diff --git a/.gitignore b/.gitignore index 9a513646e9c..8d05f8f3337 100644 --- a/.gitignore +++ b/.gitignore @@ -21,7 +21,7 @@ tests/services/baselines/local/* tests/baselines/prototyping/local/* tests/baselines/rwc/* tests/baselines/test262/* -tests/baselines/reference/projectOutput/* +tests/baselines/reference/projectOutput/* tests/baselines/local/projectOutput/* tests/services/baselines/prototyping/local/* tests/services/browser/typescriptServices.js @@ -30,6 +30,7 @@ scripts/processDiagnosticMessages.d.ts scripts/processDiagnosticMessages.js scripts/importDefinitelyTypedTests/importDefinitelyTypedTests.js src/harness/*.js +src/compiler/diagnosticInformationMap.generated.ts rwc-report.html *.swp build.json @@ -49,5 +50,6 @@ scripts/typings/ coverage/ internal/ **/.DS_Store -.settings/* -!.settings/tasks.json +.settings +.vscode/* +!.vscode/tasks.json diff --git a/.npmignore b/.npmignore index 2b75d37f70a..3af34bded4a 100644 --- a/.npmignore +++ b/.npmignore @@ -3,6 +3,11 @@ doc scripts src tests -Jakefile +internal +tslint.json +Jakefile.js +.editorconfig +.gitattributes +.settings/ .travis.yml -.settings/ \ No newline at end of file +.vscode/ \ No newline at end of file diff --git a/.vscode/tasks.json b/.vscode/tasks.json index e617f228378..9cf1c9d8f3f 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -18,6 +18,25 @@ "problemMatcher": [ "$tsc" ] + }, + { + "taskName": "lint-server", + "args": [], + "problemMatcher": { + "owner": "typescript", + "fileLocation": ["relative", "${workspaceRoot}"], + "pattern": { + "regexp": "^(warning|error)\\s+([^(]+)\\s+\\((\\d+|\\d+,\\d+|\\d+,\\d+,\\d+,\\d+)\\):\\s+(.*)$", + "severity": 1, + "file": 2, + "location": 3, + "message": 4 + }, + "watchedTaskBeginsRegExp": "^\\*\\*\\*Lint failure\\*\\*\\*$", + "watchedTaskEndsRegExp": "^\\*\\*\\* Total \\d+ failures\\.$" + }, + "showOutput": "always", + "isWatching": true } ] } \ No newline at end of file diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 41a16fff3eb..c2865280f44 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -9,7 +9,7 @@ Design changes will not be accepted at this time. If you have a design change pr ## Legal You will need to complete a Contributor License Agreement (CLA). Briefly, this agreement testifies that you are granting us permission to use the submitted change according to the terms of the project's license, and that the work being submitted is under appropriate copyright. -Please submit a Contributor License Agreement (CLA) before submitting a pull request. You may visit https://cla.microsoft.com to sign digitally. Alternatively, download the agreement ([Microsoft Contribution License Agreement.docx](https://www.codeplex.com/Download?ProjectName=typescript&DownloadId=822190) or [Microsoft Contribution License Agreement.pdf](https://www.codeplex.com/Download?ProjectName=typescript&DownloadId=921298)), sign, scan, and email it back to . Be sure to include your github user name along with the agreement. Once we have received the signed CLA, we'll review the request. Please note that we're currently only accepting pull requests of bug fixes rather than new features. +Please submit a Contributor License Agreement (CLA) before submitting a pull request. You may visit https://cla.microsoft.com to sign digitally. Alternatively, download the agreement ([Microsoft Contribution License Agreement.docx](https://www.codeplex.com/Download?ProjectName=typescript&DownloadId=822190) or [Microsoft Contribution License Agreement.pdf](https://www.codeplex.com/Download?ProjectName=typescript&DownloadId=921298)), sign, scan, and email it back to . Be sure to include your github user name along with the agreement. Once we have received the signed CLA, we'll review the request. ## Housekeeping Your pull request should: diff --git a/Jakefile.js b/Jakefile.js index c84713c18bc..5b93462d855 100644 --- a/Jakefile.js +++ b/Jakefile.js @@ -4,6 +4,7 @@ var fs = require("fs"); var os = require("os"); var path = require("path"); var child_process = require("child_process"); +var Linter = require("tslint"); // Variables var compilerDirectory = "src/compiler/"; @@ -627,10 +628,9 @@ function deleteTemporaryProjectOutput() { var testTimeout = 20000; desc("Runs the tests using the built run.js file. Syntax is jake runtests. Optional parameters 'host=', 'tests=[regex], reporter=[list|spec|json|]', debug=true."); -task("runtests", ["tests", builtLocalDirectory], function() { +task("runtests", ["build-rules", "tests", builtLocalDirectory], function() { cleanTestDirs(); var debug = process.env.debug || process.env.d; - host = "mocha" tests = process.env.test || process.env.tests || process.env.t; var light = process.env.light || false; var testConfigFile = 'test.config'; @@ -652,9 +652,16 @@ task("runtests", ["tests", builtLocalDirectory], function() { reporter = process.env.reporter || process.env.r || 'mocha-fivemat-progress-reporter'; // timeout normally isn't necessary but Travis-CI has been timing out on compiler baselines occasionally // default timeout is 2sec which really should be enough, but maybe we just need a small amount longer - var cmd = host + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + ' -t ' + testTimeout + ' ' + run; + var cmd = "mocha" + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + ' -t ' + testTimeout + ' ' + run; console.log(cmd); - exec(cmd, deleteTemporaryProjectOutput); + exec(cmd, function() { + deleteTemporaryProjectOutput(); + var lint = jake.Task['lint']; + lint.addListener('complete', function () { + complete(); + }); + lint.invoke(); + }); }, {async: true}); desc("Generates code coverage data via instanbul"); @@ -812,7 +819,6 @@ task("update-sublime", ["local", serverFile], function() { var tslintRuleDir = "scripts/tslint"; var tslintRules = ([ "nextLineRule", - "noInferrableTypesRule", "noNullRule", "booleanTriviaRule" ]); @@ -825,20 +831,94 @@ var tslintRulesOutFiles = tslintRules.map(function(p) { desc("Compiles tslint rules to js"); task("build-rules", tslintRulesOutFiles); tslintRulesFiles.forEach(function(ruleFile, i) { - compileFile(tslintRulesOutFiles[i], [ruleFile], [ruleFile], [], /*useBuiltCompiler*/ true, /*noOutFile*/ true, /*generateDeclarations*/ false, path.join(builtLocalDirectory, "tslint")); + compileFile(tslintRulesOutFiles[i], [ruleFile], [ruleFile], [], /*useBuiltCompiler*/ false, /*noOutFile*/ true, /*generateDeclarations*/ false, path.join(builtLocalDirectory, "tslint")); }); -// if the codebase were free of linter errors we could make jake runtests -// run this task automatically +function getLinterOptions() { + return { + configuration: require("./tslint.json"), + formatter: "prose", + formattersDirectory: undefined, + rulesDirectory: "built/local/tslint" + }; +} + +function lintFileContents(options, path, contents) { + var ll = new Linter(path, contents, options); + return ll.lint(); +} + +function lintFile(options, path) { + var contents = fs.readFileSync(path, "utf8"); + return lintFileContents(options, path, contents); +} + +function lintFileAsync(options, path, cb) { + fs.readFile(path, "utf8", function(err, contents) { + if (err) { + return cb(err); + } + var result = lintFileContents(options, path, contents); + cb(undefined, result); + }); +} + +var lintTargets = compilerSources.concat(harnessCoreSources); + desc("Runs tslint on the compiler sources"); task("lint", ["build-rules"], function() { - function success(f) { return function() { console.log('SUCCESS: No linter errors in ' + f + '\n'); }}; - function failure(f) { return function() { console.log('FAILURE: Please fix linting errors in ' + f + '\n') }}; - - var lintTargets = compilerSources.concat(harnessCoreSources); + var lintOptions = getLinterOptions(); for (var i in lintTargets) { - var f = lintTargets[i]; - var cmd = 'tslint --rules-dir built/local/tslint -c tslint.json ' + f; - exec(cmd, success(f), failure(f)); + var result = lintFile(lintOptions, lintTargets[i]); + if (result.failureCount > 0) { + console.log(result.output); + fail('Linter errors.', result.failureCount); + } } -}, { async: true }); +}); + +/** + * This is required because file watches on Windows get fires _twice_ + * when a file changes on some node/windows version configuations + * (node v4 and win 10, for example). By not running a lint for a file + * which already has a pending lint, we avoid duplicating our work. + * (And avoid printing duplicate results!) + */ +var lintSemaphores = {}; + +function lintWatchFile(filename) { + fs.watch(filename, {persistent: true}, function(event) { + if (event !== "change") { + return; + } + + if (!lintSemaphores[filename]) { + lintSemaphores[filename] = true; + lintFileAsync(getLinterOptions(), filename, function(err, result) { + delete lintSemaphores[filename]; + if (err) { + console.log(err); + return; + } + if (result.failureCount > 0) { + console.log("***Lint failure***"); + for (var i = 0; i < result.failures.length; i++) { + var failure = result.failures[i]; + var start = failure.startPosition.lineAndCharacter; + var end = failure.endPosition.lineAndCharacter; + console.log("warning " + filename + " (" + (start.line + 1) + "," + (start.character + 1) + "," + (end.line + 1) + "," + (end.character + 1) + "): " + failure.failure); + } + console.log("*** Total " + result.failureCount + " failures."); + } + }); + } + }); +} + +desc("Watches files for changes to rerun a lint pass"); +task("lint-server", ["build-rules"], function() { + console.log("Watching ./src for changes to linted files"); + for (var i = 0; i < lintTargets.length; i++) { + lintWatchFile(lintTargets[i]); + } +}); diff --git a/package.json b/package.json index ba8edd188e4..28f2c1b5755 100644 --- a/package.json +++ b/package.json @@ -44,7 +44,10 @@ "build": "npm run build:compiler && npm run build:tests", "build:compiler": "jake local", "build:tests": "jake tests", - "clean": "jake clean" + "clean": "jake clean", + "jake": "jake", + "lint": "jake lint", + "setup-hooks": "node scripts/link-hooks.js" }, "browser": { "buffer": false, diff --git a/scripts/hooks/post-checkout b/scripts/hooks/post-checkout new file mode 100644 index 00000000000..fb41e4e8652 --- /dev/null +++ b/scripts/hooks/post-checkout @@ -0,0 +1,2 @@ +#!/bin/sh +npm run jake -- generate-diagnostics \ No newline at end of file diff --git a/scripts/link-hooks.js b/scripts/link-hooks.js new file mode 100644 index 00000000000..33b5d4fd94f --- /dev/null +++ b/scripts/link-hooks.js @@ -0,0 +1,20 @@ +var fs = require("fs"); +var path = require("path"); + +var hooks = [ + "post-checkout" +]; + +hooks.forEach(function (hook) { + var hookInSourceControl = path.resolve(__dirname, "hooks", hook); + + if (fs.existsSync(hookInSourceControl)) { + var hookInHiddenDirectory = path.resolve(__dirname, "..", ".git", "hooks", hook); + + if (fs.existsSync(hookInHiddenDirectory)) { + fs.unlinkSync(hookInHiddenDirectory); + } + + fs.linkSync(hookInSourceControl, hookInHiddenDirectory); + } +}); \ No newline at end of file diff --git a/scripts/processDiagnosticMessages.ts b/scripts/processDiagnosticMessages.ts index 0a81b993616..1eead82d9fe 100644 --- a/scripts/processDiagnosticMessages.ts +++ b/scripts/processDiagnosticMessages.ts @@ -10,10 +10,6 @@ interface InputDiagnosticMessageTable { [msg: string]: DiagnosticDetails; } -interface IIndexable { - [key: string]: V; -} - function main(): void { var sys = ts.sys; if (sys.args.length < 1) { @@ -25,21 +21,49 @@ function main(): void { var inputFilePath = sys.args[0].replace(/\\/g, "/"); var inputStr = sys.readFile(inputFilePath); - var diagnosticMesages: InputDiagnosticMessageTable = JSON.parse(inputStr); + var diagnosticMessages: InputDiagnosticMessageTable = JSON.parse(inputStr); - var names = Utilities.getObjectKeys(diagnosticMesages); + var names = Utilities.getObjectKeys(diagnosticMessages); var nameMap = buildUniqueNameMap(names); - var infoFileOutput = buildInfoFileOutput(diagnosticMesages, nameMap); - + var infoFileOutput = buildInfoFileOutput(diagnosticMessages, nameMap); + checkForUniqueCodes(names, diagnosticMessages); + // TODO: Fix path joining var inputDirectory = inputFilePath.substr(0,inputFilePath.lastIndexOf("/")); var fileOutputPath = inputDirectory + "/diagnosticInformationMap.generated.ts"; sys.writeFile(fileOutputPath, infoFileOutput); } -function buildUniqueNameMap(names: string[]): IIndexable { - var nameMap: IIndexable = {}; +function checkForUniqueCodes(messages: string[], diagnosticTable: InputDiagnosticMessageTable) { + const originalMessageForCode: string[] = []; + let numConflicts = 0; + + for (const currentMessage of messages) { + const code = diagnosticTable[currentMessage].code; + + if (code in originalMessageForCode) { + const originalMessage = originalMessageForCode[code]; + ts.sys.write("\x1b[91m"); // High intensity red. + ts.sys.write("Error"); + ts.sys.write("\x1b[0m"); // Reset formatting. + ts.sys.write(`: Diagnostic code '${code}' conflicts between "${originalMessage}" and "${currentMessage}".`); + ts.sys.write(ts.sys.newLine + ts.sys.newLine); + + numConflicts++; + } + else { + originalMessageForCode[code] = currentMessage; + } + } + + if (numConflicts > 0) { + throw new Error(`Found ${numConflicts} conflict(s) in diagnostic codes.`); + } +} + +function buildUniqueNameMap(names: string[]): ts.Map { + var nameMap: ts.Map = {}; var uniqueNames = NameGenerator.ensureUniqueness(names, /* isCaseSensitive */ false, /* isFixed */ undefined); @@ -50,7 +74,7 @@ function buildUniqueNameMap(names: string[]): IIndexable { return nameMap; } -function buildInfoFileOutput(messageTable: InputDiagnosticMessageTable, nameMap: IIndexable): string { +function buildInfoFileOutput(messageTable: InputDiagnosticMessageTable, nameMap: ts.Map): string { var result = '// \r\n' + '/// \r\n' + @@ -172,7 +196,7 @@ module Utilities { } // Like Object.keys - export function getObjectKeys(obj: any): string[]{ + export function getObjectKeys(obj: any): string[] { var result: string[] = []; for (var name in obj) { diff --git a/scripts/tslint/nextLineRule.ts b/scripts/tslint/nextLineRule.ts index 7eec75a1baf..6d803fc7f88 100644 --- a/scripts/tslint/nextLineRule.ts +++ b/scripts/tslint/nextLineRule.ts @@ -5,8 +5,8 @@ const OPTION_CATCH = "check-catch"; const OPTION_ELSE = "check-else"; export class Rule extends Lint.Rules.AbstractRule { - public static CATCH_FAILURE_STRING = "'catch' should be on the line following the previous block's ending curly brace"; - public static ELSE_FAILURE_STRING = "'else' should be on the line following the previous block's ending curly brace"; + public static CATCH_FAILURE_STRING = "'catch' should not be on the same line as the preceeding block's curly brace"; + public static ELSE_FAILURE_STRING = "'else' should not be on the same line as the preceeding block's curly brace"; public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] { return this.applyWithWalker(new NextLineWalker(sourceFile, this.getOptions())); @@ -25,7 +25,7 @@ class NextLineWalker extends Lint.RuleWalker { if (this.hasOption(OPTION_ELSE) && !!elseKeyword) { const thenStatementEndLoc = sourceFile.getLineAndCharacterOfPosition(thenStatement.getEnd()); const elseKeywordLoc = sourceFile.getLineAndCharacterOfPosition(elseKeyword.getStart(sourceFile)); - if (thenStatementEndLoc.line !== (elseKeywordLoc.line - 1)) { + if (thenStatementEndLoc.line === elseKeywordLoc.line) { const failure = this.createFailure(elseKeyword.getStart(sourceFile), elseKeyword.getWidth(sourceFile), Rule.ELSE_FAILURE_STRING); this.addFailure(failure); } @@ -47,7 +47,7 @@ class NextLineWalker extends Lint.RuleWalker { const catchKeyword = catchClause.getFirstToken(sourceFile); const tryClosingBraceLoc = sourceFile.getLineAndCharacterOfPosition(tryClosingBrace.getEnd()); const catchKeywordLoc = sourceFile.getLineAndCharacterOfPosition(catchKeyword.getStart(sourceFile)); - if (tryClosingBraceLoc.line !== (catchKeywordLoc.line - 1)) { + if (tryClosingBraceLoc.line === catchKeywordLoc.line) { const failure = this.createFailure(catchKeyword.getStart(sourceFile), catchKeyword.getWidth(sourceFile), Rule.CATCH_FAILURE_STRING); this.addFailure(failure); } @@ -58,4 +58,4 @@ class NextLineWalker extends Lint.RuleWalker { function getFirstChildOfKind(node: ts.Node, kind: ts.SyntaxKind) { return node.getChildren().filter((child) => child.kind === kind)[0]; -} \ No newline at end of file +} diff --git a/scripts/tslint/noInferrableTypesRule.ts b/scripts/tslint/noInferrableTypesRule.ts deleted file mode 100644 index cbc0162260e..00000000000 --- a/scripts/tslint/noInferrableTypesRule.ts +++ /dev/null @@ -1,49 +0,0 @@ -/// -/// - - -export class Rule extends Lint.Rules.AbstractRule { - public static FAILURE_STRING_FACTORY = (type: string) => `LHS type (${type}) inferred by RHS expression, remove type annotation`; - - public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] { - return this.applyWithWalker(new InferrableTypeWalker(sourceFile, this.getOptions())); - } -} - -class InferrableTypeWalker extends Lint.RuleWalker { - visitVariableStatement(node: ts.VariableStatement) { - node.declarationList.declarations.forEach(e => { - if ((!!e.type) && (!!e.initializer)) { - let failure: string; - switch (e.type.kind) { - case ts.SyntaxKind.BooleanKeyword: - if (e.initializer.kind === ts.SyntaxKind.TrueKeyword || e.initializer.kind === ts.SyntaxKind.FalseKeyword) { - failure = 'boolean'; - } - break; - case ts.SyntaxKind.NumberKeyword: - if (e.initializer.kind === ts.SyntaxKind.NumericLiteral) { - failure = 'number'; - } - break; - case ts.SyntaxKind.StringKeyword: - switch (e.initializer.kind) { - case ts.SyntaxKind.StringLiteral: - case ts.SyntaxKind.NoSubstitutionTemplateLiteral: - case ts.SyntaxKind.TemplateExpression: - failure = 'string'; - break; - default: - break; - } - break; - } - if (failure) { - this.addFailure(this.createFailure(e.type.getStart(), e.type.getWidth(), Rule.FAILURE_STRING_FACTORY(failure))); - } - } - }); - - super.visitVariableStatement(node); - } -} diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 16f2a59a58d..c12a9afad62 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -88,6 +88,7 @@ namespace ts { let container: Node; let blockScopeContainer: Node; let lastContainer: Node; + let seenThisKeyword: boolean; // If this file is an external module, then it is automatically in strict-mode according to // ES6. If it is not an external module, then we'll determine if it is in strict mode or @@ -184,8 +185,9 @@ namespace ts { function declareSymbol(symbolTable: SymbolTable, parent: Symbol, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags): Symbol { Debug.assert(!hasDynamicName(node)); + let isDefaultExport = node.flags & NodeFlags.Default; // The exported symbol for an export default function/class node is always named "default" - let name = node.flags & NodeFlags.Default && parent ? "default" : getDeclarationName(node); + let name = isDefaultExport && parent ? "default" : getDeclarationName(node); let symbol: Symbol; if (name !== undefined) { @@ -226,6 +228,13 @@ namespace ts { let message = symbol.flags & SymbolFlags.BlockScopedVariable ? Diagnostics.Cannot_redeclare_block_scoped_variable_0 : Diagnostics.Duplicate_identifier_0; + + forEach(symbol.declarations, declaration => { + if (declaration.flags & NodeFlags.Default) { + message = Diagnostics.A_module_cannot_have_multiple_default_exports; + } + }); + forEach(symbol.declarations, declaration => { file.bindDiagnostics.push(createDiagnosticForNode(declaration.name || declaration, message, getDisplayName(declaration))); }); @@ -329,7 +338,14 @@ namespace ts { blockScopeContainer.locals = undefined; } - forEachChild(node, bind); + if (node.kind === SyntaxKind.InterfaceDeclaration) { + seenThisKeyword = false; + forEachChild(node, bind); + node.flags = seenThisKeyword ? node.flags | NodeFlags.ContainsThis : node.flags & ~NodeFlags.ContainsThis; + } + else { + forEachChild(node, bind); + } container = saveContainer; parent = saveParent; @@ -851,6 +867,9 @@ namespace ts { return checkStrictModePrefixUnaryExpression(node); case SyntaxKind.WithStatement: return checkStrictModeWithStatement(node); + case SyntaxKind.ThisKeyword: + seenThisKeyword = true; + return; case SyntaxKind.TypeParameter: return declareSymbolAndAddToSymbolTable(node, SymbolFlags.TypeParameter, SymbolFlags.TypeParameterExcludes); diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 2aee597092d..903addec182 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -38,12 +38,14 @@ namespace ts { let Signature = objectAllocator.getSignatureConstructor(); let typeCount = 0; + let symbolCount = 0; let emptyArray: any[] = []; let emptySymbols: SymbolTable = {}; let compilerOptions = host.getCompilerOptions(); let languageVersion = compilerOptions.target || ScriptTarget.ES3; + let modulekind = compilerOptions.module ? compilerOptions.module : languageVersion === ScriptTarget.ES6 ? ModuleKind.ES6 : ModuleKind.None; let emitResolver = createResolver(); @@ -53,7 +55,7 @@ namespace ts { let checker: TypeChecker = { getNodeCount: () => sum(host.getSourceFiles(), "nodeCount"), getIdentifierCount: () => sum(host.getSourceFiles(), "identifierCount"), - getSymbolCount: () => sum(host.getSourceFiles(), "symbolCount"), + getSymbolCount: () => sum(host.getSourceFiles(), "symbolCount") + symbolCount, getTypeCount: () => typeCount, isUndefinedSymbol: symbol => symbol === undefinedSymbol, isArgumentsSymbol: symbol => symbol === argumentsSymbol, @@ -242,6 +244,7 @@ namespace ts { } function createSymbol(flags: SymbolFlags, name: string): Symbol { + symbolCount++; return new Symbol(flags, name); } @@ -607,8 +610,11 @@ namespace ts { // block - scope variable and namespace module. However, only when we // try to resolve name in /*1*/ which is used in variable position, // we want to check for block- scoped - if (meaning & SymbolFlags.BlockScopedVariable && result.flags & SymbolFlags.BlockScopedVariable) { - checkResolvedBlockScopedVariable(result, errorLocation); + if (meaning & SymbolFlags.BlockScopedVariable) { + const exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result); + if (exportOrLocalSymbol.flags & SymbolFlags.BlockScopedVariable) { + checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation); + } } } return result; @@ -947,12 +953,6 @@ namespace ts { return symbol.flags & meaning ? symbol : resolveAlias(symbol); } - function isExternalModuleNameRelative(moduleName: string): boolean { - // TypeScript 1.0 spec (April 2014): 11.2.1 - // An external module name is "relative" if the first term is "." or "..". - return moduleName.substr(0, 2) === "./" || moduleName.substr(0, 3) === "../" || moduleName.substr(0, 2) === ".\\" || moduleName.substr(0, 3) === "..\\"; - } - function resolveExternalModuleName(location: Node, moduleReferenceExpression: Expression): Symbol { if (moduleReferenceExpression.kind !== SyntaxKind.StringLiteral) { return; @@ -1592,6 +1592,7 @@ namespace ts { function buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, globalFlags?: TypeFormatFlags, symbolStack?: Symbol[]) { let globalFlagsToPass = globalFlags & TypeFormatFlags.WriteOwnNameForAnyLike; + let inObjectTypeLiteral = false; return writeType(type, globalFlags); function writeType(type: Type, flags: TypeFormatFlags) { @@ -1602,6 +1603,12 @@ namespace ts { ? "any" : (type).intrinsicName); } + else if (type.flags & TypeFlags.ThisType) { + if (inObjectTypeLiteral) { + writer.reportInaccessibleThisError(); + } + writer.writeKeyword("this"); + } else if (type.flags & TypeFlags.Reference) { writeTypeReference(type, flags); } @@ -1645,11 +1652,10 @@ namespace ts { } } - function writeSymbolTypeReference(symbol: Symbol, typeArguments: Type[], pos: number, end: number) { - // Unnamed function expressions, arrow functions, and unnamed class expressions have reserved names that - // we don't want to display - if (!isReservedMemberName(symbol.name)) { - buildSymbolDisplay(symbol, writer, enclosingDeclaration, SymbolFlags.Type); + function writeSymbolTypeReference(symbol: Symbol, typeArguments: Type[], pos: number, end: number, flags: TypeFormatFlags) { + // Unnamed function expressions and arrow functions have reserved names that we don't want to display + if (symbol.flags & SymbolFlags.Class || !isReservedMemberName(symbol.name)) { + buildSymbolDisplay(symbol, writer, enclosingDeclaration, SymbolFlags.Type, SymbolFormatFlags.None, flags); } if (pos < end) { writePunctuation(writer, SyntaxKind.LessThanToken); @@ -1664,7 +1670,7 @@ namespace ts { } function writeTypeReference(type: TypeReference, flags: TypeFormatFlags) { - let typeArguments = type.typeArguments; + let typeArguments = type.typeArguments || emptyArray; if (type.target === globalArrayType && !(flags & TypeFormatFlags.WriteArrayAsGenericType)) { writeType(typeArguments[0], TypeFormatFlags.InElementType); writePunctuation(writer, SyntaxKind.OpenBracketToken); @@ -1688,12 +1694,13 @@ namespace ts { // 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)) { - writeSymbolTypeReference(parent, typeArguments, start, i); + writeSymbolTypeReference(parent, typeArguments, start, i, flags); writePunctuation(writer, SyntaxKind.DotToken); } } } - writeSymbolTypeReference(type.symbol, typeArguments, i, typeArguments.length); + let typeParameterCount = (type.target.typeParameters || emptyArray).length; + writeSymbolTypeReference(type.symbol, typeArguments, i, typeParameterCount, flags); } } @@ -1816,6 +1823,8 @@ namespace ts { } } + let saveInObjectTypeLiteral = inObjectTypeLiteral; + inObjectTypeLiteral = true; writePunctuation(writer, SyntaxKind.OpenBraceToken); writer.writeLine(); writer.increaseIndent(); @@ -1888,6 +1897,7 @@ namespace ts { } writer.decreaseIndent(); writePunctuation(writer, SyntaxKind.CloseBraceToken); + inObjectTypeLiteral = saveInObjectTypeLiteral; } } @@ -2202,7 +2212,7 @@ namespace ts { /** * Push an entry on the type resolution stack. If an entry with the given target and the given property name - * is already on the stack, and no entries in between already have a type, then a circularity has occurred. + * is already on the stack, and no entries in between already have a type, then a circularity has occurred. * In this case, the result values of the existing entry and all entries pushed after it are changed to false, * and the value false is returned. Otherwise, the new entry is just pushed onto the stack, and true is returned. * In order to see if the same query has already been done before, the target object and the propertyName both @@ -2293,10 +2303,17 @@ namespace ts { return type && (type.flags & TypeFlags.Any) !== 0; } + // Return the type of a binding element parent. We check SymbolLinks first to see if a type has been + // assigned by contextual typing. + function getTypeForBindingElementParent(node: VariableLikeDeclaration) { + let symbol = getSymbolOfNode(node); + return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node); + } + // Return the inferred type for a binding element function getTypeForBindingElement(declaration: BindingElement): Type { let pattern = declaration.parent; - let parentType = getTypeForVariableLikeDeclaration(pattern.parent); + let parentType = getTypeForBindingElementParent(pattern.parent); // If parent has the unknown (error) type, then so does this binding element if (parentType === unknownType) { return unknownType; @@ -2372,7 +2389,7 @@ namespace ts { if (isBindingPattern(declaration.parent)) { return getTypeForBindingElement(declaration); } - + // Use type from type annotation if one is present if (declaration.type) { return getTypeFromTypeNode(declaration.type); @@ -2393,12 +2410,12 @@ namespace ts { return type; } } - + // Use the type of the initializer expression if one is present if (declaration.initializer) { return checkExpressionCached(declaration.initializer); } - + // If it is a short-hand property assignment, use the type of the identifier if (declaration.kind === SyntaxKind.ShorthandPropertyAssignment) { return checkIdentifier(declaration.name); @@ -2493,10 +2510,10 @@ namespace ts { // tools see the actual type. return declaration.kind !== SyntaxKind.PropertyAssignment ? getWidenedType(type) : type; } - + // Rest parameters default to type any[], other parameters default to type any type = declaration.dotDotDotToken ? anyArrayType : anyType; - + // Report implicit any errors unless this is a private property within an ambient declaration if (reportErrors && compilerOptions.noImplicitAny) { let root = getRootDeclaration(declaration); @@ -2882,6 +2899,31 @@ namespace ts { } } + // Returns true if the interface given by the symbol is free of "this" references. Specifically, the result is + // true if the interface itself contains no references to "this" in its body, if all base types are interfaces, + // and if none of the base interfaces have a "this" type. + function isIndependentInterface(symbol: Symbol): boolean { + for (let declaration of symbol.declarations) { + if (declaration.kind === SyntaxKind.InterfaceDeclaration) { + if (declaration.flags & NodeFlags.ContainsThis) { + return false; + } + let baseTypeNodes = getInterfaceBaseTypeNodes(declaration); + if (baseTypeNodes) { + for (let node of baseTypeNodes) { + if (isSupportedExpressionWithTypeArguments(node)) { + let baseSymbol = resolveEntityName(node.expression, SymbolFlags.Type, /*ignoreErrors*/ true); + if (!baseSymbol || !(baseSymbol.flags & SymbolFlags.Interface) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) { + return false; + } + } + } + } + } + } + return true; + } + function getDeclaredTypeOfClassOrInterface(symbol: Symbol): InterfaceType { let links = getSymbolLinks(symbol); if (!links.declaredType) { @@ -2889,7 +2931,12 @@ namespace ts { let type = links.declaredType = createObjectType(kind, symbol); let outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol); let localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); - if (outerTypeParameters || localTypeParameters) { + // A class or interface is generic if it has type parameters or a "this" type. We always give classes a "this" type + // because it is not feasible to analyze all members to determine if the "this" type escapes the class (in particular, + // property types inferred from initializers and method return types inferred from return statements are very hard + // to exhaustively analyze). We give interfaces a "this" type if we can't definitely determine that they are free of + // "this" references. + if (outerTypeParameters || localTypeParameters || kind === TypeFlags.Class || !isIndependentInterface(symbol)) { type.flags |= TypeFlags.Reference; type.typeParameters = concatenate(outerTypeParameters, localTypeParameters); type.outerTypeParameters = outerTypeParameters; @@ -2898,6 +2945,9 @@ namespace ts { (type).instantiations[getTypeListId(type.typeParameters)] = type; (type).target = type; (type).typeArguments = type.typeParameters; + type.thisType = createType(TypeFlags.TypeParameter | TypeFlags.ThisType); + type.thisType.symbol = symbol; + type.thisType.constraint = getTypeWithThisArgument(type); } } return links.declaredType; @@ -2982,6 +3032,82 @@ namespace ts { return unknownType; } + // A type reference is considered independent if each type argument is considered independent. + function isIndependentTypeReference(node: TypeReferenceNode): boolean { + if (node.typeArguments) { + for (let typeNode of node.typeArguments) { + if (!isIndependentType(typeNode)) { + return false; + } + } + } + return true; + } + + // A type is considered independent if it the any, string, number, boolean, symbol, or void keyword, a string + // literal type, an array with an element type that is considered independent, or a type reference that is + // considered independent. + function isIndependentType(node: TypeNode): boolean { + switch (node.kind) { + case SyntaxKind.AnyKeyword: + case SyntaxKind.StringKeyword: + case SyntaxKind.NumberKeyword: + case SyntaxKind.BooleanKeyword: + case SyntaxKind.SymbolKeyword: + case SyntaxKind.VoidKeyword: + case SyntaxKind.StringLiteral: + return true; + case SyntaxKind.ArrayType: + return isIndependentType((node).elementType); + case SyntaxKind.TypeReference: + return isIndependentTypeReference(node); + } + return false; + } + + // A variable-like declaration is considered independent (free of this references) if it has a type annotation + // that specifies an independent type, or if it has no type annotation and no initializer (and thus of type any). + function isIndependentVariableLikeDeclaration(node: VariableLikeDeclaration): boolean { + return node.type && isIndependentType(node.type) || !node.type && !node.initializer; + } + + // A function-like declaration is considered independent (free of this references) if it has a return type + // annotation that is considered independent and if each parameter is considered independent. + function isIndependentFunctionLikeDeclaration(node: FunctionLikeDeclaration): boolean { + if (node.kind !== SyntaxKind.Constructor && (!node.type || !isIndependentType(node.type))) { + return false; + } + for (let parameter of node.parameters) { + if (!isIndependentVariableLikeDeclaration(parameter)) { + return false; + } + } + return true; + } + + // Returns true if the class or interface member given by the symbol is free of "this" references. The + // function may return false for symbols that are actually free of "this" references because it is not + // feasible to perform a complete analysis in all cases. In particular, property members with types + // inferred from their initializers and function members with inferred return types are convervatively + // assumed not to be free of "this" references. + function isIndependentMember(symbol: Symbol): boolean { + if (symbol.declarations && symbol.declarations.length === 1) { + let declaration = symbol.declarations[0]; + if (declaration) { + switch (declaration.kind) { + case SyntaxKind.PropertyDeclaration: + case SyntaxKind.PropertySignature: + return isIndependentVariableLikeDeclaration(declaration); + case SyntaxKind.MethodDeclaration: + case SyntaxKind.MethodSignature: + case SyntaxKind.Constructor: + return isIndependentFunctionLikeDeclaration(declaration); + } + } + } + return false; + } + function createSymbolTable(symbols: Symbol[]): SymbolTable { let result: SymbolTable = {}; for (let symbol of symbols) { @@ -2990,10 +3116,12 @@ namespace ts { return result; } - function createInstantiatedSymbolTable(symbols: Symbol[], mapper: TypeMapper): SymbolTable { + // The mappingThisOnly flag indicates that the only type parameter being mapped is "this". When the flag is true, + // we check symbols to see if we can quickly conclude they are free of "this" references, thus needing no instantiation. + function createInstantiatedSymbolTable(symbols: Symbol[], mapper: TypeMapper, mappingThisOnly: boolean): SymbolTable { let result: SymbolTable = {}; for (let symbol of symbols) { - result[symbol.name] = instantiateSymbol(symbol, mapper); + result[symbol.name] = mappingThisOnly && isIndependentMember(symbol) ? symbol : instantiateSymbol(symbol, mapper); } return result; } @@ -3026,44 +3154,57 @@ namespace ts { return type; } - function resolveClassOrInterfaceMembers(type: InterfaceType): void { - let target = resolveDeclaredMembers(type); - let members = target.symbol.members; - let callSignatures = target.declaredCallSignatures; - let constructSignatures = target.declaredConstructSignatures; - let stringIndexType = target.declaredStringIndexType; - let numberIndexType = target.declaredNumberIndexType; - let baseTypes = getBaseTypes(target); + function getTypeWithThisArgument(type: ObjectType, thisArgument?: Type) { + if (type.flags & TypeFlags.Reference) { + return createTypeReference((type).target, + concatenate((type).typeArguments, [thisArgument || (type).target.thisType])); + } + return type; + } + + function resolveObjectTypeMembers(type: ObjectType, source: InterfaceTypeWithDeclaredMembers, typeParameters: TypeParameter[], typeArguments: Type[]) { + let mapper = identityMapper; + let members = source.symbol.members; + let callSignatures = source.declaredCallSignatures; + let constructSignatures = source.declaredConstructSignatures; + let stringIndexType = source.declaredStringIndexType; + let numberIndexType = source.declaredNumberIndexType; + if (!rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) { + mapper = createTypeMapper(typeParameters, typeArguments); + members = createInstantiatedSymbolTable(source.declaredProperties, mapper, /*mappingThisOnly*/ typeParameters.length === 1); + callSignatures = instantiateList(source.declaredCallSignatures, mapper, instantiateSignature); + constructSignatures = instantiateList(source.declaredConstructSignatures, mapper, instantiateSignature); + stringIndexType = instantiateType(source.declaredStringIndexType, mapper); + numberIndexType = instantiateType(source.declaredNumberIndexType, mapper); + } + let baseTypes = getBaseTypes(source); if (baseTypes.length) { - members = createSymbolTable(target.declaredProperties); + if (members === source.symbol.members) { + members = createSymbolTable(source.declaredProperties); + } + let thisArgument = lastOrUndefined(typeArguments); for (let baseType of baseTypes) { - addInheritedMembers(members, getPropertiesOfObjectType(baseType)); - callSignatures = concatenate(callSignatures, getSignaturesOfType(baseType, SignatureKind.Call)); - constructSignatures = concatenate(constructSignatures, getSignaturesOfType(baseType, SignatureKind.Construct)); - stringIndexType = stringIndexType || getIndexTypeOfType(baseType, IndexKind.String); - numberIndexType = numberIndexType || getIndexTypeOfType(baseType, IndexKind.Number); + let instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType; + addInheritedMembers(members, getPropertiesOfObjectType(instantiatedBaseType)); + callSignatures = concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, SignatureKind.Call)); + constructSignatures = concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, SignatureKind.Construct)); + stringIndexType = stringIndexType || getIndexTypeOfType(instantiatedBaseType, IndexKind.String); + numberIndexType = numberIndexType || getIndexTypeOfType(instantiatedBaseType, IndexKind.Number); } } setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); } + function resolveClassOrInterfaceMembers(type: InterfaceType): void { + resolveObjectTypeMembers(type, resolveDeclaredMembers(type), emptyArray, emptyArray); + } + function resolveTypeReferenceMembers(type: TypeReference): void { - let target = resolveDeclaredMembers(type.target); - let mapper = createTypeMapper(target.typeParameters, type.typeArguments); - let members = createInstantiatedSymbolTable(target.declaredProperties, mapper); - let callSignatures = instantiateList(target.declaredCallSignatures, mapper, instantiateSignature); - let constructSignatures = instantiateList(target.declaredConstructSignatures, mapper, instantiateSignature); - let stringIndexType = target.declaredStringIndexType ? instantiateType(target.declaredStringIndexType, mapper) : undefined; - let numberIndexType = target.declaredNumberIndexType ? instantiateType(target.declaredNumberIndexType, mapper) : undefined; - forEach(getBaseTypes(target), baseType => { - let instantiatedBaseType = instantiateType(baseType, mapper); - addInheritedMembers(members, getPropertiesOfObjectType(instantiatedBaseType)); - callSignatures = concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, SignatureKind.Call)); - constructSignatures = concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, SignatureKind.Construct)); - stringIndexType = stringIndexType || getIndexTypeOfType(instantiatedBaseType, IndexKind.String); - numberIndexType = numberIndexType || getIndexTypeOfType(instantiatedBaseType, IndexKind.Number); - }); - setObjectTypeMembers(type, members, callSignatures, constructSignatures, stringIndexType, numberIndexType); + let source = resolveDeclaredMembers(type.target); + let typeParameters = concatenate(source.typeParameters, [source.thisType]); + let typeArguments = type.typeArguments && type.typeArguments.length === typeParameters.length ? + type.typeArguments : concatenate(type.typeArguments, [type]); + resolveObjectTypeMembers(type, source, typeParameters, typeArguments); } function createSignature(declaration: SignatureDeclaration, typeParameters: TypeParameter[], parameters: Symbol[], @@ -3118,7 +3259,9 @@ namespace ts { } function resolveTupleTypeMembers(type: TupleType) { - let arrayType = resolveStructuredTypeMembers(createArrayType(getUnionType(type.elementTypes, /*noSubtypeReduction*/ true))); + let arrayElementType = getUnionType(type.elementTypes, /*noSubtypeReduction*/ true); + // Make the tuple type itself the 'this' type by including an extra type argument + let arrayType = resolveStructuredTypeMembers(createTypeFromGenericGlobalType(globalArrayType, [arrayElementType, type])); let members = createTupleTypeMemberSymbols(type.elementTypes); addInheritedMembers(members, arrayType.properties); setObjectTypeMembers(type, members, arrayType.callSignatures, arrayType.constructSignatures, arrayType.stringIndexType, arrayType.numberIndexType); @@ -3231,7 +3374,7 @@ namespace ts { setObjectTypeMembers(type, emptySymbols, callSignatures, constructSignatures, stringIndexType, numberIndexType); } - function resolveAnonymousTypeMembers(type: ObjectType) { + function resolveAnonymousTypeMembers(type: AnonymousType) { let symbol = type.symbol; let members: SymbolTable; let callSignatures: Signature[]; @@ -3239,7 +3382,14 @@ namespace ts { let stringIndexType: Type; let numberIndexType: Type; - if (symbol.flags & SymbolFlags.TypeLiteral) { + if (type.target) { + members = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, /*mappingThisOnly*/ false); + callSignatures = instantiateList(getSignaturesOfType(type.target, SignatureKind.Call), type.mapper, instantiateSignature); + constructSignatures = instantiateList(getSignaturesOfType(type.target, SignatureKind.Construct), type.mapper, instantiateSignature); + stringIndexType = instantiateType(getIndexTypeOfType(type.target, IndexKind.String), type.mapper); + numberIndexType = instantiateType(getIndexTypeOfType(type.target, IndexKind.Number), type.mapper); + } + else if (symbol.flags & SymbolFlags.TypeLiteral) { members = symbol.members; callSignatures = getSignaturesOfSymbol(members["__call"]); constructSignatures = getSignaturesOfSymbol(members["__new"]); @@ -3277,11 +3427,14 @@ namespace ts { function resolveStructuredTypeMembers(type: ObjectType): ResolvedType { if (!(type).members) { - if (type.flags & (TypeFlags.Class | TypeFlags.Interface)) { + if (type.flags & TypeFlags.Reference) { + resolveTypeReferenceMembers(type); + } + else if (type.flags & (TypeFlags.Class | TypeFlags.Interface)) { resolveClassOrInterfaceMembers(type); } else if (type.flags & TypeFlags.Anonymous) { - resolveAnonymousTypeMembers(type); + resolveAnonymousTypeMembers(type); } else if (type.flags & TypeFlags.Tuple) { resolveTupleTypeMembers(type); @@ -3292,9 +3445,6 @@ namespace ts { else if (type.flags & TypeFlags.Intersection) { resolveIntersectionTypeMembers(type); } - else { - resolveTypeReferenceMembers(type); - } } return type; } @@ -3760,22 +3910,24 @@ namespace ts { } function getTypeListId(types: Type[]) { - switch (types.length) { - case 1: - return "" + types[0].id; - case 2: - return types[0].id + "," + types[1].id; - default: - let result = ""; - for (let i = 0; i < types.length; i++) { - if (i > 0) { - result += ","; + if (types) { + switch (types.length) { + case 1: + return "" + types[0].id; + case 2: + return types[0].id + "," + types[1].id; + default: + let result = ""; + for (let i = 0; i < types.length; i++) { + if (i > 0) { + result += ","; + } + result += types[i].id; } - - result += types[i].id; - } - return result; + return result; + } } + return ""; } // This function is used to propagate certain flags when creating new object type references and union types. @@ -3794,7 +3946,7 @@ namespace ts { let id = getTypeListId(typeArguments); let type = target.instantiations[id]; if (!type) { - let flags = TypeFlags.Reference | getPropagatingFlagsOfTypes(typeArguments); + let flags = TypeFlags.Reference | (typeArguments ? getPropagatingFlagsOfTypes(typeArguments) : 0); type = target.instantiations[id] = createObjectType(flags, target.symbol); type.target = target; type.typeArguments = typeArguments; @@ -3853,8 +4005,8 @@ namespace ts { // Get type from reference to class or interface function getTypeFromClassOrInterfaceReference(node: TypeReferenceNode | ExpressionWithTypeArguments, symbol: Symbol): Type { - let type = getDeclaredTypeOfSymbol(symbol); - let typeParameters = (type).localTypeParameters; + let type = getDeclaredTypeOfSymbol(symbol); + let typeParameters = type.localTypeParameters; if (typeParameters) { if (!node.typeArguments || node.typeArguments.length !== typeParameters.length) { error(node, Diagnostics.Generic_type_0_requires_1_type_argument_s, typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType), typeParameters.length); @@ -3863,8 +4015,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. - return createTypeReference(type, concatenate((type).outerTypeParameters, - map(node.typeArguments, getTypeFromTypeNode))); + return createTypeReference(type, concatenate(type.outerTypeParameters, map(node.typeArguments, getTypeFromTypeNode))); } if (node.typeArguments) { error(node, Diagnostics.Type_0_is_not_generic, typeToString(type)); @@ -4020,20 +4171,20 @@ namespace ts { /** * Instantiates a global type that is generic with some element type, and returns that instantiation. */ - function createTypeFromGenericGlobalType(genericGlobalType: GenericType, elementType: Type): Type { - return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, [elementType]) : emptyObjectType; + function createTypeFromGenericGlobalType(genericGlobalType: GenericType, typeArguments: Type[]): Type { + return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, typeArguments) : emptyObjectType; } function createIterableType(elementType: Type): Type { - return createTypeFromGenericGlobalType(globalIterableType, elementType); + return createTypeFromGenericGlobalType(globalIterableType, [elementType]); } function createIterableIteratorType(elementType: Type): Type { - return createTypeFromGenericGlobalType(globalIterableIteratorType, elementType); + return createTypeFromGenericGlobalType(globalIterableIteratorType, [elementType]); } function createArrayType(elementType: Type): Type { - return createTypeFromGenericGlobalType(globalArrayType, elementType); + return createTypeFromGenericGlobalType(globalArrayType, [elementType]); } function getTypeFromArrayTypeNode(node: ArrayTypeNode): Type { @@ -4222,6 +4373,26 @@ namespace ts { return links.resolvedType; } + function getThisType(node: TypeNode): Type { + let container = getThisContainer(node, /*includeArrowFunctions*/ false); + let parent = container && container.parent; + if (parent && (isClassLike(parent) || parent.kind === SyntaxKind.InterfaceDeclaration)) { + if (!(container.flags & NodeFlags.Static)) { + return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType; + } + } + error(node, Diagnostics.A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface); + return unknownType; + } + + function getTypeFromThisTypeNode(node: TypeNode): Type { + let links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getThisType(node); + } + return links.resolvedType; + } + function getTypeFromTypeNode(node: TypeNode): Type { switch (node.kind) { case SyntaxKind.AnyKeyword: @@ -4236,6 +4407,8 @@ namespace ts { return esSymbolType; case SyntaxKind.VoidKeyword: return voidType; + case SyntaxKind.ThisKeyword: + return getTypeFromThisTypeNode(node); case SyntaxKind.StringLiteral: return getTypeFromStringLiteral(node); case SyntaxKind.TypeReference: @@ -4338,7 +4511,7 @@ namespace ts { } return t; }; - + mapper.context = context; return mapper; } @@ -4380,7 +4553,7 @@ namespace ts { } let result = createSignature(signature.declaration, freshTypeParameters, instantiateList(signature.parameters, mapper, instantiateSymbol), - signature.resolvedReturnType ? instantiateType(signature.resolvedReturnType, mapper) : undefined, + instantiateType(signature.resolvedReturnType, mapper), freshTypePredicate, signature.minArgumentCount, signature.hasRestParameter, signature.hasStringLiterals); result.target = signature; @@ -4412,7 +4585,7 @@ namespace ts { return result; } - function instantiateAnonymousType(type: ObjectType, mapper: TypeMapper): ObjectType { + function instantiateAnonymousType(type: AnonymousType, mapper: TypeMapper): ObjectType { if (mapper.instantiations) { let cachedType = mapper.instantiations[type.id]; if (cachedType) { @@ -4423,27 +4596,21 @@ namespace ts { mapper.instantiations = []; } // Mark the anonymous type as instantiated such that our infinite instantiation detection logic can recognize it - let result = createObjectType(TypeFlags.Anonymous | TypeFlags.Instantiated, type.symbol); - result.properties = instantiateList(getPropertiesOfObjectType(type), mapper, instantiateSymbol); - result.members = createSymbolTable(result.properties); - result.callSignatures = instantiateList(getSignaturesOfType(type, SignatureKind.Call), mapper, instantiateSignature); - result.constructSignatures = instantiateList(getSignaturesOfType(type, SignatureKind.Construct), mapper, instantiateSignature); - let stringIndexType = getIndexTypeOfType(type, IndexKind.String); - let numberIndexType = getIndexTypeOfType(type, IndexKind.Number); - if (stringIndexType) result.stringIndexType = instantiateType(stringIndexType, mapper); - if (numberIndexType) result.numberIndexType = instantiateType(numberIndexType, mapper); + let result = createObjectType(TypeFlags.Anonymous | TypeFlags.Instantiated, type.symbol); + result.target = type; + result.mapper = mapper; mapper.instantiations[type.id] = result; return result; } function instantiateType(type: Type, mapper: TypeMapper): Type { - if (mapper !== identityMapper) { + if (type && mapper !== identityMapper) { if (type.flags & TypeFlags.TypeParameter) { return mapper(type); } if (type.flags & TypeFlags.Anonymous) { return type.symbol && type.symbol.flags & (SymbolFlags.Function | SymbolFlags.Method | SymbolFlags.Class | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral) ? - instantiateAnonymousType(type, mapper) : type; + instantiateAnonymousType(type, mapper) : type; } if (type.flags & TypeFlags.Reference) { return createTypeReference((type).target, instantiateList((type).typeArguments, mapper, instantiateType)); @@ -4690,7 +4857,7 @@ namespace ts { else { if (source.flags & TypeFlags.Reference && target.flags & TypeFlags.Reference && (source).target === (target).target) { // We have type references to same target type, see if relationship holds for all type arguments - if (result = typesRelatedTo((source).typeArguments, (target).typeArguments, reportErrors)) { + if (result = typeArgumentsRelatedTo(source, target, reportErrors)) { return result; } } @@ -4721,7 +4888,7 @@ namespace ts { if (source.flags & TypeFlags.ObjectType && target.flags & TypeFlags.ObjectType) { if (source.flags & TypeFlags.Reference && target.flags & TypeFlags.Reference && (source).target === (target).target) { // We have type references to same target type, see if all type arguments are identical - if (result = typesRelatedTo((source).typeArguments, (target).typeArguments, /*reportErrors*/ false)) { + if (result = typeArgumentsRelatedTo(source, target, /*reportErrors*/ false)) { return result; } } @@ -4772,7 +4939,7 @@ namespace ts { // We know *exactly* where things went wrong when comparing the types. // Use this property as the error node as this will be more helpful in // reasoning about what went wrong. - errorNode = prop.valueDeclaration + errorNode = prop.valueDeclaration; reportError(Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(prop), typeToString(target)); @@ -4843,9 +5010,14 @@ namespace ts { return result; } - function typesRelatedTo(sources: Type[], targets: Type[], reportErrors: boolean): Ternary { + function typeArgumentsRelatedTo(source: TypeReference, target: TypeReference, reportErrors: boolean): Ternary { + let sources = source.typeArguments || emptyArray; + let targets = target.typeArguments || emptyArray; + if (sources.length !== targets.length && relation === identityRelation) { + return Ternary.False; + } let result = Ternary.True; - for (let i = 0, len = sources.length; i < len; i++) { + for (let i = 0; i < targets.length; i++) { let related = isRelatedTo(sources[i], targets[i], reportErrors); if (!related) { return Ternary.False; @@ -5072,9 +5244,9 @@ namespace ts { if (kind === SignatureKind.Construct) { // Only want to compare the construct signatures for abstractness guarantees. - + // Because the "abstractness" of a class is the same across all construct signatures - // (internally we are checking the corresponding declaration), it is enough to perform + // (internally we are checking the corresponding declaration), it is enough to perform // the check and report an error once over all pairs of source and target construct signatures. // // sourceSig and targetSig are (possibly) undefined. @@ -5744,9 +5916,10 @@ namespace ts { } else if (source.flags & TypeFlags.Reference && target.flags & TypeFlags.Reference && (source).target === (target).target) { // If source and target are references to the same generic type, infer from type arguments - let sourceTypes = (source).typeArguments; - let targetTypes = (target).typeArguments; - for (let i = 0; i < sourceTypes.length; i++) { + let sourceTypes = (source).typeArguments || emptyArray; + let targetTypes = (target).typeArguments || emptyArray; + let count = sourceTypes.length < targetTypes.length ? sourceTypes.length : targetTypes.length; + for (let i = 0; i < count; i++) { inferFromTypes(sourceTypes[i], targetTypes[i]); } } @@ -6241,7 +6414,7 @@ namespace ts { return getUnionType(assignableConstituents); } } - + if (isTypeAssignableTo(narrowedTypeCandidate, originalType)) { // Narrow to the target type if it's assignable to the current type return narrowedTypeCandidate; @@ -6448,7 +6621,7 @@ namespace ts { if (isClassLike(container.parent)) { let symbol = getSymbolOfNode(container.parent); - return container.flags & NodeFlags.Static ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol); + return container.flags & NodeFlags.Static ? getTypeOfSymbol(symbol) : (getDeclaredTypeOfSymbol(symbol)).thisType; } return anyType; } @@ -6468,46 +6641,46 @@ namespace ts { let classType = classDeclaration && getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration)); let baseClassType = classType && getBaseTypes(classType)[0]; - let container = getSuperContainer(node, /*includeFunctions*/ true); + let container = getSuperContainer(node, /*includeFunctions*/ true); let needToCaptureLexicalThis = false; - if (!isCallExpression) { - // adjust the container reference in case if super is used inside arrow functions with arbitrary deep nesting + if (!isCallExpression) { + // adjust the container reference in case if super is used inside arrow functions with arbitrary deep nesting while (container && container.kind === SyntaxKind.ArrowFunction) { container = getSuperContainer(container, /*includeFunctions*/ true); needToCaptureLexicalThis = languageVersion < ScriptTarget.ES6; } } - + let canUseSuperExpression = isLegalUsageOfSuperExpression(container); let nodeCheckFlag: NodeCheckFlags = 0; - - // always set NodeCheckFlags for 'super' expression node - if (canUseSuperExpression) { + + // always set NodeCheckFlags for 'super' expression node + if (canUseSuperExpression) { if ((container.flags & NodeFlags.Static) || isCallExpression) { nodeCheckFlag = NodeCheckFlags.SuperStatic; } else { nodeCheckFlag = NodeCheckFlags.SuperInstance; } - + getNodeLinks(node).flags |= nodeCheckFlag; - + if (needToCaptureLexicalThis) { // call expressions are allowed only in constructors so they should always capture correct 'this' // super property access expressions can also appear in arrow functions - // in this case they should also use correct lexical this captureLexicalThis(node.parent, container); - } + } } - + if (!baseClassType) { if (!classDeclaration || !getClassExtendsHeritageClauseElement(classDeclaration)) { error(node, Diagnostics.super_can_only_be_referenced_in_a_derived_class); } - return unknownType; + return unknownType; } - + if (!canUseSuperExpression) { if (container && container.kind === SyntaxKind.ComputedPropertyName) { error(node, Diagnostics.super_cannot_be_referenced_in_a_computed_property_name); @@ -6518,20 +6691,20 @@ namespace ts { else { error(node, Diagnostics.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class); } - + return unknownType; } - + if (container.kind === SyntaxKind.Constructor && isInConstructorArgumentInitializer(node, container)) { // issue custom error message for super property access in constructor arguments (to be aligned with old compiler) error(node, Diagnostics.super_cannot_be_referenced_in_constructor_arguments); return unknownType; } - + return nodeCheckFlag === NodeCheckFlags.SuperStatic ? getBaseConstructorTypeOfClass(classType) : baseClassType; - + function isLegalUsageOfSuperExpression(container: Node): boolean { if (!container) { return false; @@ -6567,9 +6740,9 @@ namespace ts { } } } - + return false; - } + } } // Return contextual type of parameter or undefined if no contextual type is available @@ -7082,7 +7255,7 @@ namespace ts { } } } - return createArrayType(elementTypes.length ? getUnionType(elementTypes) : undefinedType) + return createArrayType(elementTypes.length ? getUnionType(elementTypes) : undefinedType); } function isNumericName(name: DeclarationName): boolean { @@ -7143,15 +7316,15 @@ namespace ts { } function checkObjectLiteral(node: ObjectLiteralExpression, contextualMapper?: TypeMapper): Type { + let inDestructuringPattern = isAssignmentTarget(node); // Grammar checking - checkGrammarObjectLiteralExpression(node); + checkGrammarObjectLiteralExpression(node, inDestructuringPattern); let propertiesTable: SymbolTable = {}; let propertiesArray: Symbol[] = []; let contextualType = getContextualType(node); let contextualTypeHasPattern = contextualType && contextualType.pattern && (contextualType.pattern.kind === SyntaxKind.ObjectBindingPattern || contextualType.pattern.kind === SyntaxKind.ObjectLiteralExpression); - let inDestructuringPattern = isAssignmentTarget(node); let typeFlags: TypeFlags = 0; for (let memberDecl of node.properties) { @@ -7175,7 +7348,10 @@ namespace ts { if (inDestructuringPattern) { // If object literal is an assignment pattern and if the assignment pattern specifies a default value // for the property, make the property optional. - if (memberDecl.kind === SyntaxKind.PropertyAssignment && hasDefaultValue((memberDecl).initializer)) { + const isOptional = + (memberDecl.kind === SyntaxKind.PropertyAssignment && hasDefaultValue((memberDecl).initializer)) || + (memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment && (memberDecl).objectAssignmentInitializer); + if (isOptional) { prop.flags |= SymbolFlags.Optional; } } @@ -7353,7 +7529,7 @@ namespace ts { // Maybe there's a string indexer? let indexerType = getIndexTypeOfType(elementAttributesType, IndexKind.String); if (indexerType) { - correspondingPropType = indexerType + correspondingPropType = indexerType; } else { // If there's no corresponding property with this name, error @@ -7421,7 +7597,8 @@ namespace ts { if (!links.resolvedSymbol) { if (isJsxIntrinsicIdentifier(node.tagName)) { links.resolvedSymbol = lookupIntrinsicTag(node); - } else { + } + else { links.resolvedSymbol = lookupClassTag(node); } } @@ -7461,7 +7638,9 @@ namespace ts { // Look up the value in the current scope if (valueSymbol && valueSymbol !== unknownSymbol) { links.jsxFlags |= JsxFlags.ClassElement; - getSymbolLinks(valueSymbol).referenced = true; + if (valueSymbol.flags & SymbolFlags.Alias) { + markAliasSymbolAsReferenced(valueSymbol); + } } return valueSymbol || unknownSymbol; @@ -7835,7 +8014,7 @@ namespace ts { let prop = getPropertyOfType(apparentType, right.text); if (!prop) { if (right.text) { - error(right, Diagnostics.Property_0_does_not_exist_on_type_1, declarationNameToString(right), typeToString(type)); + error(right, Diagnostics.Property_0_does_not_exist_on_type_1, declarationNameToString(right), typeToString(type.flags & TypeFlags.ThisType ? apparentType : type)); } return unknownType; } @@ -7843,7 +8022,7 @@ namespace ts { getNodeLinks(node).resolvedSymbol = prop; if (prop.parent && prop.parent.flags & SymbolFlags.Class) { - checkClassPropertyAccess(node, left, type, prop); + checkClassPropertyAccess(node, left, apparentType, prop); } return getTypeOfSymbol(prop); } @@ -7952,6 +8131,7 @@ namespace ts { /** * If indexArgumentExpression is a string literal or number literal, returns its text. + * If indexArgumentExpression is a constant value, returns its string value. * If indexArgumentExpression is a well known symbol, returns the property name corresponding * to this symbol, as long as it is a proper symbol reference. * Otherwise, returns undefined. @@ -7960,6 +8140,12 @@ namespace ts { if (indexArgumentExpression.kind === SyntaxKind.StringLiteral || indexArgumentExpression.kind === SyntaxKind.NumericLiteral) { return (indexArgumentExpression).text; } + if (indexArgumentExpression.kind === SyntaxKind.ElementAccessExpression || indexArgumentExpression.kind === SyntaxKind.PropertyAccessExpression) { + let value = getConstantValue(indexArgumentExpression); + if (value !== undefined) { + return value.toString(); + } + } if (checkThatExpressionIsProperSymbolReference(indexArgumentExpression, indexArgumentType, /*reportError*/ false)) { let rightHandSideName = ((indexArgumentExpression).name).text; return getPropertyNameForKnownSymbolName(rightHandSideName); @@ -8045,9 +8231,9 @@ namespace ts { function reorderCandidates(signatures: Signature[], result: Signature[]): void { let lastParent: Node; let lastSymbol: Symbol; - let cutoffIndex: number = 0; + let cutoffIndex = 0; let index: number; - let specializedIndex: number = -1; + let specializedIndex = -1; let spliceIndex: number; Debug.assert(!result.length); for (let signature of signatures) { @@ -8394,6 +8580,12 @@ namespace ts { case SyntaxKind.SetAccessor: // A method or accessor declaration decorator will have two or three arguments (see // `PropertyDecorator` and `MethodDecorator` in core.d.ts) + + // If we are emitting decorators for ES3, we will only pass two arguments. + if (languageVersion === ScriptTarget.ES3) { + return 2; + } + // If the method decorator signature only accepts a target and a key, we will only // type check those arguments. return signature.parameters.length >= 3 ? 3 : 2; @@ -9162,10 +9354,24 @@ namespace ts { } } + // When contextual typing assigns a type to a parameter that contains a binding pattern, we also need to push + // the destructured type into the contained binding elements. + function assignBindingElementTypes(node: VariableLikeDeclaration) { + if (isBindingPattern(node.name)) { + for (let element of (node.name).elements) { + if (element.kind !== SyntaxKind.OmittedExpression) { + getSymbolLinks(getSymbolOfNode(element)).type = getTypeForBindingElement(element); + assignBindingElementTypes(element); + } + } + } + } + function assignTypeToParameterAndFixTypeParameters(parameter: Symbol, contextualType: Type, mapper: TypeMapper) { let links = getSymbolLinks(parameter); if (!links.type) { links.type = instantiateType(contextualType, mapper); + assignBindingElementTypes(parameter.valueDeclaration); } else if (isInferentialContext(mapper)) { // Even if the parameter already has a type, it might be because it was given a type while @@ -9551,7 +9757,7 @@ namespace ts { return !symbol || symbol === unknownSymbol || (symbol.flags & ~SymbolFlags.EnumMember) !== 0; } case SyntaxKind.ElementAccessExpression: - // old compiler doesn't check indexed assess + // old compiler doesn't check indexed access return true; case SyntaxKind.ParenthesizedExpression: return isReferenceOrErrorExpression((n).expression); @@ -9709,32 +9915,32 @@ namespace ts { return (symbol.flags & SymbolFlags.ConstEnum) !== 0; } - function checkInstanceOfExpression(node: BinaryExpression, leftType: Type, rightType: Type): Type { + function checkInstanceOfExpression(left: Expression, right: Expression, leftType: Type, rightType: Type): Type { // TypeScript 1.0 spec (April 2014): 4.15.4 // The instanceof operator requires the left operand to be of type Any, an object type, or a type parameter type, // and the right operand to be of type Any or a subtype of the 'Function' interface type. // The result is always of the Boolean primitive type. // NOTE: do not raise error if leftType is unknown as related error was already reported if (allConstituentTypesHaveKind(leftType, TypeFlags.Primitive)) { - error(node.left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter); + error(left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter); } // NOTE: do not raise error if right is unknown as related error was already reported if (!(isTypeAny(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) { - error(node.right, Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type); + error(right, Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type); } return booleanType; } - function checkInExpression(node: BinaryExpression, leftType: Type, rightType: Type): Type { + function checkInExpression(left: Expression, right: Expression, leftType: Type, rightType: Type): Type { // TypeScript 1.0 spec (April 2014): 4.15.5 // The in operator requires the left operand to be of type Any, the String primitive type, or the Number primitive type, // and the right operand to be of type Any, an object type, or a type parameter type. // The result is always of the Boolean primitive type. if (!isTypeAnyOrAllConstituentTypesHaveKind(leftType, TypeFlags.StringLike | TypeFlags.NumberLike | TypeFlags.ESSymbol)) { - error(node.left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol); + error(left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol); } if (!isTypeAnyOrAllConstituentTypesHaveKind(rightType, TypeFlags.ObjectType | TypeFlags.TypeParameter)) { - error(node.right, Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter); + 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; } @@ -9751,7 +9957,12 @@ namespace ts { isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) || getIndexTypeOfType(sourceType, IndexKind.String); if (type) { - checkDestructuringAssignment((p).initializer || name, type); + if (p.kind === SyntaxKind.ShorthandPropertyAssignment) { + checkDestructuringAssignment(p, type); + } + else { + checkDestructuringAssignment((p).initializer || name, type); + } } else { error(name, Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(sourceType), declarationNameToString(name)); @@ -9811,7 +10022,19 @@ namespace ts { return sourceType; } - function checkDestructuringAssignment(target: Expression, sourceType: Type, contextualMapper?: TypeMapper): Type { + function checkDestructuringAssignment(exprOrAssignment: Expression | ShorthandPropertyAssignment, sourceType: Type, contextualMapper?: TypeMapper): Type { + let target: Expression; + if (exprOrAssignment.kind === SyntaxKind.ShorthandPropertyAssignment) { + const prop = exprOrAssignment; + if (prop.objectAssignmentInitializer) { + checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, contextualMapper); + } + target = (exprOrAssignment).name; + } + else { + target = exprOrAssignment; + } + if (target.kind === SyntaxKind.BinaryExpression && (target).operatorToken.kind === SyntaxKind.EqualsToken) { checkBinaryExpression(target, contextualMapper); target = (target).left; @@ -9834,12 +10057,16 @@ namespace ts { } function checkBinaryExpression(node: BinaryExpression, contextualMapper?: TypeMapper) { - let operator = node.operatorToken.kind; - if (operator === SyntaxKind.EqualsToken && (node.left.kind === SyntaxKind.ObjectLiteralExpression || node.left.kind === SyntaxKind.ArrayLiteralExpression)) { - return checkDestructuringAssignment(node.left, checkExpression(node.right, contextualMapper), contextualMapper); + return checkBinaryLikeExpression(node.left, node.operatorToken, node.right, contextualMapper, node); + } + + function checkBinaryLikeExpression(left: Expression, operatorToken: Node, right: Expression, contextualMapper?: TypeMapper, errorNode?: Node) { + let operator = operatorToken.kind; + if (operator === SyntaxKind.EqualsToken && (left.kind === SyntaxKind.ObjectLiteralExpression || left.kind === SyntaxKind.ArrayLiteralExpression)) { + return checkDestructuringAssignment(left, checkExpression(right, contextualMapper), contextualMapper); } - let leftType = checkExpression(node.left, contextualMapper); - let rightType = checkExpression(node.right, contextualMapper); + let leftType = checkExpression(left, contextualMapper); + let rightType = checkExpression(right, contextualMapper); switch (operator) { case SyntaxKind.AsteriskToken: case SyntaxKind.AsteriskEqualsToken: @@ -9875,13 +10102,13 @@ namespace ts { // try and return them a helpful suggestion if ((leftType.flags & TypeFlags.Boolean) && (rightType.flags & TypeFlags.Boolean) && - (suggestedOperator = getSuggestedBooleanOperator(node.operatorToken.kind)) !== undefined) { - error(node, Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, tokenToString(node.operatorToken.kind), tokenToString(suggestedOperator)); + (suggestedOperator = getSuggestedBooleanOperator(operatorToken.kind)) !== undefined) { + error(errorNode || operatorToken, Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, tokenToString(operatorToken.kind), tokenToString(suggestedOperator)); } else { // otherwise just check each operand separately and report errors as normal - let leftOk = checkArithmeticOperandType(node.left, leftType, Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type); - let rightOk = checkArithmeticOperandType(node.right, rightType, Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type); + let leftOk = checkArithmeticOperandType(left, leftType, Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type); + let rightOk = checkArithmeticOperandType(right, rightType, Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type); if (leftOk && rightOk) { checkAssignmentOperator(numberType); } @@ -9947,9 +10174,9 @@ namespace ts { } return booleanType; case SyntaxKind.InstanceOfKeyword: - return checkInstanceOfExpression(node, leftType, rightType); + return checkInstanceOfExpression(left, right, leftType, rightType); case SyntaxKind.InKeyword: - return checkInExpression(node, leftType, rightType); + return checkInExpression(left, right, leftType, rightType); case SyntaxKind.AmpersandAmpersandToken: return rightType; case SyntaxKind.BarBarToken: @@ -9964,8 +10191,8 @@ namespace ts { // Return true if there was no error, false if there was an error. function checkForDisallowedESSymbolOperand(operator: SyntaxKind): boolean { let offendingSymbolOperand = - someConstituentTypeHasKind(leftType, TypeFlags.ESSymbol) ? node.left : - someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? node.right : + someConstituentTypeHasKind(leftType, TypeFlags.ESSymbol) ? left : + someConstituentTypeHasKind(rightType, TypeFlags.ESSymbol) ? right : undefined; if (offendingSymbolOperand) { error(offendingSymbolOperand, Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, tokenToString(operator)); @@ -9999,17 +10226,17 @@ namespace ts { // requires VarExpr to be classified as a reference // A compound assignment furthermore requires VarExpr to be classified as a reference (section 4.1) // and the type of the non - compound operation to be assignable to the type of VarExpr. - let ok = checkReferenceExpression(node.left, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant); + let ok = checkReferenceExpression(left, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant); // Use default messages if (ok) { // to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported - checkTypeAssignableTo(valueType, leftType, node.left, /*headMessage*/ undefined); + checkTypeAssignableTo(valueType, leftType, left, /*headMessage*/ undefined); } } } function reportOperatorError() { - error(node, Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, tokenToString(node.operatorToken.kind), typeToString(leftType), typeToString(rightType)); + error(errorNode || operatorToken, Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, tokenToString(operatorToken.kind), typeToString(leftType), typeToString(rightType)); } } @@ -10632,7 +10859,7 @@ namespace ts { } if (!superCallStatement) { error(node, Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties); - } + } else { // In such a required super call, it is a compile-time error for argument expressions to reference this. markThisReferencesAsErrors(superCallStatement.expression); @@ -11071,7 +11298,7 @@ namespace ts { // Spaces for anyting not declared a 'default export'. let nonDefaultExportedDeclarationSpaces = exportedDeclarationSpaces | nonExportedDeclarationSpaces; - + let commonDeclarationSpacesForExportsAndLocals = exportedDeclarationSpaces & nonExportedDeclarationSpaces; let commonDeclarationSpacesForDefaultAndNonDefault = defaultExportedDeclarationSpaces & nonDefaultExportedDeclarationSpaces; @@ -11079,7 +11306,7 @@ namespace ts { // declaration spaces for exported and non-exported declarations intersect for (let d of symbol.declarations) { let declarationSpaces = getDeclarationSpaces(d); - + // Only error on the declarations that conributed to the intersecting spaces. if (declarationSpaces & commonDeclarationSpacesForDefaultAndNonDefault) { error(d.name, Diagnostics.Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead, declarationNameToString(d.name)); @@ -11113,7 +11340,8 @@ namespace ts { } function checkNonThenableType(type: Type, location?: Node, message?: DiagnosticMessage) { - if (!(type.flags & TypeFlags.Any) && isTypeAssignableTo(type, getGlobalThenableType())) { + type = getWidenedType(type); + if (!isTypeAny(type) && isTypeAssignableTo(type, getGlobalThenableType())) { if (location) { if (!message) { message = Diagnostics.Operand_for_await_does_not_have_a_valid_callable_then_member; @@ -11906,7 +12134,7 @@ namespace ts { function checkGrammarDisallowedModifiersOnObjectLiteralExpressionMethod(node: Node) { // We only disallow modifier on a method declaration if it is a property of object-literal-expression - if (node.modifiers && node.parent.kind === SyntaxKind.ObjectLiteralExpression){ + if (node.modifiers && node.parent.kind === SyntaxKind.ObjectLiteralExpression) { if (isAsyncFunctionLike(node)) { if (node.modifiers.length > 1) { return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here); @@ -12351,7 +12579,12 @@ namespace ts { if (isAsyncFunctionLike(func)) { let promisedType = getPromisedType(returnType); let awaitedType = checkAwaitedType(exprType, node.expression, Diagnostics.Return_expression_in_async_function_does_not_have_a_valid_callable_then_member); - checkTypeAssignableTo(awaitedType, promisedType, node.expression); + if (promisedType) { + // If the function has a return type, but promisedType is + // undefined, an error will be reported in checkAsyncFunctionReturnType + // so we don't need to report one here. + checkTypeAssignableTo(awaitedType, promisedType, node.expression); + } } else { checkTypeAssignableTo(exprType, returnType, node.expression); @@ -12633,6 +12866,7 @@ namespace ts { checkExportsOnMergedDeclarations(node); let symbol = getSymbolOfNode(node); let type = getDeclaredTypeOfSymbol(symbol); + let typeWithThis = getTypeWithThisArgument(type); let staticType = getTypeOfSymbol(symbol); let baseTypeNode = getClassExtendsHeritageClauseElement(node); @@ -12651,7 +12885,7 @@ namespace ts { } } } - checkTypeAssignableTo(type, baseType, node.name || node, Diagnostics.Class_0_incorrectly_extends_base_class_1); + checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(baseType, type.thisType), node.name || node, Diagnostics.Class_0_incorrectly_extends_base_class_1); checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); @@ -12671,7 +12905,7 @@ namespace ts { let implementedTypeNodes = getClassImplementsHeritageClauseElements(node); if (implementedTypeNodes) { - forEach(implementedTypeNodes, typeRefNode => { + for (let typeRefNode of implementedTypeNodes) { if (!isSupportedExpressionWithTypeArguments(typeRefNode)) { error(typeRefNode.expression, Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments); } @@ -12681,14 +12915,14 @@ namespace ts { if (t !== unknownType) { let declaredType = (t.flags & TypeFlags.Reference) ? (t).target : t; if (declaredType.flags & (TypeFlags.Class | TypeFlags.Interface)) { - checkTypeAssignableTo(type, t, node.name || node, Diagnostics.Class_0_incorrectly_implements_interface_1); + checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(t, type.thisType), node.name || node, Diagnostics.Class_0_incorrectly_implements_interface_1); } else { error(typeRefNode, Diagnostics.A_class_may_only_implement_another_class_or_interface); } } } - }); + } } if (produceDiagnostics) { @@ -12848,7 +13082,7 @@ namespace ts { let ok = true; for (let base of baseTypes) { - let properties = getPropertiesOfObjectType(base); + let properties = getPropertiesOfObjectType(getTypeWithThisArgument(base, type.thisType)); for (let prop of properties) { if (!hasProperty(seen, prop.name)) { seen[prop.name] = { prop: prop, containingType: base }; @@ -12893,11 +13127,12 @@ namespace ts { // Only check this symbol once if (node === firstInterfaceDecl) { let type = getDeclaredTypeOfSymbol(symbol); + let typeWithThis = getTypeWithThisArgument(type); // run subsequent checks only if first set succeeded if (checkInheritedPropertiesAreIdentical(type, node.name)) { - forEach(getBaseTypes(type), baseType => { - checkTypeAssignableTo(type, baseType, node.name, Diagnostics.Interface_0_incorrectly_extends_interface_1); - }); + for (let baseType of getBaseTypes(type)) { + checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(baseType, type.thisType), node.name, Diagnostics.Interface_0_incorrectly_extends_interface_1); + } checkIndexConstraints(type); } } @@ -12940,26 +13175,41 @@ namespace ts { if (!(nodeLinks.flags & NodeCheckFlags.EnumValuesComputed)) { let enumSymbol = getSymbolOfNode(node); let enumType = getDeclaredTypeOfSymbol(enumSymbol); - let autoValue = 0; + let autoValue = 0; // set to undefined when enum member is non-constant let ambient = isInAmbientContext(node); let enumIsConst = isConst(node); - forEach(node.members, member => { - if (member.name.kind !== SyntaxKind.ComputedPropertyName && isNumericLiteralName((member.name).text)) { + for (const member of node.members) { + if (member.name.kind === SyntaxKind.ComputedPropertyName) { + error(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums); + } + else if (isNumericLiteralName((member.name).text)) { error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name); } + + const previousEnumMemberIsNonConstant = autoValue === undefined; + let initializer = member.initializer; if (initializer) { autoValue = computeConstantValueForEnumMemberInitializer(initializer, enumType, enumIsConst, ambient); } else if (ambient && !enumIsConst) { + // In ambient enum declarations that specify no const modifier, enum member declarations + // that omit a value are considered computed members (as opposed to having auto-incremented values assigned). autoValue = undefined; } + else if (previousEnumMemberIsNonConstant) { + // If the member declaration specifies no value, the member is considered a constant enum member. + // If the member is the first member in the enum declaration, it is assigned the value zero. + // Otherwise, it is assigned the value of the immediately preceding member plus one, + // and an error occurs if the immediately preceding member is not a constant enum member + error(member.name, Diagnostics.Enum_member_must_have_initializer); + } if (autoValue !== undefined) { getNodeLinks(member).enumMemberValue = autoValue++; } - }); + } nodeLinks.flags |= NodeCheckFlags.EnumValuesComputed; } @@ -12975,11 +13225,11 @@ namespace ts { if (enumIsConst) { error(initializer, Diagnostics.In_const_enum_declarations_member_initializer_must_be_constant_expression); } - else if (!ambient) { + else if (ambient) { + error(initializer, Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression); + } + else { // Only here do we need to check that the initializer is assignable to the enum type. - // If it is a constant value (not undefined), it is syntactically constrained to be a number. - // Also, we do not need to check this for ambients because there is already - // a syntax error if it is not a constant. checkTypeAssignableTo(checkExpression(initializer), enumType, initializer, /*headMessage*/ undefined); } } @@ -13119,7 +13369,7 @@ namespace ts { } // Grammar checking - checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node); + checkGrammarDecorators(node) || checkGrammarModifiers(node); checkTypeNameIsReserved(node.name, Diagnostics.Enum_name_cannot_be_0); checkCollisionWithCapturedThisVariable(node, node.name); @@ -13252,7 +13502,7 @@ namespace ts { // Checks for ambient external modules. if (isAmbientExternalModule) { if (!isGlobalSourceFile(node.parent)) { - error(node.name, Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules); + error(node.name, Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces); } if (isExternalModuleNameRelative(node.name.text)) { error(node.name, Diagnostics.Ambient_module_declaration_cannot_specify_relative_module_name); @@ -13277,7 +13527,7 @@ namespace ts { Debug.assert(node.kind === SyntaxKind.Identifier); return node; } - + function checkExternalImportOrExportDeclaration(node: ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration): boolean { let moduleName = getExternalModuleName(node); if (!nodeIsMissing(moduleName) && moduleName.kind !== SyntaxKind.StringLiteral) { @@ -13379,9 +13629,9 @@ namespace ts { } } else { - if (languageVersion >= ScriptTarget.ES6 && !isInAmbientContext(node)) { + if (modulekind === ModuleKind.ES6 && !isInAmbientContext(node)) { // Import equals declaration is deprecated in es6 or above - grammarErrorOnNode(node, Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_6_or_higher_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_or_import_d_from_mod_instead); + grammarErrorOnNode(node, Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_6_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead); } } } @@ -13456,11 +13706,11 @@ namespace ts { checkExternalModuleExports(container); if (node.isExportEquals && !isInAmbientContext(node)) { - if (languageVersion >= ScriptTarget.ES6) { - // export assignment is deprecated in es6 or above - grammarErrorOnNode(node, Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_6_or_higher_Consider_using_export_default_instead); + if (modulekind === ModuleKind.ES6) { + // export assignment is not supported in es6 modules + grammarErrorOnNode(node, Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_6_modules_Consider_using_export_default_or_another_module_format_instead); } - else if (compilerOptions.module === ModuleKind.System) { + else if (modulekind === ModuleKind.System) { // system modules does not support export assignment grammarErrorOnNode(node, Diagnostics.Export_assignment_is_not_supported_when_module_flag_is_system); } @@ -13650,6 +13900,7 @@ namespace ts { break; case SyntaxKind.ClassExpression: forEach((node).members, checkSourceElement); + forEachChild(node, checkFunctionAndClassExpressionBodies); break; case SyntaxKind.MethodDeclaration: case SyntaxKind.MethodSignature: @@ -13890,7 +14141,7 @@ namespace ts { case SyntaxKind.ClassDeclaration: case SyntaxKind.InterfaceDeclaration: // If we didn't come from static member of class or interface, - // add the type parameters into the symbol table + // add the type parameters into the symbol table // (type parameters of classDeclaration/classExpression and interface are in member property of the symbol. // Note: that the memberFlags come from previous iteration. if (!(memberFlags & NodeFlags.Static)) { @@ -13904,11 +14155,11 @@ namespace ts { } break; } - + if (introducesArgumentsExoticObject(location)) { copySymbol(argumentsSymbol, meaning); } - + memberFlags = location.flags; location = location.parent; } @@ -14023,7 +14274,21 @@ namespace ts { } if (isHeritageClauseElementIdentifier(entityName)) { - let meaning = entityName.parent.kind === SyntaxKind.ExpressionWithTypeArguments ? SymbolFlags.Type : SymbolFlags.Namespace; + 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; + + // In a class 'extends' clause we are also looking for a value. + if (isExpressionWithTypeArgumentsInClassExtendsClause(entityName.parent)) { + meaning |= SymbolFlags.Value; + } + } + else { + meaning = SymbolFlags.Namespace; + } + meaning |= SymbolFlags.Alias; return resolveEntityName(entityName, meaning); } @@ -14115,7 +14380,7 @@ namespace ts { case SyntaxKind.ThisKeyword: case SyntaxKind.SuperKeyword: - let type = checkExpression(node); + let type = isExpression(node) ? checkExpression(node) : getTypeFromTypeNode(node); return type.symbol; case SyntaxKind.ConstructorKeyword: @@ -14380,9 +14645,9 @@ namespace ts { } // const enums and modules that contain only const enums are not considered values from the emit perespective // unless 'preserveConstEnums' option is set to true - return target !== unknownSymbol && - target && - target.flags & SymbolFlags.Value && + return target !== unknownSymbol && + target && + target.flags & SymbolFlags.Value && (compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(target)); } @@ -14453,7 +14718,7 @@ namespace ts { function isFunctionType(type: Type): boolean { return type.flags & TypeFlags.ObjectType && getSignaturesOfType(type, SignatureKind.Call).length > 0; } - + function getTypeReferenceSerializationKind(typeName: EntityName): TypeReferenceSerializationKind { // Resolve the symbol as a value to ensure the type can be reached at runtime during emit. let valueSymbol = resolveEntityName(typeName, SymbolFlags.Value, /*ignoreErrors*/ true); @@ -14466,7 +14731,7 @@ namespace ts { let typeSymbol = resolveEntityName(typeName, SymbolFlags.Type, /*ignoreErrors*/ true); // We might not be able to resolve type symbol so use unknown type in that case (eg error case) if (!typeSymbol) { - return TypeReferenceSerializationKind.ObjectType; + return TypeReferenceSerializationKind.ObjectType; } let type = getDeclaredTypeOfSymbol(typeSymbol); if (type === unknownType) { @@ -14540,31 +14805,6 @@ namespace ts { return symbol && getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration; } - function getBlockScopedVariableId(n: Identifier): number { - Debug.assert(!nodeIsSynthesized(n)); - - let isVariableDeclarationOrBindingElement = - n.parent.kind === SyntaxKind.BindingElement || (n.parent.kind === SyntaxKind.VariableDeclaration && (n.parent).name === n); - - let symbol = - (isVariableDeclarationOrBindingElement ? getSymbolOfNode(n.parent) : undefined) || - getNodeLinks(n).resolvedSymbol || - resolveName(n, n.text, SymbolFlags.Value | SymbolFlags.Alias, /*nodeNotFoundMessage*/ undefined, /*nameArg*/ undefined); - - let isLetOrConst = - symbol && - (symbol.flags & SymbolFlags.BlockScopedVariable) && - symbol.valueDeclaration.parent.kind !== SyntaxKind.CatchClause; - - if (isLetOrConst) { - // side-effect of calling this method: - // assign id to symbol if it was not yet set - getSymbolLinks(symbol); - return symbol.id; - } - return undefined; - } - function instantiateSingleCallFunctionType(functionType: Type, typeArguments: Type[]): Type { if (functionType === unknownType) { return unknownType; @@ -14599,7 +14839,6 @@ namespace ts { isEntityNameVisible, getConstantValue, collectLinkedAliases, - getBlockScopedVariableId, getReferencedValueDeclaration, getTypeReferenceSerializationKind, isOptionalParameter @@ -14702,9 +14941,6 @@ namespace ts { if (!nodeCanBeDecorated(node)) { return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_not_valid_here); } - else if (languageVersion < ScriptTarget.ES5) { - return grammarErrorOnFirstToken(node, Diagnostics.Decorators_are_only_available_when_targeting_ECMAScript_5_and_higher); - } else if (node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor) { let accessors = getAllAccessorDeclarations((node.parent).members, node); if (accessors.firstAccessor.decorators && node === accessors.secondAccessor) { @@ -15213,7 +15449,7 @@ namespace ts { } } - function checkGrammarObjectLiteralExpression(node: ObjectLiteralExpression) { + function checkGrammarObjectLiteralExpression(node: ObjectLiteralExpression, inDestructuring: boolean) { let seen: Map = {}; let Property = 1; let GetAccessor = 2; @@ -15229,6 +15465,12 @@ namespace ts { continue; } + if (prop.kind === SyntaxKind.ShorthandPropertyAssignment && !inDestructuring && (prop).objectAssignmentInitializer) { + // having objectAssignmentInitializer is only valid in ObjectAssignmentPattern + // outside of destructuring it is a syntax error + return grammarErrorOnNode((prop).equalsToken, Diagnostics.can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment); + } + // ECMA-262 11.1.5 Object Initialiser // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true // a.This production is contained in strict code and IsDataDescriptor(previous) is true and @@ -15619,40 +15861,6 @@ namespace ts { return false; } - function checkGrammarEnumDeclaration(enumDecl: EnumDeclaration): boolean { - let enumIsConst = (enumDecl.flags & NodeFlags.Const) !== 0; - - let hasError = false; - - // skip checks below for const enums - they allow arbitrary initializers as long as they can be evaluated to constant expressions. - // since all values are known in compile time - it is not necessary to check that constant enum section precedes computed enum members. - if (!enumIsConst) { - let inConstantEnumMemberSection = true; - let inAmbientContext = isInAmbientContext(enumDecl); - for (let node of enumDecl.members) { - // Do not use hasDynamicName here, because that returns false for well known symbols. - // We want to perform checkComputedPropertyName for all computed properties, including - // well known symbols. - if (node.name.kind === SyntaxKind.ComputedPropertyName) { - hasError = grammarErrorOnNode(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums); - } - else if (inAmbientContext) { - if (node.initializer && !isIntegerLiteral(node.initializer)) { - hasError = grammarErrorOnNode(node.name, Diagnostics.Ambient_enum_elements_can_only_have_integer_literal_initializers) || hasError; - } - } - else if (node.initializer) { - inConstantEnumMemberSection = isIntegerLiteral(node.initializer); - } - else if (!inConstantEnumMemberSection) { - hasError = grammarErrorOnNode(node.name, Diagnostics.Enum_member_must_have_initializer) || hasError; - } - } - } - - return hasError; - } - function hasParseDiagnostics(sourceFile: SourceFile): boolean { return sourceFile.parseDiagnostics.length > 0; } diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 1670251973a..731a37a8cb7 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -76,10 +76,11 @@ namespace ts { "amd": ModuleKind.AMD, "system": ModuleKind.System, "umd": ModuleKind.UMD, + "es6": ModuleKind.ES6, }, - description: Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_or_umd, + description: Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_umd_or_es6, paramType: Diagnostics.KIND, - error: Diagnostics.Argument_for_module_option_must_be_commonjs_amd_system_or_umd + error: Diagnostics.Argument_for_module_option_must_be_commonjs_amd_system_umd_or_es6 }, { name: "newLine", @@ -447,6 +448,9 @@ namespace ts { } if (opt.isFilePath) { value = normalizePath(combinePaths(basePath, value)); + if (value === "") { + value = "."; + } } options[opt.name] = value; } @@ -469,7 +473,7 @@ namespace ts { fileNames = map(json["files"], s => combinePaths(basePath, s)); } else { - errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "files", "Array")); + errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "files", "Array")); } } else { @@ -496,4 +500,4 @@ namespace ts { return fileNames; } } -} \ No newline at end of file +} diff --git a/src/compiler/core.ts b/src/compiler/core.ts index cdec2a4fa34..caa246373a2 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -52,7 +52,7 @@ namespace ts { function normalizeKey(key: string) { return getCanonicalFileName(normalizeSlashes(key)); } - + function clear() { files = {}; } @@ -117,7 +117,7 @@ namespace ts { return count; } - export function filter(array: T[], f: (x: T) => boolean): T[]{ + export function filter(array: T[], f: (x: T) => boolean): T[] { let result: T[]; if (array) { result = []; @@ -130,7 +130,7 @@ namespace ts { return result; } - export function map(array: T[], f: (x: T) => U): U[]{ + export function map(array: T[], f: (x: T) => U): U[] { let result: U[]; if (array) { result = []; @@ -148,7 +148,7 @@ namespace ts { return array1.concat(array2); } - export function deduplicate(array: T[]): T[]{ + export function deduplicate(array: T[]): T[] { let result: T[]; if (array) { result = []; @@ -486,7 +486,7 @@ namespace ts { return text1 ? Comparison.GreaterThan : Comparison.LessThan; } - export function sortAndDeduplicateDiagnostics(diagnostics: Diagnostic[]): Diagnostic[]{ + export function sortAndDeduplicateDiagnostics(diagnostics: Diagnostic[]): Diagnostic[] { return deduplicateSortedDiagnostics(diagnostics.sort(compareDiagnostics)); } @@ -728,7 +728,7 @@ namespace ts { * but still would like to load only TypeScript files as modules */ export const moduleFileExtensions = supportedExtensions; - + const extensionsToRemove = [".d.ts", ".ts", ".js", ".tsx", ".jsx"]; export function removeFileExtension(path: string): string { for (let ext of extensionsToRemove) { @@ -801,7 +801,7 @@ namespace ts { VeryAggressive = 3, } - export module Debug { + export namespace Debug { let currentAssertionLevel = AssertionLevel.None; export function shouldAssert(level: AssertionLevel): boolean { diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts index e5914d10060..00085f16086 100644 --- a/src/compiler/declarationEmitter.ts +++ b/src/compiler/declarationEmitter.ts @@ -52,6 +52,7 @@ namespace ts { let enclosingDeclaration: Node; let currentSourceFile: SourceFile; let reportedDeclarationError = false; + let errorNameNode: DeclarationName; let emitJsDocComments = compilerOptions.removeComments ? function (declaration: Node) { } : writeJsDocComments; let emit = compilerOptions.stripInternal ? stripInternal : emitNode; @@ -152,6 +153,7 @@ namespace ts { function createAndSetNewTextWriterWithSymbolWriter(): EmitTextWriterWithSymbolWriter { let writer = createTextWriter(newLine); writer.trackSymbol = trackSymbol; + writer.reportInaccessibleThisError = reportInaccessibleThisError; writer.writeKeyword = writer.write; writer.writeOperator = writer.write; writer.writePunctuation = writer.write; @@ -178,9 +180,11 @@ namespace ts { let nodeToCheck: Node; if (declaration.kind === SyntaxKind.VariableDeclaration) { nodeToCheck = declaration.parent.parent; - } else if (declaration.kind === SyntaxKind.NamedImports || declaration.kind === SyntaxKind.ImportSpecifier || declaration.kind === SyntaxKind.ImportClause) { + } + else if (declaration.kind === SyntaxKind.NamedImports || declaration.kind === SyntaxKind.ImportSpecifier || declaration.kind === SyntaxKind.ImportClause) { Debug.fail("We should be getting ImportDeclaration instead to write"); - } else { + } + else { nodeToCheck = declaration; } @@ -257,6 +261,13 @@ namespace ts { handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning)); } + function reportInaccessibleThisError() { + if (errorNameNode) { + diagnostics.push(createDiagnosticForNode(errorNameNode, Diagnostics.The_inferred_type_of_0_references_an_inaccessible_this_type_A_type_annotation_is_necessary, + declarationNameToString(errorNameNode))); + } + } + function writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, type: TypeNode, getSymbolAccessibilityDiagnostic: GetSymbolAccessibilityDiagnostic) { writer.getSymbolAccessibilityDiagnostic = getSymbolAccessibilityDiagnostic; write(": "); @@ -265,7 +276,9 @@ namespace ts { emitType(type); } else { + errorNameNode = declaration.name; resolver.writeTypeOfDeclaration(declaration, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer); + errorNameNode = undefined; } } @@ -277,7 +290,9 @@ namespace ts { emitType(signature.type); } else { + errorNameNode = signature.name; resolver.writeReturnTypeOfSignatureDeclaration(signature, enclosingDeclaration, TypeFormatFlags.UseTypeOfFunction, writer); + errorNameNode = undefined; } } @@ -326,6 +341,7 @@ namespace ts { case SyntaxKind.BooleanKeyword: case SyntaxKind.SymbolKeyword: case SyntaxKind.VoidKeyword: + case SyntaxKind.ThisKeyword: case SyntaxKind.StringLiteral: return writeTextOfNode(currentSourceFile, type); case SyntaxKind.ExpressionWithTypeArguments: @@ -1068,7 +1084,7 @@ namespace ts { // emitted: declare var c: number; // instead of declare var c:number, ; let elements: Node[] = []; for (let element of bindingPattern.elements) { - if (element.kind !== SyntaxKind.OmittedExpression){ + if (element.kind !== SyntaxKind.OmittedExpression) { elements.push(element); } } diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts deleted file mode 100644 index 37989c3433a..00000000000 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ /dev/null @@ -1,622 +0,0 @@ -// -/// -/* @internal */ -namespace ts { - export var Diagnostics = { - Unterminated_string_literal: { code: 1002, category: DiagnosticCategory.Error, key: "Unterminated string literal." }, - Identifier_expected: { code: 1003, category: DiagnosticCategory.Error, key: "Identifier expected." }, - _0_expected: { code: 1005, category: DiagnosticCategory.Error, key: "'{0}' expected." }, - A_file_cannot_have_a_reference_to_itself: { code: 1006, category: DiagnosticCategory.Error, key: "A file cannot have a reference to itself." }, - Trailing_comma_not_allowed: { code: 1009, category: DiagnosticCategory.Error, key: "Trailing comma not allowed." }, - Asterisk_Slash_expected: { code: 1010, category: DiagnosticCategory.Error, key: "'*/' expected." }, - Unexpected_token: { code: 1012, category: DiagnosticCategory.Error, key: "Unexpected token." }, - A_rest_parameter_must_be_last_in_a_parameter_list: { code: 1014, category: DiagnosticCategory.Error, key: "A rest parameter must be last in a parameter list." }, - Parameter_cannot_have_question_mark_and_initializer: { code: 1015, category: DiagnosticCategory.Error, key: "Parameter cannot have question mark and initializer." }, - A_required_parameter_cannot_follow_an_optional_parameter: { code: 1016, category: DiagnosticCategory.Error, key: "A required parameter cannot follow an optional parameter." }, - An_index_signature_cannot_have_a_rest_parameter: { code: 1017, category: DiagnosticCategory.Error, key: "An index signature cannot have a rest parameter." }, - An_index_signature_parameter_cannot_have_an_accessibility_modifier: { code: 1018, category: DiagnosticCategory.Error, key: "An index signature parameter cannot have an accessibility modifier." }, - An_index_signature_parameter_cannot_have_a_question_mark: { code: 1019, category: DiagnosticCategory.Error, key: "An index signature parameter cannot have a question mark." }, - An_index_signature_parameter_cannot_have_an_initializer: { code: 1020, category: DiagnosticCategory.Error, key: "An index signature parameter cannot have an initializer." }, - An_index_signature_must_have_a_type_annotation: { code: 1021, category: DiagnosticCategory.Error, key: "An index signature must have a type annotation." }, - An_index_signature_parameter_must_have_a_type_annotation: { code: 1022, category: DiagnosticCategory.Error, key: "An index signature parameter must have a type annotation." }, - An_index_signature_parameter_type_must_be_string_or_number: { code: 1023, category: DiagnosticCategory.Error, key: "An index signature parameter type must be 'string' or 'number'." }, - Accessibility_modifier_already_seen: { code: 1028, category: DiagnosticCategory.Error, key: "Accessibility modifier already seen." }, - _0_modifier_must_precede_1_modifier: { code: 1029, category: DiagnosticCategory.Error, key: "'{0}' modifier must precede '{1}' modifier." }, - _0_modifier_already_seen: { code: 1030, category: DiagnosticCategory.Error, key: "'{0}' modifier already seen." }, - _0_modifier_cannot_appear_on_a_class_element: { code: 1031, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a class element." }, - super_must_be_followed_by_an_argument_list_or_member_access: { code: 1034, category: DiagnosticCategory.Error, key: "'super' must be followed by an argument list or member access." }, - Only_ambient_modules_can_use_quoted_names: { code: 1035, category: DiagnosticCategory.Error, key: "Only ambient modules can use quoted names." }, - Statements_are_not_allowed_in_ambient_contexts: { code: 1036, category: DiagnosticCategory.Error, key: "Statements are not allowed in ambient contexts." }, - A_declare_modifier_cannot_be_used_in_an_already_ambient_context: { code: 1038, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used in an already ambient context." }, - Initializers_are_not_allowed_in_ambient_contexts: { code: 1039, category: DiagnosticCategory.Error, key: "Initializers are not allowed in ambient contexts." }, - _0_modifier_cannot_be_used_in_an_ambient_context: { code: 1040, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used in an ambient context." }, - _0_modifier_cannot_be_used_with_a_class_declaration: { code: 1041, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with a class declaration." }, - _0_modifier_cannot_be_used_here: { code: 1042, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used here." }, - _0_modifier_cannot_appear_on_a_data_property: { code: 1043, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a data property." }, - _0_modifier_cannot_appear_on_a_module_element: { code: 1044, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a module element." }, - A_0_modifier_cannot_be_used_with_an_interface_declaration: { code: 1045, category: DiagnosticCategory.Error, key: "A '{0}' modifier cannot be used with an interface declaration." }, - A_declare_modifier_is_required_for_a_top_level_declaration_in_a_d_ts_file: { code: 1046, category: DiagnosticCategory.Error, key: "A 'declare' modifier is required for a top level declaration in a .d.ts file." }, - A_rest_parameter_cannot_be_optional: { code: 1047, category: DiagnosticCategory.Error, key: "A rest parameter cannot be optional." }, - A_rest_parameter_cannot_have_an_initializer: { code: 1048, category: DiagnosticCategory.Error, key: "A rest parameter cannot have an initializer." }, - A_set_accessor_must_have_exactly_one_parameter: { code: 1049, category: DiagnosticCategory.Error, key: "A 'set' accessor must have exactly one parameter." }, - A_set_accessor_cannot_have_an_optional_parameter: { code: 1051, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have an optional parameter." }, - A_set_accessor_parameter_cannot_have_an_initializer: { code: 1052, category: DiagnosticCategory.Error, key: "A 'set' accessor parameter cannot have an initializer." }, - A_set_accessor_cannot_have_rest_parameter: { code: 1053, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have rest parameter." }, - A_get_accessor_cannot_have_parameters: { code: 1054, category: DiagnosticCategory.Error, key: "A 'get' accessor cannot have parameters." }, - Type_0_is_not_a_valid_async_function_return_type: { code: 1055, category: DiagnosticCategory.Error, key: "Type '{0}' is not a valid async function return type." }, - Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1056, category: DiagnosticCategory.Error, key: "Accessors are only available when targeting ECMAScript 5 and higher." }, - An_async_function_or_method_must_have_a_valid_awaitable_return_type: { code: 1057, category: DiagnosticCategory.Error, key: "An async function or method must have a valid awaitable return type." }, - Operand_for_await_does_not_have_a_valid_callable_then_member: { code: 1058, category: DiagnosticCategory.Error, key: "Operand for 'await' does not have a valid callable 'then' member." }, - Return_expression_in_async_function_does_not_have_a_valid_callable_then_member: { code: 1059, category: DiagnosticCategory.Error, key: "Return expression in async function does not have a valid callable 'then' member." }, - Expression_body_for_async_arrow_function_does_not_have_a_valid_callable_then_member: { code: 1060, category: DiagnosticCategory.Error, key: "Expression body for async arrow function does not have a valid callable 'then' member." }, - Enum_member_must_have_initializer: { code: 1061, category: DiagnosticCategory.Error, key: "Enum member must have initializer." }, - _0_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: { code: 1062, category: DiagnosticCategory.Error, key: "{0} is referenced directly or indirectly in the fulfillment callback of its own 'then' method." }, - An_export_assignment_cannot_be_used_in_a_namespace: { code: 1063, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in a namespace." }, - Ambient_enum_elements_can_only_have_integer_literal_initializers: { code: 1066, category: DiagnosticCategory.Error, key: "Ambient enum elements can only have integer literal initializers." }, - Unexpected_token_A_constructor_method_accessor_or_property_was_expected: { code: 1068, category: DiagnosticCategory.Error, key: "Unexpected token. A constructor, method, accessor, or property was expected." }, - A_0_modifier_cannot_be_used_with_an_import_declaration: { code: 1079, category: DiagnosticCategory.Error, key: "A '{0}' modifier cannot be used with an import declaration." }, - Invalid_reference_directive_syntax: { code: 1084, category: DiagnosticCategory.Error, key: "Invalid 'reference' directive syntax." }, - Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher: { code: 1085, category: DiagnosticCategory.Error, key: "Octal literals are not available when targeting ECMAScript 5 and higher." }, - An_accessor_cannot_be_declared_in_an_ambient_context: { code: 1086, category: DiagnosticCategory.Error, key: "An accessor cannot be declared in an ambient context." }, - _0_modifier_cannot_appear_on_a_constructor_declaration: { code: 1089, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a constructor declaration." }, - _0_modifier_cannot_appear_on_a_parameter: { code: 1090, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot appear on a parameter." }, - Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: { code: 1091, category: DiagnosticCategory.Error, key: "Only a single variable declaration is allowed in a 'for...in' statement." }, - Type_parameters_cannot_appear_on_a_constructor_declaration: { code: 1092, category: DiagnosticCategory.Error, key: "Type parameters cannot appear on a constructor declaration." }, - Type_annotation_cannot_appear_on_a_constructor_declaration: { code: 1093, category: DiagnosticCategory.Error, key: "Type annotation cannot appear on a constructor declaration." }, - An_accessor_cannot_have_type_parameters: { code: 1094, category: DiagnosticCategory.Error, key: "An accessor cannot have type parameters." }, - A_set_accessor_cannot_have_a_return_type_annotation: { code: 1095, category: DiagnosticCategory.Error, key: "A 'set' accessor cannot have a return type annotation." }, - An_index_signature_must_have_exactly_one_parameter: { code: 1096, category: DiagnosticCategory.Error, key: "An index signature must have exactly one parameter." }, - _0_list_cannot_be_empty: { code: 1097, category: DiagnosticCategory.Error, key: "'{0}' list cannot be empty." }, - Type_parameter_list_cannot_be_empty: { code: 1098, category: DiagnosticCategory.Error, key: "Type parameter list cannot be empty." }, - Type_argument_list_cannot_be_empty: { code: 1099, category: DiagnosticCategory.Error, key: "Type argument list cannot be empty." }, - Invalid_use_of_0_in_strict_mode: { code: 1100, category: DiagnosticCategory.Error, key: "Invalid use of '{0}' in strict mode." }, - with_statements_are_not_allowed_in_strict_mode: { code: 1101, category: DiagnosticCategory.Error, key: "'with' statements are not allowed in strict mode." }, - delete_cannot_be_called_on_an_identifier_in_strict_mode: { code: 1102, category: DiagnosticCategory.Error, key: "'delete' cannot be called on an identifier in strict mode." }, - A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: { code: 1104, category: DiagnosticCategory.Error, key: "A 'continue' statement can only be used within an enclosing iteration statement." }, - A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: { code: 1105, category: DiagnosticCategory.Error, key: "A 'break' statement can only be used within an enclosing iteration or switch statement." }, - Jump_target_cannot_cross_function_boundary: { code: 1107, category: DiagnosticCategory.Error, key: "Jump target cannot cross function boundary." }, - A_return_statement_can_only_be_used_within_a_function_body: { code: 1108, category: DiagnosticCategory.Error, key: "A 'return' statement can only be used within a function body." }, - Expression_expected: { code: 1109, category: DiagnosticCategory.Error, key: "Expression expected." }, - Type_expected: { code: 1110, category: DiagnosticCategory.Error, key: "Type expected." }, - A_class_member_cannot_be_declared_optional: { code: 1112, category: DiagnosticCategory.Error, key: "A class member cannot be declared optional." }, - A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: { code: 1113, category: DiagnosticCategory.Error, key: "A 'default' clause cannot appear more than once in a 'switch' statement." }, - Duplicate_label_0: { code: 1114, category: DiagnosticCategory.Error, key: "Duplicate label '{0}'" }, - A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: { code: 1115, category: DiagnosticCategory.Error, key: "A 'continue' statement can only jump to a label of an enclosing iteration statement." }, - A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: { code: 1116, category: DiagnosticCategory.Error, key: "A 'break' statement can only jump to a label of an enclosing statement." }, - An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode: { code: 1117, category: DiagnosticCategory.Error, key: "An object literal cannot have multiple properties with the same name in strict mode." }, - An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: { code: 1118, category: DiagnosticCategory.Error, key: "An object literal cannot have multiple get/set accessors with the same name." }, - An_object_literal_cannot_have_property_and_accessor_with_the_same_name: { code: 1119, category: DiagnosticCategory.Error, key: "An object literal cannot have property and accessor with the same name." }, - An_export_assignment_cannot_have_modifiers: { code: 1120, category: DiagnosticCategory.Error, key: "An export assignment cannot have modifiers." }, - Octal_literals_are_not_allowed_in_strict_mode: { code: 1121, category: DiagnosticCategory.Error, key: "Octal literals are not allowed in strict mode." }, - A_tuple_type_element_list_cannot_be_empty: { code: 1122, category: DiagnosticCategory.Error, key: "A tuple type element list cannot be empty." }, - Variable_declaration_list_cannot_be_empty: { code: 1123, category: DiagnosticCategory.Error, key: "Variable declaration list cannot be empty." }, - Digit_expected: { code: 1124, category: DiagnosticCategory.Error, key: "Digit expected." }, - Hexadecimal_digit_expected: { code: 1125, category: DiagnosticCategory.Error, key: "Hexadecimal digit expected." }, - Unexpected_end_of_text: { code: 1126, category: DiagnosticCategory.Error, key: "Unexpected end of text." }, - Invalid_character: { code: 1127, category: DiagnosticCategory.Error, key: "Invalid character." }, - Declaration_or_statement_expected: { code: 1128, category: DiagnosticCategory.Error, key: "Declaration or statement expected." }, - Statement_expected: { code: 1129, category: DiagnosticCategory.Error, key: "Statement expected." }, - case_or_default_expected: { code: 1130, category: DiagnosticCategory.Error, key: "'case' or 'default' expected." }, - Property_or_signature_expected: { code: 1131, category: DiagnosticCategory.Error, key: "Property or signature expected." }, - Enum_member_expected: { code: 1132, category: DiagnosticCategory.Error, key: "Enum member expected." }, - Variable_declaration_expected: { code: 1134, category: DiagnosticCategory.Error, key: "Variable declaration expected." }, - Argument_expression_expected: { code: 1135, category: DiagnosticCategory.Error, key: "Argument expression expected." }, - Property_assignment_expected: { code: 1136, category: DiagnosticCategory.Error, key: "Property assignment expected." }, - Expression_or_comma_expected: { code: 1137, category: DiagnosticCategory.Error, key: "Expression or comma expected." }, - Parameter_declaration_expected: { code: 1138, category: DiagnosticCategory.Error, key: "Parameter declaration expected." }, - Type_parameter_declaration_expected: { code: 1139, category: DiagnosticCategory.Error, key: "Type parameter declaration expected." }, - Type_argument_expected: { code: 1140, category: DiagnosticCategory.Error, key: "Type argument expected." }, - String_literal_expected: { code: 1141, category: DiagnosticCategory.Error, key: "String literal expected." }, - Line_break_not_permitted_here: { code: 1142, category: DiagnosticCategory.Error, key: "Line break not permitted here." }, - or_expected: { code: 1144, category: DiagnosticCategory.Error, key: "'{' or ';' expected." }, - Modifiers_not_permitted_on_index_signature_members: { code: 1145, category: DiagnosticCategory.Error, key: "Modifiers not permitted on index signature members." }, - Declaration_expected: { code: 1146, category: DiagnosticCategory.Error, key: "Declaration expected." }, - Import_declarations_in_a_namespace_cannot_reference_a_module: { code: 1147, category: DiagnosticCategory.Error, key: "Import declarations in a namespace cannot reference a module." }, - Cannot_compile_modules_unless_the_module_flag_is_provided: { code: 1148, category: DiagnosticCategory.Error, key: "Cannot compile modules unless the '--module' flag is provided." }, - File_name_0_differs_from_already_included_file_name_1_only_in_casing: { code: 1149, category: DiagnosticCategory.Error, key: "File name '{0}' differs from already included file name '{1}' only in casing" }, - new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: { code: 1150, category: DiagnosticCategory.Error, key: "'new T[]' cannot be used to create an array. Use 'new Array()' instead." }, - const_declarations_must_be_initialized: { code: 1155, category: DiagnosticCategory.Error, key: "'const' declarations must be initialized" }, - const_declarations_can_only_be_declared_inside_a_block: { code: 1156, category: DiagnosticCategory.Error, key: "'const' declarations can only be declared inside a block." }, - let_declarations_can_only_be_declared_inside_a_block: { code: 1157, category: DiagnosticCategory.Error, key: "'let' declarations can only be declared inside a block." }, - Unterminated_template_literal: { code: 1160, category: DiagnosticCategory.Error, key: "Unterminated template literal." }, - Unterminated_regular_expression_literal: { code: 1161, category: DiagnosticCategory.Error, key: "Unterminated regular expression literal." }, - An_object_member_cannot_be_declared_optional: { code: 1162, category: DiagnosticCategory.Error, key: "An object member cannot be declared optional." }, - A_yield_expression_is_only_allowed_in_a_generator_body: { code: 1163, category: DiagnosticCategory.Error, key: "A 'yield' expression is only allowed in a generator body." }, - Computed_property_names_are_not_allowed_in_enums: { code: 1164, category: DiagnosticCategory.Error, key: "Computed property names are not allowed in enums." }, - A_computed_property_name_in_an_ambient_context_must_directly_refer_to_a_built_in_symbol: { code: 1165, category: DiagnosticCategory.Error, key: "A computed property name in an ambient context must directly refer to a built-in symbol." }, - A_computed_property_name_in_a_class_property_declaration_must_directly_refer_to_a_built_in_symbol: { code: 1166, category: DiagnosticCategory.Error, key: "A computed property name in a class property declaration must directly refer to a built-in symbol." }, - A_computed_property_name_in_a_method_overload_must_directly_refer_to_a_built_in_symbol: { code: 1168, category: DiagnosticCategory.Error, key: "A computed property name in a method overload must directly refer to a built-in symbol." }, - A_computed_property_name_in_an_interface_must_directly_refer_to_a_built_in_symbol: { code: 1169, category: DiagnosticCategory.Error, key: "A computed property name in an interface must directly refer to a built-in symbol." }, - A_computed_property_name_in_a_type_literal_must_directly_refer_to_a_built_in_symbol: { code: 1170, category: DiagnosticCategory.Error, key: "A computed property name in a type literal must directly refer to a built-in symbol." }, - A_comma_expression_is_not_allowed_in_a_computed_property_name: { code: 1171, category: DiagnosticCategory.Error, key: "A comma expression is not allowed in a computed property name." }, - extends_clause_already_seen: { code: 1172, category: DiagnosticCategory.Error, key: "'extends' clause already seen." }, - extends_clause_must_precede_implements_clause: { code: 1173, category: DiagnosticCategory.Error, key: "'extends' clause must precede 'implements' clause." }, - Classes_can_only_extend_a_single_class: { code: 1174, category: DiagnosticCategory.Error, key: "Classes can only extend a single class." }, - implements_clause_already_seen: { code: 1175, category: DiagnosticCategory.Error, key: "'implements' clause already seen." }, - Interface_declaration_cannot_have_implements_clause: { code: 1176, category: DiagnosticCategory.Error, key: "Interface declaration cannot have 'implements' clause." }, - Binary_digit_expected: { code: 1177, category: DiagnosticCategory.Error, key: "Binary digit expected." }, - Octal_digit_expected: { code: 1178, category: DiagnosticCategory.Error, key: "Octal digit expected." }, - Unexpected_token_expected: { code: 1179, category: DiagnosticCategory.Error, key: "Unexpected token. '{' expected." }, - Property_destructuring_pattern_expected: { code: 1180, category: DiagnosticCategory.Error, key: "Property destructuring pattern expected." }, - Array_element_destructuring_pattern_expected: { code: 1181, category: DiagnosticCategory.Error, key: "Array element destructuring pattern expected." }, - A_destructuring_declaration_must_have_an_initializer: { code: 1182, category: DiagnosticCategory.Error, key: "A destructuring declaration must have an initializer." }, - An_implementation_cannot_be_declared_in_ambient_contexts: { code: 1184, category: DiagnosticCategory.Error, key: "An implementation cannot be declared in ambient contexts." }, - Modifiers_cannot_appear_here: { code: 1184, category: DiagnosticCategory.Error, key: "Modifiers cannot appear here." }, - Merge_conflict_marker_encountered: { code: 1185, category: DiagnosticCategory.Error, key: "Merge conflict marker encountered." }, - A_rest_element_cannot_have_an_initializer: { code: 1186, category: DiagnosticCategory.Error, key: "A rest element cannot have an initializer." }, - A_parameter_property_may_not_be_a_binding_pattern: { code: 1187, category: DiagnosticCategory.Error, key: "A parameter property may not be a binding pattern." }, - Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: { code: 1188, category: DiagnosticCategory.Error, key: "Only a single variable declaration is allowed in a 'for...of' statement." }, - The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: { code: 1189, category: DiagnosticCategory.Error, key: "The variable declaration of a 'for...in' statement cannot have an initializer." }, - The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: { code: 1190, category: DiagnosticCategory.Error, key: "The variable declaration of a 'for...of' statement cannot have an initializer." }, - An_import_declaration_cannot_have_modifiers: { code: 1191, category: DiagnosticCategory.Error, key: "An import declaration cannot have modifiers." }, - Module_0_has_no_default_export: { code: 1192, category: DiagnosticCategory.Error, key: "Module '{0}' has no default export." }, - An_export_declaration_cannot_have_modifiers: { code: 1193, category: DiagnosticCategory.Error, key: "An export declaration cannot have modifiers." }, - Export_declarations_are_not_permitted_in_a_namespace: { code: 1194, category: DiagnosticCategory.Error, key: "Export declarations are not permitted in a namespace." }, - Catch_clause_variable_name_must_be_an_identifier: { code: 1195, category: DiagnosticCategory.Error, key: "Catch clause variable name must be an identifier." }, - Catch_clause_variable_cannot_have_a_type_annotation: { code: 1196, category: DiagnosticCategory.Error, key: "Catch clause variable cannot have a type annotation." }, - Catch_clause_variable_cannot_have_an_initializer: { code: 1197, category: DiagnosticCategory.Error, key: "Catch clause variable cannot have an initializer." }, - An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive: { code: 1198, category: DiagnosticCategory.Error, key: "An extended Unicode escape value must be between 0x0 and 0x10FFFF inclusive." }, - Unterminated_Unicode_escape_sequence: { code: 1199, category: DiagnosticCategory.Error, key: "Unterminated Unicode escape sequence." }, - Line_terminator_not_permitted_before_arrow: { code: 1200, category: DiagnosticCategory.Error, key: "Line terminator not permitted before arrow." }, - Import_assignment_cannot_be_used_when_targeting_ECMAScript_6_or_higher_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_or_import_d_from_mod_instead: { code: 1202, category: DiagnosticCategory.Error, key: "Import assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"' or 'import d from \"mod\"' instead." }, - Export_assignment_cannot_be_used_when_targeting_ECMAScript_6_or_higher_Consider_using_export_default_instead: { code: 1203, category: DiagnosticCategory.Error, key: "Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead." }, - Cannot_compile_modules_into_commonjs_amd_system_or_umd_when_targeting_ES6_or_higher: { code: 1204, category: DiagnosticCategory.Error, key: "Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher." }, - Decorators_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1205, category: DiagnosticCategory.Error, key: "Decorators are only available when targeting ECMAScript 5 and higher." }, - Decorators_are_not_valid_here: { code: 1206, category: DiagnosticCategory.Error, key: "Decorators are not valid here." }, - Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: { code: 1207, category: DiagnosticCategory.Error, key: "Decorators cannot be applied to multiple get/set accessors of the same name." }, - Cannot_compile_namespaces_when_the_isolatedModules_flag_is_provided: { code: 1208, category: DiagnosticCategory.Error, key: "Cannot compile namespaces when the '--isolatedModules' flag is provided." }, - Ambient_const_enums_are_not_allowed_when_the_isolatedModules_flag_is_provided: { code: 1209, category: DiagnosticCategory.Error, key: "Ambient const enums are not allowed when the '--isolatedModules' flag is provided." }, - Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode: { code: 1210, category: DiagnosticCategory.Error, key: "Invalid use of '{0}'. Class definitions are automatically in strict mode." }, - A_class_declaration_without_the_default_modifier_must_have_a_name: { code: 1211, category: DiagnosticCategory.Error, key: "A class declaration without the 'default' modifier must have a name" }, - Identifier_expected_0_is_a_reserved_word_in_strict_mode: { code: 1212, category: DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode" }, - Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: { code: 1213, category: DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode." }, - Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: { code: 1214, category: DiagnosticCategory.Error, key: "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode." }, - Invalid_use_of_0_Modules_are_automatically_in_strict_mode: { code: 1215, category: DiagnosticCategory.Error, key: "Invalid use of '{0}'. Modules are automatically in strict mode." }, - Export_assignment_is_not_supported_when_module_flag_is_system: { code: 1218, category: DiagnosticCategory.Error, key: "Export assignment is not supported when '--module' flag is 'system'." }, - Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalDecorators_to_remove_this_warning: { code: 1219, category: DiagnosticCategory.Error, key: "Experimental support for decorators is a feature that is subject to change in a future release. Specify '--experimentalDecorators' to remove this warning." }, - Generators_are_only_available_when_targeting_ECMAScript_6_or_higher: { code: 1220, category: DiagnosticCategory.Error, key: "Generators are only available when targeting ECMAScript 6 or higher." }, - Generators_are_not_allowed_in_an_ambient_context: { code: 1221, category: DiagnosticCategory.Error, key: "Generators are not allowed in an ambient context." }, - An_overload_signature_cannot_be_declared_as_a_generator: { code: 1222, category: DiagnosticCategory.Error, key: "An overload signature cannot be declared as a generator." }, - _0_tag_already_specified: { code: 1223, category: DiagnosticCategory.Error, key: "'{0}' tag already specified." }, - Signature_0_must_have_a_type_predicate: { code: 1224, category: DiagnosticCategory.Error, key: "Signature '{0}' must have a type predicate." }, - Cannot_find_parameter_0: { code: 1225, category: DiagnosticCategory.Error, key: "Cannot find parameter '{0}'." }, - Type_predicate_0_is_not_assignable_to_1: { code: 1226, category: DiagnosticCategory.Error, key: "Type predicate '{0}' is not assignable to '{1}'." }, - Parameter_0_is_not_in_the_same_position_as_parameter_1: { code: 1227, category: DiagnosticCategory.Error, key: "Parameter '{0}' is not in the same position as parameter '{1}'." }, - A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: { code: 1228, category: DiagnosticCategory.Error, key: "A type predicate is only allowed in return type position for functions and methods." }, - A_type_predicate_cannot_reference_a_rest_parameter: { code: 1229, category: DiagnosticCategory.Error, key: "A type predicate cannot reference a rest parameter." }, - A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: { code: 1230, category: DiagnosticCategory.Error, key: "A type predicate cannot reference element '{0}' in a binding pattern." }, - An_export_assignment_can_only_be_used_in_a_module: { code: 1231, category: DiagnosticCategory.Error, key: "An export assignment can only be used in a module." }, - An_import_declaration_can_only_be_used_in_a_namespace_or_module: { code: 1232, category: DiagnosticCategory.Error, key: "An import declaration can only be used in a namespace or module." }, - An_export_declaration_can_only_be_used_in_a_module: { code: 1233, category: DiagnosticCategory.Error, key: "An export declaration can only be used in a module." }, - An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: { code: 1234, category: DiagnosticCategory.Error, key: "An ambient module declaration is only allowed at the top level in a file." }, - A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: { code: 1235, category: DiagnosticCategory.Error, key: "A namespace declaration is only allowed in a namespace or module." }, - Experimental_support_for_async_functions_is_a_feature_that_is_subject_to_change_in_a_future_release_Specify_experimentalAsyncFunctions_to_remove_this_warning: { code: 1236, category: DiagnosticCategory.Error, key: "Experimental support for async functions is a feature that is subject to change in a future release. Specify '--experimentalAsyncFunctions' to remove this warning." }, - with_statements_are_not_allowed_in_an_async_function_block: { code: 1300, category: DiagnosticCategory.Error, key: "'with' statements are not allowed in an async function block." }, - await_expression_is_only_allowed_within_an_async_function: { code: 1308, category: DiagnosticCategory.Error, key: "'await' expression is only allowed within an async function." }, - Async_functions_are_only_available_when_targeting_ECMAScript_6_and_higher: { code: 1311, category: DiagnosticCategory.Error, key: "Async functions are only available when targeting ECMAScript 6 and higher." }, - The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: { code: 1236, category: DiagnosticCategory.Error, key: "The return type of a property decorator function must be either 'void' or 'any'." }, - The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: { code: 1237, category: DiagnosticCategory.Error, key: "The return type of a parameter decorator function must be either 'void' or 'any'." }, - Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: { code: 1238, category: DiagnosticCategory.Error, key: "Unable to resolve signature of class decorator when called as an expression." }, - Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: { code: 1239, category: DiagnosticCategory.Error, key: "Unable to resolve signature of parameter decorator when called as an expression." }, - Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: { code: 1240, category: DiagnosticCategory.Error, key: "Unable to resolve signature of property decorator when called as an expression." }, - Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: { code: 1241, category: DiagnosticCategory.Error, key: "Unable to resolve signature of method decorator when called as an expression." }, - abstract_modifier_can_only_appear_on_a_class_or_method_declaration: { code: 1242, category: DiagnosticCategory.Error, key: "'abstract' modifier can only appear on a class or method declaration." }, - _0_modifier_cannot_be_used_with_1_modifier: { code: 1243, category: DiagnosticCategory.Error, key: "'{0}' modifier cannot be used with '{1}' modifier." }, - Abstract_methods_can_only_appear_within_an_abstract_class: { code: 1244, category: DiagnosticCategory.Error, key: "Abstract methods can only appear within an abstract class." }, - Method_0_cannot_have_an_implementation_because_it_is_marked_abstract: { code: 1245, category: DiagnosticCategory.Error, key: "Method '{0}' cannot have an implementation because it is marked abstract." }, - Duplicate_identifier_0: { code: 2300, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." }, - Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: DiagnosticCategory.Error, key: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." }, - Static_members_cannot_reference_class_type_parameters: { code: 2302, category: DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." }, - Circular_definition_of_import_alias_0: { code: 2303, category: DiagnosticCategory.Error, key: "Circular definition of import alias '{0}'." }, - Cannot_find_name_0: { code: 2304, category: DiagnosticCategory.Error, key: "Cannot find name '{0}'." }, - Module_0_has_no_exported_member_1: { code: 2305, category: DiagnosticCategory.Error, key: "Module '{0}' has no exported member '{1}'." }, - File_0_is_not_a_module: { code: 2306, category: DiagnosticCategory.Error, key: "File '{0}' is not a module." }, - Cannot_find_module_0: { code: 2307, category: DiagnosticCategory.Error, key: "Cannot find module '{0}'." }, - An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements: { code: 2309, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in a module with other exported elements." }, - Type_0_recursively_references_itself_as_a_base_type: { code: 2310, category: DiagnosticCategory.Error, key: "Type '{0}' recursively references itself as a base type." }, - A_class_may_only_extend_another_class: { code: 2311, category: DiagnosticCategory.Error, key: "A class may only extend another class." }, - An_interface_may_only_extend_a_class_or_another_interface: { code: 2312, category: DiagnosticCategory.Error, key: "An interface may only extend a class or another interface." }, - Constraint_of_a_type_parameter_cannot_reference_any_type_parameter_from_the_same_type_parameter_list: { code: 2313, category: DiagnosticCategory.Error, key: "Constraint of a type parameter cannot reference any type parameter from the same type parameter list." }, - Generic_type_0_requires_1_type_argument_s: { code: 2314, category: DiagnosticCategory.Error, key: "Generic type '{0}' requires {1} type argument(s)." }, - Type_0_is_not_generic: { code: 2315, category: DiagnosticCategory.Error, key: "Type '{0}' is not generic." }, - Global_type_0_must_be_a_class_or_interface_type: { code: 2316, category: DiagnosticCategory.Error, key: "Global type '{0}' must be a class or interface type." }, - Global_type_0_must_have_1_type_parameter_s: { code: 2317, category: DiagnosticCategory.Error, key: "Global type '{0}' must have {1} type parameter(s)." }, - Cannot_find_global_type_0: { code: 2318, category: DiagnosticCategory.Error, key: "Cannot find global type '{0}'." }, - Named_property_0_of_types_1_and_2_are_not_identical: { code: 2319, category: DiagnosticCategory.Error, key: "Named property '{0}' of types '{1}' and '{2}' are not identical." }, - Interface_0_cannot_simultaneously_extend_types_1_and_2: { code: 2320, category: DiagnosticCategory.Error, key: "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}'." }, - Excessive_stack_depth_comparing_types_0_and_1: { code: 2321, category: DiagnosticCategory.Error, key: "Excessive stack depth comparing types '{0}' and '{1}'." }, - Type_0_is_not_assignable_to_type_1: { code: 2322, category: DiagnosticCategory.Error, key: "Type '{0}' is not assignable to type '{1}'." }, - Property_0_is_missing_in_type_1: { code: 2324, category: DiagnosticCategory.Error, key: "Property '{0}' is missing in type '{1}'." }, - Property_0_is_private_in_type_1_but_not_in_type_2: { code: 2325, category: DiagnosticCategory.Error, key: "Property '{0}' is private in type '{1}' but not in type '{2}'." }, - Types_of_property_0_are_incompatible: { code: 2326, category: DiagnosticCategory.Error, key: "Types of property '{0}' are incompatible." }, - Property_0_is_optional_in_type_1_but_required_in_type_2: { code: 2327, category: DiagnosticCategory.Error, key: "Property '{0}' is optional in type '{1}' but required in type '{2}'." }, - Types_of_parameters_0_and_1_are_incompatible: { code: 2328, category: DiagnosticCategory.Error, key: "Types of parameters '{0}' and '{1}' are incompatible." }, - Index_signature_is_missing_in_type_0: { code: 2329, category: DiagnosticCategory.Error, key: "Index signature is missing in type '{0}'." }, - Index_signatures_are_incompatible: { code: 2330, category: DiagnosticCategory.Error, key: "Index signatures are incompatible." }, - this_cannot_be_referenced_in_a_module_or_namespace_body: { code: 2331, category: DiagnosticCategory.Error, key: "'this' cannot be referenced in a module or namespace body." }, - this_cannot_be_referenced_in_current_location: { code: 2332, category: DiagnosticCategory.Error, key: "'this' cannot be referenced in current location." }, - this_cannot_be_referenced_in_constructor_arguments: { code: 2333, category: DiagnosticCategory.Error, key: "'this' cannot be referenced in constructor arguments." }, - this_cannot_be_referenced_in_a_static_property_initializer: { code: 2334, category: DiagnosticCategory.Error, key: "'this' cannot be referenced in a static property initializer." }, - super_can_only_be_referenced_in_a_derived_class: { code: 2335, category: DiagnosticCategory.Error, key: "'super' can only be referenced in a derived class." }, - super_cannot_be_referenced_in_constructor_arguments: { code: 2336, category: DiagnosticCategory.Error, key: "'super' cannot be referenced in constructor arguments." }, - Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: { code: 2337, category: DiagnosticCategory.Error, key: "Super calls are not permitted outside constructors or in nested functions inside constructors." }, - super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: { code: 2338, category: DiagnosticCategory.Error, key: "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class." }, - Property_0_does_not_exist_on_type_1: { code: 2339, category: DiagnosticCategory.Error, key: "Property '{0}' does not exist on type '{1}'." }, - Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword: { code: 2340, category: DiagnosticCategory.Error, key: "Only public and protected methods of the base class are accessible via the 'super' keyword." }, - Property_0_is_private_and_only_accessible_within_class_1: { code: 2341, category: DiagnosticCategory.Error, key: "Property '{0}' is private and only accessible within class '{1}'." }, - An_index_expression_argument_must_be_of_type_string_number_symbol_or_any: { code: 2342, category: DiagnosticCategory.Error, key: "An index expression argument must be of type 'string', 'number', 'symbol', or 'any'." }, - Type_0_does_not_satisfy_the_constraint_1: { code: 2344, category: DiagnosticCategory.Error, key: "Type '{0}' does not satisfy the constraint '{1}'." }, - Argument_of_type_0_is_not_assignable_to_parameter_of_type_1: { code: 2345, category: DiagnosticCategory.Error, key: "Argument of type '{0}' is not assignable to parameter of type '{1}'." }, - Supplied_parameters_do_not_match_any_signature_of_call_target: { code: 2346, category: DiagnosticCategory.Error, key: "Supplied parameters do not match any signature of call target." }, - Untyped_function_calls_may_not_accept_type_arguments: { code: 2347, category: DiagnosticCategory.Error, key: "Untyped function calls may not accept type arguments." }, - Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: { code: 2348, category: DiagnosticCategory.Error, key: "Value of type '{0}' is not callable. Did you mean to include 'new'?" }, - Cannot_invoke_an_expression_whose_type_lacks_a_call_signature: { code: 2349, category: DiagnosticCategory.Error, key: "Cannot invoke an expression whose type lacks a call signature." }, - Only_a_void_function_can_be_called_with_the_new_keyword: { code: 2350, category: DiagnosticCategory.Error, key: "Only a void function can be called with the 'new' keyword." }, - Cannot_use_new_with_an_expression_whose_type_lacks_a_call_or_construct_signature: { code: 2351, category: DiagnosticCategory.Error, key: "Cannot use 'new' with an expression whose type lacks a call or construct signature." }, - Neither_type_0_nor_type_1_is_assignable_to_the_other: { code: 2352, category: DiagnosticCategory.Error, key: "Neither type '{0}' nor type '{1}' is assignable to the other." }, - Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: { code: 2353, category: DiagnosticCategory.Error, key: "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'." }, - No_best_common_type_exists_among_return_expressions: { code: 2354, category: DiagnosticCategory.Error, key: "No best common type exists among return expressions." }, - A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2355, category: DiagnosticCategory.Error, key: "A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement." }, - An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type: { code: 2356, category: DiagnosticCategory.Error, key: "An arithmetic operand must be of type 'any', 'number' or an enum type." }, - The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_property_or_indexer: { code: 2357, category: DiagnosticCategory.Error, key: "The operand of an increment or decrement operator must be a variable, property or indexer." }, - The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2358, category: DiagnosticCategory.Error, key: "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter." }, - The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: { code: 2359, category: DiagnosticCategory.Error, key: "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type." }, - The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol: { code: 2360, category: DiagnosticCategory.Error, key: "The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'." }, - The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2361, category: DiagnosticCategory.Error, key: "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter" }, - The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: { code: 2362, category: DiagnosticCategory.Error, key: "The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type." }, - The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_or_an_enum_type: { code: 2363, category: DiagnosticCategory.Error, key: "The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type." }, - Invalid_left_hand_side_of_assignment_expression: { code: 2364, category: DiagnosticCategory.Error, key: "Invalid left-hand side of assignment expression." }, - Operator_0_cannot_be_applied_to_types_1_and_2: { code: 2365, category: DiagnosticCategory.Error, key: "Operator '{0}' cannot be applied to types '{1}' and '{2}'." }, - Type_parameter_name_cannot_be_0: { code: 2368, category: DiagnosticCategory.Error, key: "Type parameter name cannot be '{0}'" }, - A_parameter_property_is_only_allowed_in_a_constructor_implementation: { code: 2369, category: DiagnosticCategory.Error, key: "A parameter property is only allowed in a constructor implementation." }, - A_rest_parameter_must_be_of_an_array_type: { code: 2370, category: DiagnosticCategory.Error, key: "A rest parameter must be of an array type." }, - A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation: { code: 2371, category: DiagnosticCategory.Error, key: "A parameter initializer is only allowed in a function or constructor implementation." }, - Parameter_0_cannot_be_referenced_in_its_initializer: { code: 2372, category: DiagnosticCategory.Error, key: "Parameter '{0}' cannot be referenced in its initializer." }, - Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it: { code: 2373, category: DiagnosticCategory.Error, key: "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it." }, - Duplicate_string_index_signature: { code: 2374, category: DiagnosticCategory.Error, key: "Duplicate string index signature." }, - Duplicate_number_index_signature: { code: 2375, category: DiagnosticCategory.Error, key: "Duplicate number index signature." }, - A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties: { code: 2376, category: DiagnosticCategory.Error, key: "A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties." }, - Constructors_for_derived_classes_must_contain_a_super_call: { code: 2377, category: DiagnosticCategory.Error, key: "Constructors for derived classes must contain a 'super' call." }, - A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement: { code: 2378, category: DiagnosticCategory.Error, key: "A 'get' accessor must return a value or consist of a single 'throw' statement." }, - Getter_and_setter_accessors_do_not_agree_in_visibility: { code: 2379, category: DiagnosticCategory.Error, key: "Getter and setter accessors do not agree in visibility." }, - get_and_set_accessor_must_have_the_same_type: { code: 2380, category: DiagnosticCategory.Error, key: "'get' and 'set' accessor must have the same type." }, - A_signature_with_an_implementation_cannot_use_a_string_literal_type: { code: 2381, category: DiagnosticCategory.Error, key: "A signature with an implementation cannot use a string literal type." }, - Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature: { code: 2382, category: DiagnosticCategory.Error, key: "Specialized overload signature is not assignable to any non-specialized signature." }, - Overload_signatures_must_all_be_exported_or_not_exported: { code: 2383, category: DiagnosticCategory.Error, key: "Overload signatures must all be exported or not exported." }, - Overload_signatures_must_all_be_ambient_or_non_ambient: { code: 2384, category: DiagnosticCategory.Error, key: "Overload signatures must all be ambient or non-ambient." }, - Overload_signatures_must_all_be_public_private_or_protected: { code: 2385, category: DiagnosticCategory.Error, key: "Overload signatures must all be public, private or protected." }, - Overload_signatures_must_all_be_optional_or_required: { code: 2386, category: DiagnosticCategory.Error, key: "Overload signatures must all be optional or required." }, - Function_overload_must_be_static: { code: 2387, category: DiagnosticCategory.Error, key: "Function overload must be static." }, - Function_overload_must_not_be_static: { code: 2388, category: DiagnosticCategory.Error, key: "Function overload must not be static." }, - Function_implementation_name_must_be_0: { code: 2389, category: DiagnosticCategory.Error, key: "Function implementation name must be '{0}'." }, - Constructor_implementation_is_missing: { code: 2390, category: DiagnosticCategory.Error, key: "Constructor implementation is missing." }, - Function_implementation_is_missing_or_not_immediately_following_the_declaration: { code: 2391, category: DiagnosticCategory.Error, key: "Function implementation is missing or not immediately following the declaration." }, - Multiple_constructor_implementations_are_not_allowed: { code: 2392, category: DiagnosticCategory.Error, key: "Multiple constructor implementations are not allowed." }, - Duplicate_function_implementation: { code: 2393, category: DiagnosticCategory.Error, key: "Duplicate function implementation." }, - Overload_signature_is_not_compatible_with_function_implementation: { code: 2394, category: DiagnosticCategory.Error, key: "Overload signature is not compatible with function implementation." }, - Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local: { code: 2395, category: DiagnosticCategory.Error, key: "Individual declarations in merged declaration '{0}' must be all exported or all local." }, - Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: { code: 2396, category: DiagnosticCategory.Error, key: "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters." }, - Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: { code: 2399, category: DiagnosticCategory.Error, key: "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference." }, - Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: { code: 2400, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference." }, - Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference: { code: 2401, category: DiagnosticCategory.Error, key: "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference." }, - Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: { code: 2402, category: DiagnosticCategory.Error, key: "Expression resolves to '_super' that compiler uses to capture base class reference." }, - Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: { code: 2403, category: DiagnosticCategory.Error, key: "Subsequent variable declarations must have the same type. Variable '{0}' must be of type '{1}', but here has type '{2}'." }, - The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation: { code: 2404, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement cannot use a type annotation." }, - The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any: { code: 2405, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement must be of type 'string' or 'any'." }, - Invalid_left_hand_side_in_for_in_statement: { code: 2406, category: DiagnosticCategory.Error, key: "Invalid left-hand side in 'for...in' statement." }, - The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter: { code: 2407, category: DiagnosticCategory.Error, key: "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter." }, - Setters_cannot_return_a_value: { code: 2408, category: DiagnosticCategory.Error, key: "Setters cannot return a value." }, - Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: { code: 2409, category: DiagnosticCategory.Error, key: "Return type of constructor signature must be assignable to the instance type of the class" }, - All_symbols_within_a_with_block_will_be_resolved_to_any: { code: 2410, category: DiagnosticCategory.Error, key: "All symbols within a 'with' block will be resolved to 'any'." }, - Property_0_of_type_1_is_not_assignable_to_string_index_type_2: { code: 2411, category: DiagnosticCategory.Error, key: "Property '{0}' of type '{1}' is not assignable to string index type '{2}'." }, - Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2: { code: 2412, category: DiagnosticCategory.Error, key: "Property '{0}' of type '{1}' is not assignable to numeric index type '{2}'." }, - Numeric_index_type_0_is_not_assignable_to_string_index_type_1: { code: 2413, category: DiagnosticCategory.Error, key: "Numeric index type '{0}' is not assignable to string index type '{1}'." }, - Class_name_cannot_be_0: { code: 2414, category: DiagnosticCategory.Error, key: "Class name cannot be '{0}'" }, - Class_0_incorrectly_extends_base_class_1: { code: 2415, category: DiagnosticCategory.Error, key: "Class '{0}' incorrectly extends base class '{1}'." }, - Class_static_side_0_incorrectly_extends_base_class_static_side_1: { code: 2417, category: DiagnosticCategory.Error, key: "Class static side '{0}' incorrectly extends base class static side '{1}'." }, - Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0: { code: 2419, category: DiagnosticCategory.Error, key: "Type name '{0}' in extends clause does not reference constructor function for '{0}'." }, - Class_0_incorrectly_implements_interface_1: { code: 2420, category: DiagnosticCategory.Error, key: "Class '{0}' incorrectly implements interface '{1}'." }, - A_class_may_only_implement_another_class_or_interface: { code: 2422, category: DiagnosticCategory.Error, key: "A class may only implement another class or interface." }, - Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: { code: 2423, category: DiagnosticCategory.Error, key: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor." }, - Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property: { code: 2424, category: DiagnosticCategory.Error, key: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property." }, - Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: { code: 2425, category: DiagnosticCategory.Error, key: "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function." }, - Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: { code: 2426, category: DiagnosticCategory.Error, key: "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function." }, - Interface_name_cannot_be_0: { code: 2427, category: DiagnosticCategory.Error, key: "Interface name cannot be '{0}'" }, - All_declarations_of_an_interface_must_have_identical_type_parameters: { code: 2428, category: DiagnosticCategory.Error, key: "All declarations of an interface must have identical type parameters." }, - Interface_0_incorrectly_extends_interface_1: { code: 2430, category: DiagnosticCategory.Error, key: "Interface '{0}' incorrectly extends interface '{1}'." }, - Enum_name_cannot_be_0: { code: 2431, category: DiagnosticCategory.Error, key: "Enum name cannot be '{0}'" }, - In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element: { code: 2432, category: DiagnosticCategory.Error, key: "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element." }, - A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged: { code: 2433, category: DiagnosticCategory.Error, key: "A namespace declaration cannot be in a different file from a class or function with which it is merged" }, - A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged: { code: 2434, category: DiagnosticCategory.Error, key: "A namespace declaration cannot be located prior to a class or function with which it is merged" }, - Ambient_modules_cannot_be_nested_in_other_modules: { code: 2435, category: DiagnosticCategory.Error, key: "Ambient modules cannot be nested in other modules." }, - Ambient_module_declaration_cannot_specify_relative_module_name: { code: 2436, category: DiagnosticCategory.Error, key: "Ambient module declaration cannot specify relative module name." }, - Module_0_is_hidden_by_a_local_declaration_with_the_same_name: { code: 2437, category: DiagnosticCategory.Error, key: "Module '{0}' is hidden by a local declaration with the same name" }, - Import_name_cannot_be_0: { code: 2438, category: DiagnosticCategory.Error, key: "Import name cannot be '{0}'" }, - Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name: { code: 2439, category: DiagnosticCategory.Error, key: "Import or export declaration in an ambient module declaration cannot reference module through relative module name." }, - Import_declaration_conflicts_with_local_declaration_of_0: { code: 2440, category: DiagnosticCategory.Error, key: "Import declaration conflicts with local declaration of '{0}'" }, - Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module: { code: 2441, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module." }, - Types_have_separate_declarations_of_a_private_property_0: { code: 2442, category: DiagnosticCategory.Error, key: "Types have separate declarations of a private property '{0}'." }, - Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2: { code: 2443, category: DiagnosticCategory.Error, key: "Property '{0}' is protected but type '{1}' is not a class derived from '{2}'." }, - Property_0_is_protected_in_type_1_but_public_in_type_2: { code: 2444, category: DiagnosticCategory.Error, key: "Property '{0}' is protected in type '{1}' but public in type '{2}'." }, - Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses: { code: 2445, category: DiagnosticCategory.Error, key: "Property '{0}' is protected and only accessible within class '{1}' and its subclasses." }, - Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1: { code: 2446, category: DiagnosticCategory.Error, key: "Property '{0}' is protected and only accessible through an instance of class '{1}'." }, - The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead: { code: 2447, category: DiagnosticCategory.Error, key: "The '{0}' operator is not allowed for boolean types. Consider using '{1}' instead." }, - Block_scoped_variable_0_used_before_its_declaration: { code: 2448, category: DiagnosticCategory.Error, key: "Block-scoped variable '{0}' used before its declaration." }, - The_operand_of_an_increment_or_decrement_operator_cannot_be_a_constant: { code: 2449, category: DiagnosticCategory.Error, key: "The operand of an increment or decrement operator cannot be a constant." }, - Left_hand_side_of_assignment_expression_cannot_be_a_constant: { code: 2450, category: DiagnosticCategory.Error, key: "Left-hand side of assignment expression cannot be a constant." }, - Cannot_redeclare_block_scoped_variable_0: { code: 2451, category: DiagnosticCategory.Error, key: "Cannot redeclare block-scoped variable '{0}'." }, - An_enum_member_cannot_have_a_numeric_name: { code: 2452, category: DiagnosticCategory.Error, key: "An enum member cannot have a numeric name." }, - The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly: { code: 2453, category: DiagnosticCategory.Error, key: "The type argument for type parameter '{0}' cannot be inferred from the usage. Consider specifying the type arguments explicitly." }, - Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0: { code: 2455, category: DiagnosticCategory.Error, key: "Type argument candidate '{1}' is not a valid type argument because it is not a supertype of candidate '{0}'." }, - Type_alias_0_circularly_references_itself: { code: 2456, category: DiagnosticCategory.Error, key: "Type alias '{0}' circularly references itself." }, - Type_alias_name_cannot_be_0: { code: 2457, category: DiagnosticCategory.Error, key: "Type alias name cannot be '{0}'" }, - An_AMD_module_cannot_have_multiple_name_assignments: { code: 2458, category: DiagnosticCategory.Error, key: "An AMD module cannot have multiple name assignments." }, - Type_0_has_no_property_1_and_no_string_index_signature: { code: 2459, category: DiagnosticCategory.Error, key: "Type '{0}' has no property '{1}' and no string index signature." }, - Type_0_has_no_property_1: { code: 2460, category: DiagnosticCategory.Error, key: "Type '{0}' has no property '{1}'." }, - Type_0_is_not_an_array_type: { code: 2461, category: DiagnosticCategory.Error, key: "Type '{0}' is not an array type." }, - A_rest_element_must_be_last_in_an_array_destructuring_pattern: { code: 2462, category: DiagnosticCategory.Error, key: "A rest element must be last in an array destructuring pattern" }, - A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature: { code: 2463, category: DiagnosticCategory.Error, key: "A binding pattern parameter cannot be optional in an implementation signature." }, - A_computed_property_name_must_be_of_type_string_number_symbol_or_any: { code: 2464, category: DiagnosticCategory.Error, key: "A computed property name must be of type 'string', 'number', 'symbol', or 'any'." }, - this_cannot_be_referenced_in_a_computed_property_name: { code: 2465, category: DiagnosticCategory.Error, key: "'this' cannot be referenced in a computed property name." }, - super_cannot_be_referenced_in_a_computed_property_name: { code: 2466, category: DiagnosticCategory.Error, key: "'super' cannot be referenced in a computed property name." }, - A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type: { code: 2467, category: DiagnosticCategory.Error, key: "A computed property name cannot reference a type parameter from its containing type." }, - Cannot_find_global_value_0: { code: 2468, category: DiagnosticCategory.Error, key: "Cannot find global value '{0}'." }, - The_0_operator_cannot_be_applied_to_type_symbol: { code: 2469, category: DiagnosticCategory.Error, key: "The '{0}' operator cannot be applied to type 'symbol'." }, - Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object: { code: 2470, category: DiagnosticCategory.Error, key: "'Symbol' reference does not refer to the global Symbol constructor object." }, - A_computed_property_name_of_the_form_0_must_be_of_type_symbol: { code: 2471, category: DiagnosticCategory.Error, key: "A computed property name of the form '{0}' must be of type 'symbol'." }, - Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher: { code: 2472, category: DiagnosticCategory.Error, key: "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher." }, - Enum_declarations_must_all_be_const_or_non_const: { code: 2473, category: DiagnosticCategory.Error, key: "Enum declarations must all be const or non-const." }, - In_const_enum_declarations_member_initializer_must_be_constant_expression: { code: 2474, category: DiagnosticCategory.Error, key: "In 'const' enum declarations member initializer must be constant expression." }, - const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment: { code: 2475, category: DiagnosticCategory.Error, key: "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment." }, - A_const_enum_member_can_only_be_accessed_using_a_string_literal: { code: 2476, category: DiagnosticCategory.Error, key: "A const enum member can only be accessed using a string literal." }, - const_enum_member_initializer_was_evaluated_to_a_non_finite_value: { code: 2477, category: DiagnosticCategory.Error, key: "'const' enum member initializer was evaluated to a non-finite value." }, - const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN: { code: 2478, category: DiagnosticCategory.Error, key: "'const' enum member initializer was evaluated to disallowed value 'NaN'." }, - Property_0_does_not_exist_on_const_enum_1: { code: 2479, category: DiagnosticCategory.Error, key: "Property '{0}' does not exist on 'const' enum '{1}'." }, - let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations: { code: 2480, category: DiagnosticCategory.Error, key: "'let' is not allowed to be used as a name in 'let' or 'const' declarations." }, - Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: { code: 2481, category: DiagnosticCategory.Error, key: "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'." }, - The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: { code: 2483, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...of' statement cannot use a type annotation." }, - Export_declaration_conflicts_with_exported_declaration_of_0: { code: 2484, category: DiagnosticCategory.Error, key: "Export declaration conflicts with exported declaration of '{0}'" }, - The_left_hand_side_of_a_for_of_statement_cannot_be_a_previously_defined_constant: { code: 2485, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...of' statement cannot be a previously defined constant." }, - The_left_hand_side_of_a_for_in_statement_cannot_be_a_previously_defined_constant: { code: 2486, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement cannot be a previously defined constant." }, - Invalid_left_hand_side_in_for_of_statement: { code: 2487, category: DiagnosticCategory.Error, key: "Invalid left-hand side in 'for...of' statement." }, - Type_must_have_a_Symbol_iterator_method_that_returns_an_iterator: { code: 2488, category: DiagnosticCategory.Error, key: "Type must have a '[Symbol.iterator]()' method that returns an iterator." }, - An_iterator_must_have_a_next_method: { code: 2489, category: DiagnosticCategory.Error, key: "An iterator must have a 'next()' method." }, - The_type_returned_by_the_next_method_of_an_iterator_must_have_a_value_property: { code: 2490, category: DiagnosticCategory.Error, key: "The type returned by the 'next()' method of an iterator must have a 'value' property." }, - The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern: { code: 2491, category: DiagnosticCategory.Error, key: "The left-hand side of a 'for...in' statement cannot be a destructuring pattern." }, - Cannot_redeclare_identifier_0_in_catch_clause: { code: 2492, category: DiagnosticCategory.Error, key: "Cannot redeclare identifier '{0}' in catch clause" }, - Tuple_type_0_with_length_1_cannot_be_assigned_to_tuple_with_length_2: { code: 2493, category: DiagnosticCategory.Error, key: "Tuple type '{0}' with length '{1}' cannot be assigned to tuple with length '{2}'." }, - Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher: { code: 2494, category: DiagnosticCategory.Error, key: "Using a string in a 'for...of' statement is only supported in ECMAScript 5 and higher." }, - Type_0_is_not_an_array_type_or_a_string_type: { code: 2495, category: DiagnosticCategory.Error, key: "Type '{0}' is not an array type or a string type." }, - The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression: { code: 2496, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression." }, - Module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct: { code: 2497, category: DiagnosticCategory.Error, key: "Module '{0}' resolves to a non-module entity and cannot be imported using this construct." }, - Module_0_uses_export_and_cannot_be_used_with_export_Asterisk: { code: 2498, category: DiagnosticCategory.Error, key: "Module '{0}' uses 'export =' and cannot be used with 'export *'." }, - An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2499, category: DiagnosticCategory.Error, key: "An interface can only extend an identifier/qualified-name with optional type arguments." }, - A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: { code: 2500, category: DiagnosticCategory.Error, key: "A class can only implement an identifier/qualified-name with optional type arguments." }, - A_rest_element_cannot_contain_a_binding_pattern: { code: 2501, category: DiagnosticCategory.Error, key: "A rest element cannot contain a binding pattern." }, - _0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: { code: 2502, category: DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own type annotation." }, - Cannot_find_namespace_0: { code: 2503, category: DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." }, - No_best_common_type_exists_among_yield_expressions: { code: 2504, category: DiagnosticCategory.Error, key: "No best common type exists among yield expressions." }, - A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: DiagnosticCategory.Error, key: "A generator cannot have a 'void' type annotation." }, - _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: { code: 2506, category: DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own base expression." }, - Type_0_is_not_a_constructor_function_type: { code: 2507, category: DiagnosticCategory.Error, key: "Type '{0}' is not a constructor function type." }, - No_base_constructor_has_the_specified_number_of_type_arguments: { code: 2508, category: DiagnosticCategory.Error, key: "No base constructor has the specified number of type arguments." }, - Base_constructor_return_type_0_is_not_a_class_or_interface_type: { code: 2509, category: DiagnosticCategory.Error, key: "Base constructor return type '{0}' is not a class or interface type." }, - Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: DiagnosticCategory.Error, key: "Base constructors must all have the same return type." }, - Cannot_create_an_instance_of_the_abstract_class_0: { code: 2511, category: DiagnosticCategory.Error, key: "Cannot create an instance of the abstract class '{0}'." }, - Overload_signatures_must_all_be_abstract_or_not_abstract: { code: 2512, category: DiagnosticCategory.Error, key: "Overload signatures must all be abstract or not abstract." }, - Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: { code: 2513, category: DiagnosticCategory.Error, key: "Abstract method '{0}' in class '{1}' cannot be accessed via super expression." }, - Classes_containing_abstract_methods_must_be_marked_abstract: { code: 2514, category: DiagnosticCategory.Error, key: "Classes containing abstract methods must be marked abstract." }, - Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: { code: 2515, category: DiagnosticCategory.Error, key: "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'." }, - All_declarations_of_an_abstract_method_must_be_consecutive: { code: 2516, category: DiagnosticCategory.Error, key: "All declarations of an abstract method must be consecutive." }, - Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type: { code: 2517, category: DiagnosticCategory.Error, key: "Cannot assign an abstract constructor type to a non-abstract constructor type." }, - Only_an_ambient_class_can_be_merged_with_an_interface: { code: 2518, category: DiagnosticCategory.Error, key: "Only an ambient class can be merged with an interface." }, - Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: { code: 2520, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions." }, - Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions: { code: 2521, category: DiagnosticCategory.Error, key: "Expression resolves to variable declaration '{0}' that compiler uses to support async functions." }, - The_arguments_object_cannot_be_referenced_in_an_async_arrow_function_Consider_using_a_standard_async_function_expression: { code: 2522, category: DiagnosticCategory.Error, key: "The 'arguments' object cannot be referenced in an async arrow function. Consider using a standard async function expression." }, - yield_expressions_cannot_be_used_in_a_parameter_initializer: { code: 2523, category: DiagnosticCategory.Error, key: "'yield' expressions cannot be used in a parameter initializer." }, - await_expressions_cannot_be_used_in_a_parameter_initializer: { code: 2524, category: DiagnosticCategory.Error, key: "'await' expressions cannot be used in a parameter initializer." }, - Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value: { code: 2525, category: DiagnosticCategory.Error, key: "Initializer provides no value for this binding element and the binding element has no default value." }, - JSX_element_attributes_type_0_must_be_an_object_type: { code: 2600, category: DiagnosticCategory.Error, key: "JSX element attributes type '{0}' must be an object type." }, - The_return_type_of_a_JSX_element_constructor_must_return_an_object_type: { code: 2601, category: DiagnosticCategory.Error, key: "The return type of a JSX element constructor must return an object type." }, - JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist: { code: 2602, category: DiagnosticCategory.Error, key: "JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist." }, - Property_0_in_type_1_is_not_assignable_to_type_2: { code: 2603, category: DiagnosticCategory.Error, key: "Property '{0}' in type '{1}' is not assignable to type '{2}'" }, - JSX_element_type_0_does_not_have_any_construct_or_call_signatures: { code: 2604, category: DiagnosticCategory.Error, key: "JSX element type '{0}' does not have any construct or call signatures." }, - JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements: { code: 2605, category: DiagnosticCategory.Error, key: "JSX element type '{0}' is not a constructor function for JSX elements." }, - Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property: { code: 2606, category: DiagnosticCategory.Error, key: "Property '{0}' of JSX spread attribute is not assignable to target property." }, - JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property: { code: 2607, category: DiagnosticCategory.Error, key: "JSX element class does not support attributes because it does not have a '{0}' property" }, - The_global_type_JSX_0_may_not_have_more_than_one_property: { code: 2608, category: DiagnosticCategory.Error, key: "The global type 'JSX.{0}' may not have more than one property" }, - Cannot_emit_namespaced_JSX_elements_in_React: { code: 2650, category: DiagnosticCategory.Error, key: "Cannot emit namespaced JSX elements in React" }, - A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: { code: 2651, category: DiagnosticCategory.Error, key: "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums." }, - Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: { code: 2652, category: DiagnosticCategory.Error, key: "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead." }, - Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1: { code: 2653, category: DiagnosticCategory.Error, key: "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'." }, - Exported_external_package_typings_file_cannot_contain_tripleslash_references_Please_contact_the_package_author_to_update_the_package_definition: { code: 2654, category: DiagnosticCategory.Error, key: "Exported external package typings file cannot contain tripleslash references. Please contact the package author to update the package definition." }, - Exported_external_package_typings_can_only_be_in_d_ts_files_Please_contact_the_package_author_to_update_the_package_definition: { code: 2655, category: DiagnosticCategory.Error, key: "Exported external package typings can only be in '.d.ts' files. Please contact the package author to update the package definition." }, - Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_the_package_definition: { code: 2656, category: DiagnosticCategory.Error, key: "Exported external package typings file '{0}' is not a module. Please contact the package author to update the package definition." }, - Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." }, - Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." }, - Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." }, - Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4006, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'." }, - Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4008, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of call signature from exported interface has or is using private name '{1}'." }, - Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: { code: 4010, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of public static method from exported class has or is using private name '{1}'." }, - Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: { code: 4012, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of public method from exported class has or is using private name '{1}'." }, - Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: { code: 4014, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of method from exported interface has or is using private name '{1}'." }, - Type_parameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 4016, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported function has or is using private name '{1}'." }, - Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 4019, category: DiagnosticCategory.Error, key: "Implements clause of exported class '{0}' has or is using private name '{1}'." }, - Extends_clause_of_exported_class_0_has_or_is_using_private_name_1: { code: 4020, category: DiagnosticCategory.Error, key: "Extends clause of exported class '{0}' has or is using private name '{1}'." }, - Extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: { code: 4022, category: DiagnosticCategory.Error, key: "Extends clause of exported interface '{0}' has or is using private name '{1}'." }, - Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4023, category: DiagnosticCategory.Error, key: "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named." }, - Exported_variable_0_has_or_is_using_name_1_from_private_module_2: { code: 4024, category: DiagnosticCategory.Error, key: "Exported variable '{0}' has or is using name '{1}' from private module '{2}'." }, - Exported_variable_0_has_or_is_using_private_name_1: { code: 4025, category: DiagnosticCategory.Error, key: "Exported variable '{0}' has or is using private name '{1}'." }, - Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4026, category: DiagnosticCategory.Error, key: "Public static property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named." }, - Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4027, category: DiagnosticCategory.Error, key: "Public static property '{0}' of exported class has or is using name '{1}' from private module '{2}'." }, - Public_static_property_0_of_exported_class_has_or_is_using_private_name_1: { code: 4028, category: DiagnosticCategory.Error, key: "Public static property '{0}' of exported class has or is using private name '{1}'." }, - Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4029, category: DiagnosticCategory.Error, key: "Public property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named." }, - Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4030, category: DiagnosticCategory.Error, key: "Public property '{0}' of exported class has or is using name '{1}' from private module '{2}'." }, - Public_property_0_of_exported_class_has_or_is_using_private_name_1: { code: 4031, category: DiagnosticCategory.Error, key: "Public property '{0}' of exported class has or is using private name '{1}'." }, - Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4032, category: DiagnosticCategory.Error, key: "Property '{0}' of exported interface has or is using name '{1}' from private module '{2}'." }, - Property_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4033, category: DiagnosticCategory.Error, key: "Property '{0}' of exported interface has or is using private name '{1}'." }, - Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4034, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static property setter from exported class has or is using name '{1}' from private module '{2}'." }, - Parameter_0_of_public_static_property_setter_from_exported_class_has_or_is_using_private_name_1: { code: 4035, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static property setter from exported class has or is using private name '{1}'." }, - Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4036, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public property setter from exported class has or is using name '{1}' from private module '{2}'." }, - Parameter_0_of_public_property_setter_from_exported_class_has_or_is_using_private_name_1: { code: 4037, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public property setter from exported class has or is using private name '{1}'." }, - Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4038, category: DiagnosticCategory.Error, key: "Return type of public static property getter from exported class has or is using name '{0}' from external module {1} but cannot be named." }, - Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4039, category: DiagnosticCategory.Error, key: "Return type of public static property getter from exported class has or is using name '{0}' from private module '{1}'." }, - Return_type_of_public_static_property_getter_from_exported_class_has_or_is_using_private_name_0: { code: 4040, category: DiagnosticCategory.Error, key: "Return type of public static property getter from exported class has or is using private name '{0}'." }, - Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4041, category: DiagnosticCategory.Error, key: "Return type of public property getter from exported class has or is using name '{0}' from external module {1} but cannot be named." }, - Return_type_of_public_property_getter_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4042, category: DiagnosticCategory.Error, key: "Return type of public property getter from exported class has or is using name '{0}' from private module '{1}'." }, - Return_type_of_public_property_getter_from_exported_class_has_or_is_using_private_name_0: { code: 4043, category: DiagnosticCategory.Error, key: "Return type of public property getter from exported class has or is using private name '{0}'." }, - Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4044, category: DiagnosticCategory.Error, key: "Return type of constructor signature from exported interface has or is using name '{0}' from private module '{1}'." }, - Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4045, category: DiagnosticCategory.Error, key: "Return type of constructor signature from exported interface has or is using private name '{0}'." }, - Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4046, category: DiagnosticCategory.Error, key: "Return type of call signature from exported interface has or is using name '{0}' from private module '{1}'." }, - Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4047, category: DiagnosticCategory.Error, key: "Return type of call signature from exported interface has or is using private name '{0}'." }, - Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4048, category: DiagnosticCategory.Error, key: "Return type of index signature from exported interface has or is using name '{0}' from private module '{1}'." }, - Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0: { code: 4049, category: DiagnosticCategory.Error, key: "Return type of index signature from exported interface has or is using private name '{0}'." }, - Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4050, category: DiagnosticCategory.Error, key: "Return type of public static method from exported class has or is using name '{0}' from external module {1} but cannot be named." }, - Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4051, category: DiagnosticCategory.Error, key: "Return type of public static method from exported class has or is using name '{0}' from private module '{1}'." }, - Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0: { code: 4052, category: DiagnosticCategory.Error, key: "Return type of public static method from exported class has or is using private name '{0}'." }, - Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4053, category: DiagnosticCategory.Error, key: "Return type of public method from exported class has or is using name '{0}' from external module {1} but cannot be named." }, - Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: { code: 4054, category: DiagnosticCategory.Error, key: "Return type of public method from exported class has or is using name '{0}' from private module '{1}'." }, - Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0: { code: 4055, category: DiagnosticCategory.Error, key: "Return type of public method from exported class has or is using private name '{0}'." }, - Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1: { code: 4056, category: DiagnosticCategory.Error, key: "Return type of method from exported interface has or is using name '{0}' from private module '{1}'." }, - Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0: { code: 4057, category: DiagnosticCategory.Error, key: "Return type of method from exported interface has or is using private name '{0}'." }, - Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: { code: 4058, category: DiagnosticCategory.Error, key: "Return type of exported function has or is using name '{0}' from external module {1} but cannot be named." }, - Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1: { code: 4059, category: DiagnosticCategory.Error, key: "Return type of exported function has or is using name '{0}' from private module '{1}'." }, - Return_type_of_exported_function_has_or_is_using_private_name_0: { code: 4060, category: DiagnosticCategory.Error, key: "Return type of exported function has or is using private name '{0}'." }, - Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4061, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor from exported class has or is using name '{1}' from external module {2} but cannot be named." }, - Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4062, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor from exported class has or is using name '{1}' from private module '{2}'." }, - Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1: { code: 4063, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor from exported class has or is using private name '{1}'." }, - Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4064, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'." }, - Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4065, category: DiagnosticCategory.Error, key: "Parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'." }, - Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4066, category: DiagnosticCategory.Error, key: "Parameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'." }, - Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: { code: 4067, category: DiagnosticCategory.Error, key: "Parameter '{0}' of call signature from exported interface has or is using private name '{1}'." }, - Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4068, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static method from exported class has or is using name '{1}' from external module {2} but cannot be named." }, - Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4069, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'." }, - Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: { code: 4070, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public static method from exported class has or is using private name '{1}'." }, - Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4071, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public method from exported class has or is using name '{1}' from external module {2} but cannot be named." }, - Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: { code: 4072, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'." }, - Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: { code: 4073, category: DiagnosticCategory.Error, key: "Parameter '{0}' of public method from exported class has or is using private name '{1}'." }, - Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2: { code: 4074, category: DiagnosticCategory.Error, key: "Parameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'." }, - Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: { code: 4075, category: DiagnosticCategory.Error, key: "Parameter '{0}' of method from exported interface has or is using private name '{1}'." }, - Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4076, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named." }, - Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: { code: 4077, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'." }, - Parameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 4078, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using private name '{1}'." }, - Exported_type_alias_0_has_or_is_using_private_name_1: { code: 4081, category: DiagnosticCategory.Error, key: "Exported type alias '{0}' has or is using private name '{1}'." }, - Default_export_of_the_module_has_or_is_using_private_name_0: { code: 4082, category: DiagnosticCategory.Error, key: "Default export of the module has or is using private name '{0}'." }, - Loop_contains_block_scoped_variable_0_referenced_by_a_function_in_the_loop_This_is_only_supported_in_ECMAScript_6_or_higher: { code: 4091, category: DiagnosticCategory.Error, key: "Loop contains block-scoped variable '{0}' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher." }, - The_current_host_does_not_support_the_0_option: { code: 5001, category: DiagnosticCategory.Error, key: "The current host does not support the '{0}' option." }, - Cannot_find_the_common_subdirectory_path_for_the_input_files: { code: 5009, category: DiagnosticCategory.Error, key: "Cannot find the common subdirectory path for the input files." }, - Cannot_read_file_0_Colon_1: { code: 5012, category: DiagnosticCategory.Error, key: "Cannot read file '{0}': {1}" }, - Unsupported_file_encoding: { code: 5013, category: DiagnosticCategory.Error, key: "Unsupported file encoding." }, - Failed_to_parse_file_0_Colon_1: { code: 5014, category: DiagnosticCategory.Error, key: "Failed to parse file '{0}': {1}." }, - Unknown_compiler_option_0: { code: 5023, category: DiagnosticCategory.Error, key: "Unknown compiler option '{0}'." }, - Compiler_option_0_requires_a_value_of_type_1: { code: 5024, category: DiagnosticCategory.Error, key: "Compiler option '{0}' requires a value of type {1}." }, - Could_not_write_file_0_Colon_1: { code: 5033, category: DiagnosticCategory.Error, key: "Could not write file '{0}': {1}" }, - Option_project_cannot_be_mixed_with_source_files_on_a_command_line: { code: 5042, category: DiagnosticCategory.Error, key: "Option 'project' cannot be mixed with source files on a command line." }, - Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES6_or_higher: { code: 5047, category: DiagnosticCategory.Error, key: "Option 'isolatedModules' can only be used when either option'--module' is provided or option 'target' is 'ES6' or higher." }, - Option_inlineSources_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided: { code: 5051, category: DiagnosticCategory.Error, key: "Option 'inlineSources' can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided." }, - Option_0_cannot_be_specified_without_specifying_option_1: { code: 5052, category: DiagnosticCategory.Error, key: "Option '{0}' cannot be specified without specifying option '{1}'." }, - Option_0_cannot_be_specified_with_option_1: { code: 5053, category: DiagnosticCategory.Error, key: "Option '{0}' cannot be specified with option '{1}'." }, - A_tsconfig_json_file_is_already_defined_at_Colon_0: { code: 5053, category: DiagnosticCategory.Error, key: "A 'tsconfig.json' file is already defined at: '{0}'." }, - Concatenate_and_emit_output_to_single_file: { code: 6001, category: DiagnosticCategory.Message, key: "Concatenate and emit output to single file." }, - Generates_corresponding_d_ts_file: { code: 6002, category: DiagnosticCategory.Message, key: "Generates corresponding '.d.ts' file." }, - Specifies_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: { code: 6003, category: DiagnosticCategory.Message, key: "Specifies the location where debugger should locate map files instead of generated locations." }, - Specifies_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: { code: 6004, category: DiagnosticCategory.Message, key: "Specifies the location where debugger should locate TypeScript files instead of source locations." }, - Watch_input_files: { code: 6005, category: DiagnosticCategory.Message, key: "Watch input files." }, - Redirect_output_structure_to_the_directory: { code: 6006, category: DiagnosticCategory.Message, key: "Redirect output structure to the directory." }, - Do_not_erase_const_enum_declarations_in_generated_code: { code: 6007, category: DiagnosticCategory.Message, key: "Do not erase const enum declarations in generated code." }, - Do_not_emit_outputs_if_any_errors_were_reported: { code: 6008, category: DiagnosticCategory.Message, key: "Do not emit outputs if any errors were reported." }, - Do_not_emit_comments_to_output: { code: 6009, category: DiagnosticCategory.Message, key: "Do not emit comments to output." }, - Do_not_emit_outputs: { code: 6010, category: DiagnosticCategory.Message, key: "Do not emit outputs." }, - Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES6_experimental: { code: 6015, category: DiagnosticCategory.Message, key: "Specify ECMAScript target version: 'ES3' (default), 'ES5', or 'ES6' (experimental)" }, - Specify_module_code_generation_Colon_commonjs_amd_system_or_umd: { code: 6016, category: DiagnosticCategory.Message, key: "Specify module code generation: 'commonjs', 'amd', 'system' or 'umd'" }, - Print_this_message: { code: 6017, category: DiagnosticCategory.Message, key: "Print this message." }, - Print_the_compiler_s_version: { code: 6019, category: DiagnosticCategory.Message, key: "Print the compiler's version." }, - Compile_the_project_in_the_given_directory: { code: 6020, category: DiagnosticCategory.Message, key: "Compile the project in the given directory." }, - Syntax_Colon_0: { code: 6023, category: DiagnosticCategory.Message, key: "Syntax: {0}" }, - options: { code: 6024, category: DiagnosticCategory.Message, key: "options" }, - file: { code: 6025, category: DiagnosticCategory.Message, key: "file" }, - Examples_Colon_0: { code: 6026, category: DiagnosticCategory.Message, key: "Examples: {0}" }, - Options_Colon: { code: 6027, category: DiagnosticCategory.Message, key: "Options:" }, - Version_0: { code: 6029, category: DiagnosticCategory.Message, key: "Version {0}" }, - Insert_command_line_options_and_files_from_a_file: { code: 6030, category: DiagnosticCategory.Message, key: "Insert command line options and files from a file." }, - File_change_detected_Starting_incremental_compilation: { code: 6032, category: DiagnosticCategory.Message, key: "File change detected. Starting incremental compilation..." }, - KIND: { code: 6034, category: DiagnosticCategory.Message, key: "KIND" }, - FILE: { code: 6035, category: DiagnosticCategory.Message, key: "FILE" }, - VERSION: { code: 6036, category: DiagnosticCategory.Message, key: "VERSION" }, - LOCATION: { code: 6037, category: DiagnosticCategory.Message, key: "LOCATION" }, - DIRECTORY: { code: 6038, category: DiagnosticCategory.Message, key: "DIRECTORY" }, - Compilation_complete_Watching_for_file_changes: { code: 6042, category: DiagnosticCategory.Message, key: "Compilation complete. Watching for file changes." }, - Generates_corresponding_map_file: { code: 6043, category: DiagnosticCategory.Message, key: "Generates corresponding '.map' file." }, - Compiler_option_0_expects_an_argument: { code: 6044, category: DiagnosticCategory.Error, key: "Compiler option '{0}' expects an argument." }, - Unterminated_quoted_string_in_response_file_0: { code: 6045, category: DiagnosticCategory.Error, key: "Unterminated quoted string in response file '{0}'." }, - Argument_for_module_option_must_be_commonjs_amd_system_or_umd: { code: 6046, category: DiagnosticCategory.Error, key: "Argument for '--module' option must be 'commonjs', 'amd', 'system' or 'umd'." }, - Argument_for_target_option_must_be_ES3_ES5_or_ES6: { code: 6047, category: DiagnosticCategory.Error, key: "Argument for '--target' option must be 'ES3', 'ES5', or 'ES6'." }, - Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: { code: 6048, category: DiagnosticCategory.Error, key: "Locale must be of the form or -. For example '{0}' or '{1}'." }, - Unsupported_locale_0: { code: 6049, category: DiagnosticCategory.Error, key: "Unsupported locale '{0}'." }, - Unable_to_open_file_0: { code: 6050, category: DiagnosticCategory.Error, key: "Unable to open file '{0}'." }, - Corrupted_locale_file_0: { code: 6051, category: DiagnosticCategory.Error, key: "Corrupted locale file {0}." }, - Raise_error_on_expressions_and_declarations_with_an_implied_any_type: { code: 6052, category: DiagnosticCategory.Message, key: "Raise error on expressions and declarations with an implied 'any' type." }, - File_0_not_found: { code: 6053, category: DiagnosticCategory.Error, key: "File '{0}' not found." }, - File_0_has_unsupported_extension_The_only_supported_extensions_are_1: { code: 6054, category: DiagnosticCategory.Error, key: "File '{0}' has unsupported extension. The only supported extensions are {1}." }, - Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: { code: 6055, category: DiagnosticCategory.Message, key: "Suppress noImplicitAny errors for indexing objects lacking index signatures." }, - Do_not_emit_declarations_for_code_that_has_an_internal_annotation: { code: 6056, category: DiagnosticCategory.Message, key: "Do not emit declarations for code that has an '@internal' annotation." }, - Specifies_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir: { code: 6058, category: DiagnosticCategory.Message, key: "Specifies the root directory of input files. Use to control the output directory structure with --outDir." }, - File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files: { code: 6059, category: DiagnosticCategory.Error, key: "File '{0}' is not under 'rootDir' '{1}'. 'rootDir' is expected to contain all source files." }, - Specifies_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: { code: 6060, category: DiagnosticCategory.Message, key: "Specifies the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)." }, - NEWLINE: { code: 6061, category: DiagnosticCategory.Message, key: "NEWLINE" }, - Argument_for_newLine_option_must_be_CRLF_or_LF: { code: 6062, category: DiagnosticCategory.Error, key: "Argument for '--newLine' option must be 'CRLF' or 'LF'." }, - Argument_for_moduleResolution_option_must_be_node_or_classic: { code: 6063, category: DiagnosticCategory.Error, key: "Argument for '--moduleResolution' option must be 'node' or 'classic'." }, - Specify_JSX_code_generation_Colon_preserve_or_react: { code: 6080, category: DiagnosticCategory.Message, key: "Specify JSX code generation: 'preserve' or 'react'" }, - Argument_for_jsx_must_be_preserve_or_react: { code: 6081, category: DiagnosticCategory.Message, key: "Argument for '--jsx' must be 'preserve' or 'react'." }, - Enables_experimental_support_for_ES7_decorators: { code: 6065, category: DiagnosticCategory.Message, key: "Enables experimental support for ES7 decorators." }, - Enables_experimental_support_for_emitting_type_metadata_for_decorators: { code: 6066, category: DiagnosticCategory.Message, key: "Enables experimental support for emitting type metadata for decorators." }, - Option_experimentalAsyncFunctions_cannot_be_specified_when_targeting_ES5_or_lower: { code: 6067, category: DiagnosticCategory.Message, key: "Option 'experimentalAsyncFunctions' cannot be specified when targeting ES5 or lower." }, - Enables_experimental_support_for_ES7_async_functions: { code: 6068, category: DiagnosticCategory.Message, key: "Enables experimental support for ES7 async functions." }, - Specifies_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6: { code: 6069, category: DiagnosticCategory.Message, key: "Specifies module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6)." }, - Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: { code: 6070, category: DiagnosticCategory.Message, key: "Initializes a TypeScript project and creates a tsconfig.json file." }, - Successfully_created_a_tsconfig_json_file: { code: 6071, category: DiagnosticCategory.Message, key: "Successfully created a tsconfig.json file." }, - Suppress_excess_property_checks_for_object_literals: { code: 6072, category: DiagnosticCategory.Message, key: "Suppress excess property checks for object literals." }, - Variable_0_implicitly_has_an_1_type: { code: 7005, category: DiagnosticCategory.Error, key: "Variable '{0}' implicitly has an '{1}' type." }, - Parameter_0_implicitly_has_an_1_type: { code: 7006, category: DiagnosticCategory.Error, key: "Parameter '{0}' implicitly has an '{1}' type." }, - Member_0_implicitly_has_an_1_type: { code: 7008, category: DiagnosticCategory.Error, key: "Member '{0}' implicitly has an '{1}' type." }, - new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type: { code: 7009, category: DiagnosticCategory.Error, key: "'new' expression, whose target lacks a construct signature, implicitly has an 'any' type." }, - _0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type: { code: 7010, category: DiagnosticCategory.Error, key: "'{0}', which lacks return-type annotation, implicitly has an '{1}' return type." }, - Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: { code: 7011, category: DiagnosticCategory.Error, key: "Function expression, which lacks return-type annotation, implicitly has an '{0}' return type." }, - Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: { code: 7013, category: DiagnosticCategory.Error, key: "Construct signature, which lacks return-type annotation, implicitly has an 'any' return type." }, - Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_type_annotation: { code: 7016, category: DiagnosticCategory.Error, key: "Property '{0}' implicitly has type 'any', because its 'set' accessor lacks a type annotation." }, - Index_signature_of_object_type_implicitly_has_an_any_type: { code: 7017, category: DiagnosticCategory.Error, key: "Index signature of object type implicitly has an 'any' type." }, - Object_literal_s_property_0_implicitly_has_an_1_type: { code: 7018, category: DiagnosticCategory.Error, key: "Object literal's property '{0}' implicitly has an '{1}' type." }, - Rest_parameter_0_implicitly_has_an_any_type: { code: 7019, category: DiagnosticCategory.Error, key: "Rest parameter '{0}' implicitly has an 'any[]' type." }, - Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: { code: 7020, category: DiagnosticCategory.Error, key: "Call signature, which lacks return-type annotation, implicitly has an 'any' return type." }, - _0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: { code: 7022, category: DiagnosticCategory.Error, key: "'{0}' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer." }, - _0_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: { code: 7023, category: DiagnosticCategory.Error, key: "'{0}' 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." }, - 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: { code: 7024, category: DiagnosticCategory.Error, key: "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." }, - Generator_implicitly_has_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type: { code: 7025, category: DiagnosticCategory.Error, key: "Generator implicitly has type '{0}' because it does not yield any values. Consider supplying a return type." }, - JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: { code: 7026, category: DiagnosticCategory.Error, key: "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists" }, - You_cannot_rename_this_element: { code: 8000, category: DiagnosticCategory.Error, key: "You cannot rename this element." }, - You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: { code: 8001, category: DiagnosticCategory.Error, key: "You cannot rename elements that are defined in the standard TypeScript library." }, - import_can_only_be_used_in_a_ts_file: { code: 8002, category: DiagnosticCategory.Error, key: "'import ... =' can only be used in a .ts file." }, - export_can_only_be_used_in_a_ts_file: { code: 8003, category: DiagnosticCategory.Error, key: "'export=' can only be used in a .ts file." }, - type_parameter_declarations_can_only_be_used_in_a_ts_file: { code: 8004, category: DiagnosticCategory.Error, key: "'type parameter declarations' can only be used in a .ts file." }, - implements_clauses_can_only_be_used_in_a_ts_file: { code: 8005, category: DiagnosticCategory.Error, key: "'implements clauses' can only be used in a .ts file." }, - interface_declarations_can_only_be_used_in_a_ts_file: { code: 8006, category: DiagnosticCategory.Error, key: "'interface declarations' can only be used in a .ts file." }, - module_declarations_can_only_be_used_in_a_ts_file: { code: 8007, category: DiagnosticCategory.Error, key: "'module declarations' can only be used in a .ts file." }, - type_aliases_can_only_be_used_in_a_ts_file: { code: 8008, category: DiagnosticCategory.Error, key: "'type aliases' can only be used in a .ts file." }, - _0_can_only_be_used_in_a_ts_file: { code: 8009, category: DiagnosticCategory.Error, key: "'{0}' can only be used in a .ts file." }, - types_can_only_be_used_in_a_ts_file: { code: 8010, category: DiagnosticCategory.Error, key: "'types' can only be used in a .ts file." }, - type_arguments_can_only_be_used_in_a_ts_file: { code: 8011, category: DiagnosticCategory.Error, key: "'type arguments' can only be used in a .ts file." }, - parameter_modifiers_can_only_be_used_in_a_ts_file: { code: 8012, category: DiagnosticCategory.Error, key: "'parameter modifiers' can only be used in a .ts file." }, - property_declarations_can_only_be_used_in_a_ts_file: { code: 8014, category: DiagnosticCategory.Error, key: "'property declarations' can only be used in a .ts file." }, - enum_declarations_can_only_be_used_in_a_ts_file: { code: 8015, category: DiagnosticCategory.Error, key: "'enum declarations' can only be used in a .ts file." }, - type_assertion_expressions_can_only_be_used_in_a_ts_file: { code: 8016, category: DiagnosticCategory.Error, key: "'type assertion expressions' can only be used in a .ts file." }, - decorators_can_only_be_used_in_a_ts_file: { code: 8017, category: DiagnosticCategory.Error, key: "'decorators' can only be used in a .ts file." }, - Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses: { code: 9002, category: DiagnosticCategory.Error, key: "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses." }, - class_expressions_are_not_currently_supported: { code: 9003, category: DiagnosticCategory.Error, key: "'class' expressions are not currently supported." }, - JSX_attributes_must_only_be_assigned_a_non_empty_expression: { code: 17000, category: DiagnosticCategory.Error, key: "JSX attributes must only be assigned a non-empty 'expression'." }, - JSX_elements_cannot_have_multiple_attributes_with_the_same_name: { code: 17001, category: DiagnosticCategory.Error, key: "JSX elements cannot have multiple attributes with the same name." }, - Expected_corresponding_JSX_closing_tag_for_0: { code: 17002, category: DiagnosticCategory.Error, key: "Expected corresponding JSX closing tag for '{0}'." }, - JSX_attribute_expected: { code: 17003, category: DiagnosticCategory.Error, key: "JSX attribute expected." }, - Cannot_use_JSX_unless_the_jsx_flag_is_provided: { code: 17004, category: DiagnosticCategory.Error, key: "Cannot use JSX unless the '--jsx' flag is provided." }, - A_constructor_cannot_contain_a_super_call_when_its_class_extends_null: { code: 17005, category: DiagnosticCategory.Error, key: "A constructor cannot contain a 'super' call when its class extends 'null'" }, - }; -} \ No newline at end of file diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index c1657a81bab..b391545a733 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -195,7 +195,7 @@ "category": "Error", "code": 1063 }, - "Ambient enum elements can only have integer literal initializers.": { + "In ambient enum declarations member initializer must be constant expression.": { "category": "Error", "code": 1066 }, @@ -549,7 +549,7 @@ }, "An implementation cannot be declared in ambient contexts.": { "category": "Error", - "code": 1184 + "code": 1183 }, "Modifiers cannot appear here.": { "category": "Error", @@ -619,22 +619,18 @@ "category": "Error", "code": 1200 }, - "Import assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"' or 'import d from \"mod\"' instead.": { + "Import assignment cannot be used when targeting ECMAScript 6 modules. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"', 'import d from \"mod\"', or another module format instead.": { "category": "Error", "code": 1202 }, - "Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead.": { + "Export assignment cannot be used when targeting ECMAScript 6 modules. Consider using 'export default' or another module format instead.": { "category": "Error", "code": 1203 }, - "Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher.": { + "Cannot compile modules into 'es6' when targeting 'ES5' or lower.": { "category": "Error", "code": 1204 }, - "Decorators are only available when targeting ECMAScript 5 and higher.": { - "category": "Error", - "code": 1205 - }, "Decorators are not valid here.": { "category": "Error", "code": 1206 @@ -747,24 +743,6 @@ "category": "Error", "code": 1235 }, - "Experimental support for async functions is a feature that is subject to change in a future release. Specify '--experimentalAsyncFunctions' to remove this warning.": { - "category": "Error", - "code": 1236 - }, - - - "'with' statements are not allowed in an async function block.": { - "category": "Error", - "code": 1300 - }, - "'await' expression is only allowed within an async function.": { - "category": "Error", - "code": 1308 - }, - "Async functions are only available when targeting ECMAScript 6 and higher.": { - "category": "Error", - "code": 1311 - }, "The return type of a property decorator function must be either 'void' or 'any'.": { "category": "Error", "code": 1236 @@ -805,6 +783,27 @@ "category": "Error", "code": 1245 }, + "Experimental support for async functions is a feature that is subject to change in a future release. Specify '--experimentalAsyncFunctions' to remove this warning.": { + "category": "Error", + "code": 1246 + }, + + "'with' statements are not allowed in an async function block.": { + "category": "Error", + "code": 1300 + }, + "'await' expression is only allowed within an async function.": { + "category": "Error", + "code": 1308 + }, + "Async functions are only available when targeting ECMAScript 6 and higher.": { + "category": "Error", + "code": 1311 + }, + "'=' can only be used in an object literal property inside a destructuring assignment.": { + "category": "Error", + "code": 1312 + }, "Duplicate identifier '{0}'.": { "category": "Error", "code": 2300 @@ -1301,7 +1300,7 @@ "category": "Error", "code": 2434 }, - "Ambient modules cannot be nested in other modules.": { + "Ambient modules cannot be nested in other modules or namespaces.": { "category": "Error", "code": 2435 }, @@ -1653,6 +1652,18 @@ "category": "Error", "code": 2525 }, + "A 'this' type is available only in a non-static member of a class or interface.": { + "category": "Error", + "code": 2526 + }, + "The inferred type of '{0}' references an inaccessible 'this' type. A type annotation is necessary.": { + "category": "Error", + "code": 2527 + }, + "A module cannot have multiple default exports.": { + "category": "Error", + "code": 2528 + }, "JSX element attributes type '{0}' must be an object type.": { "category": "Error", "code": 2600 @@ -1700,11 +1711,11 @@ "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead.": { "category": "Error", "code": 2652 - }, + }, "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'.": { "category": "Error", "code": 2653 - }, + }, "Exported external package typings file cannot contain tripleslash references. Please contact the package author to update the package definition.": { "category": "Error", "code": 2654 @@ -1712,11 +1723,11 @@ "Exported external package typings can only be in '.d.ts' files. Please contact the package author to update the package definition.": { "category": "Error", "code": 2655 - }, + }, "Exported external package typings file '{0}' is not a module. Please contact the package author to update the package definition.": { "category": "Error", "code": 2656 - }, + }, "Import declaration '{0}' is using private name '{1}'.": { "category": "Error", "code": 4000 @@ -2055,7 +2066,7 @@ }, "A 'tsconfig.json' file is already defined at: '{0}'.": { "category": "Error", - "code": 5053 + "code": 5054 }, "Concatenate and emit output to single file.": { @@ -2102,7 +2113,7 @@ "category": "Message", "code": 6015 }, - "Specify module code generation: 'commonjs', 'amd', 'system' or 'umd'": { + "Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es6'": { "category": "Message", "code": 6016 }, @@ -2186,7 +2197,7 @@ "category": "Error", "code": 6045 }, - "Argument for '--module' option must be 'commonjs', 'amd', 'system' or 'umd'.": { + "Argument for '--module' option must be 'commonjs', 'amd', 'system', 'umd', or 'es6'.": { "category": "Error", "code": 6046 }, diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index bd16b13bb09..fb3aaf54717 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -7,6 +7,264 @@ namespace ts { return isExternalModule(sourceFile) || isDeclarationFile(sourceFile); } + type DependencyGroup = Array; + + let entities: Map = { + "quot": 0x0022, + "amp": 0x0026, + "apos": 0x0027, + "lt": 0x003C, + "gt": 0x003E, + "nbsp": 0x00A0, + "iexcl": 0x00A1, + "cent": 0x00A2, + "pound": 0x00A3, + "curren": 0x00A4, + "yen": 0x00A5, + "brvbar": 0x00A6, + "sect": 0x00A7, + "uml": 0x00A8, + "copy": 0x00A9, + "ordf": 0x00AA, + "laquo": 0x00AB, + "not": 0x00AC, + "shy": 0x00AD, + "reg": 0x00AE, + "macr": 0x00AF, + "deg": 0x00B0, + "plusmn": 0x00B1, + "sup2": 0x00B2, + "sup3": 0x00B3, + "acute": 0x00B4, + "micro": 0x00B5, + "para": 0x00B6, + "middot": 0x00B7, + "cedil": 0x00B8, + "sup1": 0x00B9, + "ordm": 0x00BA, + "raquo": 0x00BB, + "frac14": 0x00BC, + "frac12": 0x00BD, + "frac34": 0x00BE, + "iquest": 0x00BF, + "Agrave": 0x00C0, + "Aacute": 0x00C1, + "Acirc": 0x00C2, + "Atilde": 0x00C3, + "Auml": 0x00C4, + "Aring": 0x00C5, + "AElig": 0x00C6, + "Ccedil": 0x00C7, + "Egrave": 0x00C8, + "Eacute": 0x00C9, + "Ecirc": 0x00CA, + "Euml": 0x00CB, + "Igrave": 0x00CC, + "Iacute": 0x00CD, + "Icirc": 0x00CE, + "Iuml": 0x00CF, + "ETH": 0x00D0, + "Ntilde": 0x00D1, + "Ograve": 0x00D2, + "Oacute": 0x00D3, + "Ocirc": 0x00D4, + "Otilde": 0x00D5, + "Ouml": 0x00D6, + "times": 0x00D7, + "Oslash": 0x00D8, + "Ugrave": 0x00D9, + "Uacute": 0x00DA, + "Ucirc": 0x00DB, + "Uuml": 0x00DC, + "Yacute": 0x00DD, + "THORN": 0x00DE, + "szlig": 0x00DF, + "agrave": 0x00E0, + "aacute": 0x00E1, + "acirc": 0x00E2, + "atilde": 0x00E3, + "auml": 0x00E4, + "aring": 0x00E5, + "aelig": 0x00E6, + "ccedil": 0x00E7, + "egrave": 0x00E8, + "eacute": 0x00E9, + "ecirc": 0x00EA, + "euml": 0x00EB, + "igrave": 0x00EC, + "iacute": 0x00ED, + "icirc": 0x00EE, + "iuml": 0x00EF, + "eth": 0x00F0, + "ntilde": 0x00F1, + "ograve": 0x00F2, + "oacute": 0x00F3, + "ocirc": 0x00F4, + "otilde": 0x00F5, + "ouml": 0x00F6, + "divide": 0x00F7, + "oslash": 0x00F8, + "ugrave": 0x00F9, + "uacute": 0x00FA, + "ucirc": 0x00FB, + "uuml": 0x00FC, + "yacute": 0x00FD, + "thorn": 0x00FE, + "yuml": 0x00FF, + "OElig": 0x0152, + "oelig": 0x0153, + "Scaron": 0x0160, + "scaron": 0x0161, + "Yuml": 0x0178, + "fnof": 0x0192, + "circ": 0x02C6, + "tilde": 0x02DC, + "Alpha": 0x0391, + "Beta": 0x0392, + "Gamma": 0x0393, + "Delta": 0x0394, + "Epsilon": 0x0395, + "Zeta": 0x0396, + "Eta": 0x0397, + "Theta": 0x0398, + "Iota": 0x0399, + "Kappa": 0x039A, + "Lambda": 0x039B, + "Mu": 0x039C, + "Nu": 0x039D, + "Xi": 0x039E, + "Omicron": 0x039F, + "Pi": 0x03A0, + "Rho": 0x03A1, + "Sigma": 0x03A3, + "Tau": 0x03A4, + "Upsilon": 0x03A5, + "Phi": 0x03A6, + "Chi": 0x03A7, + "Psi": 0x03A8, + "Omega": 0x03A9, + "alpha": 0x03B1, + "beta": 0x03B2, + "gamma": 0x03B3, + "delta": 0x03B4, + "epsilon": 0x03B5, + "zeta": 0x03B6, + "eta": 0x03B7, + "theta": 0x03B8, + "iota": 0x03B9, + "kappa": 0x03BA, + "lambda": 0x03BB, + "mu": 0x03BC, + "nu": 0x03BD, + "xi": 0x03BE, + "omicron": 0x03BF, + "pi": 0x03C0, + "rho": 0x03C1, + "sigmaf": 0x03C2, + "sigma": 0x03C3, + "tau": 0x03C4, + "upsilon": 0x03C5, + "phi": 0x03C6, + "chi": 0x03C7, + "psi": 0x03C8, + "omega": 0x03C9, + "thetasym": 0x03D1, + "upsih": 0x03D2, + "piv": 0x03D6, + "ensp": 0x2002, + "emsp": 0x2003, + "thinsp": 0x2009, + "zwnj": 0x200C, + "zwj": 0x200D, + "lrm": 0x200E, + "rlm": 0x200F, + "ndash": 0x2013, + "mdash": 0x2014, + "lsquo": 0x2018, + "rsquo": 0x2019, + "sbquo": 0x201A, + "ldquo": 0x201C, + "rdquo": 0x201D, + "bdquo": 0x201E, + "dagger": 0x2020, + "Dagger": 0x2021, + "bull": 0x2022, + "hellip": 0x2026, + "permil": 0x2030, + "prime": 0x2032, + "Prime": 0x2033, + "lsaquo": 0x2039, + "rsaquo": 0x203A, + "oline": 0x203E, + "frasl": 0x2044, + "euro": 0x20AC, + "image": 0x2111, + "weierp": 0x2118, + "real": 0x211C, + "trade": 0x2122, + "alefsym": 0x2135, + "larr": 0x2190, + "uarr": 0x2191, + "rarr": 0x2192, + "darr": 0x2193, + "harr": 0x2194, + "crarr": 0x21B5, + "lArr": 0x21D0, + "uArr": 0x21D1, + "rArr": 0x21D2, + "dArr": 0x21D3, + "hArr": 0x21D4, + "forall": 0x2200, + "part": 0x2202, + "exist": 0x2203, + "empty": 0x2205, + "nabla": 0x2207, + "isin": 0x2208, + "notin": 0x2209, + "ni": 0x220B, + "prod": 0x220F, + "sum": 0x2211, + "minus": 0x2212, + "lowast": 0x2217, + "radic": 0x221A, + "prop": 0x221D, + "infin": 0x221E, + "ang": 0x2220, + "and": 0x2227, + "or": 0x2228, + "cap": 0x2229, + "cup": 0x222A, + "int": 0x222B, + "there4": 0x2234, + "sim": 0x223C, + "cong": 0x2245, + "asymp": 0x2248, + "ne": 0x2260, + "equiv": 0x2261, + "le": 0x2264, + "ge": 0x2265, + "sub": 0x2282, + "sup": 0x2283, + "nsub": 0x2284, + "sube": 0x2286, + "supe": 0x2287, + "oplus": 0x2295, + "otimes": 0x2297, + "perp": 0x22A5, + "sdot": 0x22C5, + "lceil": 0x2308, + "rceil": 0x2309, + "lfloor": 0x230A, + "rfloor": 0x230B, + "lang": 0x2329, + "rang": 0x232A, + "loz": 0x25CA, + "spades": 0x2660, + "clubs": 0x2663, + "hearts": 0x2665, + "diams": 0x2666 + }; + // Flags enum to track count of temp variables and a few dedicated names const enum TempFlags { Auto = 0x00000000, // No preferred name @@ -27,12 +285,10 @@ var __extends = (this && this.__extends) || function (d, b) { // emit output for the __decorate helper function const decorateHelper = ` var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; };`; // emit output for the __metadata helper function @@ -64,6 +320,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi let compilerOptions = host.getCompilerOptions(); let languageVersion = compilerOptions.target || ScriptTarget.ES3; + let modulekind = compilerOptions.module ? compilerOptions.module : languageVersion === ScriptTarget.ES6 ? ModuleKind.ES6 : ModuleKind.None; let sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined; let diagnostics: Diagnostic[] = []; let newLine = host.getNewLine(); @@ -189,6 +446,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi /** If removeComments is true, no leading-comments needed to be emitted **/ let emitLeadingCommentsOfPosition = compilerOptions.removeComments ? function (pos: number) { } : emitLeadingCommentsOfPositionWorker; + let moduleEmitDelegates: Map<(node: SourceFile) => void> = { + [ModuleKind.ES6]: emitES6Module, + [ModuleKind.AMD]: emitAMDModule, + [ModuleKind.System]: emitSystemModule, + [ModuleKind.UMD]: emitUMDModule, + [ModuleKind.CommonJS]: emitCommonJSModule, + }; + if (compilerOptions.sourceMap || compilerOptions.inlineSourceMap) { initializeEmitterWithSourceMaps(); } @@ -686,7 +951,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } } } - + function emitNodeWithCommentsAndWithSourcemap(node: Node) { emitNodeConsideringCommentsOption(node, emitNodeWithSourceMap); } @@ -1181,7 +1446,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi function emitJsxElement(openingNode: JsxOpeningLikeElement, children?: JsxChild[]) { let syntheticReactRef = createSynthesizedNode(SyntaxKind.Identifier); - syntheticReactRef.text = 'React'; + syntheticReactRef.text = "React"; syntheticReactRef.parent = openingNode; // Call React.createElement(tag, ... @@ -1385,7 +1650,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi // // The emit for the decorated computed property decorator is: // - // Object.defineProperty(C.prototype, _a, __decorate([dec], C.prototype, _a, Object.getOwnPropertyDescriptor(C.prototype, _a))); + // __decorate([dec], C.prototype, _a, Object.getOwnPropertyDescriptor(C.prototype, _a)); // if (nodeIsDecorated(node.parent)) { if (!computedPropertyNamesToGeneratedNames) { @@ -1425,6 +1690,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi let parent = node.parent; switch (parent.kind) { case SyntaxKind.ArrayLiteralExpression: + case SyntaxKind.AsExpression: case SyntaxKind.BinaryExpression: case SyntaxKind.CallExpression: case SyntaxKind.CaseClause: @@ -1493,7 +1759,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi if (container) { if (container.kind === SyntaxKind.SourceFile) { // Identifier references module export - if (languageVersion < ScriptTarget.ES6 && compilerOptions.module !== ModuleKind.System) { + if (modulekind !== ModuleKind.ES6 && modulekind !== ModuleKind.System) { write("exports."); } } @@ -1503,7 +1769,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write("."); } } - else if (languageVersion < ScriptTarget.ES6) { + else if (modulekind !== ModuleKind.ES6) { let declaration = resolver.getReferencedImportDeclaration(node); if (declaration) { if (declaration.kind === SyntaxKind.ImportClause) { @@ -1515,8 +1781,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi else if (declaration.kind === SyntaxKind.ImportSpecifier) { // Identifier references named import write(getGeneratedNameForNode(declaration.parent.parent.parent)); - var name = (declaration).propertyName || (declaration).name; - var identifier = getSourceTextOfNodeFromSourceFile(currentSourceFile, name); + let name = (declaration).propertyName || (declaration).name; + let identifier = getSourceTextOfNodeFromSourceFile(currentSourceFile, name); if (languageVersion === ScriptTarget.ES3 && identifier === "default") { write(`["default"]`); } @@ -2045,6 +2311,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write(": "); emit(node.name); } + + if (languageVersion >= ScriptTarget.ES6 && node.objectAssignmentInitializer) { + write(" = "); + emit(node.objectAssignmentInitializer); + } } function tryEmitConstantValue(node: PropertyAccessExpression | ElementAccessExpression): boolean { @@ -2059,15 +2330,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } return false; } - + function tryGetConstEnumValue(node: Node): number { if (compilerOptions.isolatedModules) { return undefined; } - - return node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.ElementAccessExpression + + return node.kind === SyntaxKind.PropertyAccessExpression || node.kind === SyntaxKind.ElementAccessExpression ? resolver.getConstantValue(node) - : undefined + : undefined; } // Returns 'true' if the code was actually indented, false otherwise. @@ -3056,7 +3327,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write(getGeneratedNameForNode(container)); write("."); } - else if (languageVersion < ScriptTarget.ES6 && compilerOptions.module !== ModuleKind.System) { + else if (modulekind !== ModuleKind.ES6 && modulekind !== ModuleKind.System) { write("exports."); } } @@ -3076,7 +3347,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi if (node.parent.kind === SyntaxKind.SourceFile) { Debug.assert(!!(node.flags & NodeFlags.Default) || node.kind === SyntaxKind.ExportAssignment); // only allow export default at a source file level - if (compilerOptions.module === ModuleKind.CommonJS || compilerOptions.module === ModuleKind.AMD || compilerOptions.module === ModuleKind.UMD) { + if (modulekind === ModuleKind.CommonJS || modulekind === ModuleKind.AMD || modulekind === ModuleKind.UMD) { if (!currentSourceFile.symbol.exports["___esModule"]) { if (languageVersion === ScriptTarget.ES5) { // default value of configurable, enumerable, writable are `false`. @@ -3098,7 +3369,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitStart(node); // emit call to exporter only for top level nodes - if (compilerOptions.module === ModuleKind.System && node.parent === currentSourceFile) { + if (modulekind === ModuleKind.System && node.parent === currentSourceFile) { // emit export default as // export("default", ) write(`${exportFunctionForFile}("`); @@ -3134,10 +3405,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } function emitExportMemberAssignments(name: Identifier) { - if (compilerOptions.module === ModuleKind.System) { + if (modulekind === ModuleKind.System) { return; } - + if (!exportEquals && exportSpecifiers && hasProperty(exportSpecifiers, name.text)) { for (let specifier of exportSpecifiers[name.text]) { writeLine(); @@ -3152,14 +3423,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } } } - + function emitExportSpecifierInSystemModule(specifier: ExportSpecifier): void { - Debug.assert(compilerOptions.module === ModuleKind.System); + Debug.assert(modulekind === ModuleKind.System); if (!resolver.getReferencedValueDeclaration(specifier.propertyName || specifier.name) && !resolver.isValueAliasDeclaration(specifier) ) { return; } - + writeLine(); emitStart(specifier.name); write(`${exportFunctionForFile}("`); @@ -3308,7 +3579,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi for (let p of properties) { if (p.kind === SyntaxKind.PropertyAssignment || p.kind === SyntaxKind.ShorthandPropertyAssignment) { let propName = (p).name; - emitDestructuringAssignment((p).initializer || propName, createPropertyAccessForDestructuringProperty(value, propName)); + let target = p.kind === SyntaxKind.ShorthandPropertyAssignment ? p : (p).initializer || propName; + emitDestructuringAssignment(target, createPropertyAccessForDestructuringProperty(value, propName)); } } } @@ -3333,8 +3605,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } } - function emitDestructuringAssignment(target: Expression, value: Expression) { - if (target.kind === SyntaxKind.BinaryExpression && (target).operatorToken.kind === SyntaxKind.EqualsToken) { + function emitDestructuringAssignment(target: Expression | ShorthandPropertyAssignment, value: Expression) { + if (target.kind === SyntaxKind.ShorthandPropertyAssignment) { + if ((target).objectAssignmentInitializer) { + value = createDefaultValueCheck(value, (target).objectAssignmentInitializer); + } + target = (target).name; + } + else if (target.kind === SyntaxKind.BinaryExpression && (target).operatorToken.kind === SyntaxKind.EqualsToken) { value = createDefaultValueCheck(value, (target).right); target = (target).left; } @@ -3491,7 +3769,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi function isES6ExportedDeclaration(node: Node) { return !!(node.flags & NodeFlags.Export) && - languageVersion >= ScriptTarget.ES6 && + modulekind === ModuleKind.ES6 && node.parent.kind === SyntaxKind.SourceFile; } @@ -3519,7 +3797,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write(";"); } } - if (languageVersion < ScriptTarget.ES6 && node.parent === currentSourceFile) { + if (modulekind !== ModuleKind.ES6 && node.parent === currentSourceFile) { forEach(node.declarationList.declarations, emitExportVariableAssignments); } } @@ -3745,7 +4023,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } emitSignatureAndBody(node); - if (languageVersion < ScriptTarget.ES6 && node.kind === SyntaxKind.FunctionDeclaration && node.parent === currentSourceFile && node.name) { + if (modulekind !== ModuleKind.ES6 && node.kind === SyntaxKind.FunctionDeclaration && node.parent === currentSourceFile && node.name) { emitExportMemberAssignments((node).name); } @@ -4421,6 +4699,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi else { emitClassLikeDeclarationForES6AndHigher(node); } + if (modulekind !== ModuleKind.ES6 && node.parent === currentSourceFile && node.name) { + emitExportMemberAssignments(node.name); + } } function emitClassLikeDeclarationForES6AndHigher(node: ClassLikeDeclaration) { @@ -4439,7 +4720,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi // // let C = class { // }; - // Object.defineProperty(C, "name", { value: "C", configurable: true }); // C = __decorate([dec], C); // // * For an exported class declaration: @@ -4451,7 +4731,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi // // export let C = class { // }; - // Object.defineProperty(C, "name", { value: "C", configurable: true }); // C = __decorate([dec], C); // // * For a default export of a class declaration with a name: @@ -4463,7 +4742,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi // // let C = class { // } - // Object.defineProperty(C, "name", { value: "C", configurable: true }); // C = __decorate([dec], C); // export default C; // @@ -4520,8 +4798,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write("class"); - // check if this is an "export default class" as it may not have a name. Do not emit the name if the class is decorated. - if ((node.name || !(node.flags & NodeFlags.Default)) && !thisNodeIsDecorated) { + // emit name if + // - node has a name + // - this is default export with static initializers + if ((node.name || (node.flags & NodeFlags.Default && staticProperties.length > 0)) && !thisNodeIsDecorated) { write(" "); emitDeclarationName(node); } @@ -4669,10 +4949,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi if (node.kind === SyntaxKind.ClassDeclaration) { emitExportMemberAssignment(node); } - - if (languageVersion < ScriptTarget.ES6 && node.parent === currentSourceFile && node.name) { - emitExportMemberAssignments(node.name); - } } function emitClassMemberPrefix(node: ClassLikeDeclaration, member: Node) { @@ -4789,21 +5065,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi // // The emit for a method is: // - // Object.defineProperty(C.prototype, "method", - // __decorate([ - // dec, - // __param(0, dec2), - // __metadata("design:type", Function), - // __metadata("design:paramtypes", [Object]), - // __metadata("design:returntype", void 0) - // ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method"))); + // __decorate([ + // dec, + // __param(0, dec2), + // __metadata("design:type", Function), + // __metadata("design:paramtypes", [Object]), + // __metadata("design:returntype", void 0) + // ], C.prototype, "method", undefined); // // The emit for an accessor is: // - // Object.defineProperty(C.prototype, "accessor", - // __decorate([ - // dec - // ], C.prototype, "accessor", Object.getOwnPropertyDescriptor(C.prototype, "accessor"))); + // __decorate([ + // dec + // ], C.prototype, "accessor", undefined); // // The emit for a property is: // @@ -4814,18 +5088,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi writeLine(); emitStart(member); - if (member.kind !== SyntaxKind.PropertyDeclaration) { - write("Object.defineProperty("); - emitStart(member.name); - emitClassMemberPrefix(node, member); - write(", "); - emitExpressionForPropertyName(member.name); - emitEnd(member.name); - write(","); - increaseIndent(); - writeLine(); - } - write("__decorate(["); increaseIndent(); writeLine(); @@ -4849,15 +5111,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitExpressionForPropertyName(member.name); emitEnd(member.name); - if (member.kind !== SyntaxKind.PropertyDeclaration) { - write(", Object.getOwnPropertyDescriptor("); - emitStart(member.name); - emitClassMemberPrefix(node, member); - write(", "); - emitExpressionForPropertyName(member.name); - emitEnd(member.name); - write("))"); - decreaseIndent(); + if (languageVersion > ScriptTarget.ES3) { + if (member.kind !== SyntaxKind.PropertyDeclaration) { + // We emit `null` here to indicate to `__decorate` that it can invoke `Object.getOwnPropertyDescriptor` directly. + // We have this extra argument here so that we can inject an explicit property descriptor at a later date. + write(", null"); + } + else { + // We emit `void 0` here to indicate to `__decorate` that it can invoke `Object.defineProperty` directly, but that it + // should not invoke `Object.getOwnPropertyDescriptor`. + write(", void 0"); + } } write(");"); @@ -5256,8 +5520,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitEnd(node); write(";"); } - if (languageVersion < ScriptTarget.ES6 && node.parent === currentSourceFile) { - if (compilerOptions.module === ModuleKind.System && (node.flags & NodeFlags.Export)) { + if (modulekind !== ModuleKind.ES6 && node.parent === currentSourceFile) { + if (modulekind === ModuleKind.System && (node.flags & NodeFlags.Export)) { // write the call to exporter for enum writeLine(); write(`${exportFunctionForFile}("`); @@ -5379,7 +5643,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write(" = {}));"); emitEnd(node); if (!isES6ExportedDeclaration(node) && node.name.kind === SyntaxKind.Identifier && node.parent === currentSourceFile) { - if (compilerOptions.module === ModuleKind.System && (node.flags & NodeFlags.Export)) { + if (modulekind === ModuleKind.System && (node.flags & NodeFlags.Export)) { writeLine(); write(`${exportFunctionForFile}("`); emitDeclarationName(node); @@ -5390,14 +5654,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitExportMemberAssignments(node.name); } } - + /* - * Some bundlers (SystemJS builder) sometimes want to rename dependencies. - * Here we check if alternative name was provided for a given moduleName and return it if possible. + * Some bundlers (SystemJS builder) sometimes want to rename dependencies. + * Here we check if alternative name was provided for a given moduleName and return it if possible. */ function tryRenameExternalModule(moduleName: LiteralExpression): string { if (currentSourceFile.renamedDependencies && hasProperty(currentSourceFile.renamedDependencies, moduleName.text)) { - return `"${currentSourceFile.renamedDependencies[moduleName.text]}"` + return `"${currentSourceFile.renamedDependencies[moduleName.text]}"`; } return undefined; } @@ -5443,7 +5707,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } function emitImportDeclaration(node: ImportDeclaration) { - if (languageVersion < ScriptTarget.ES6) { + if (modulekind !== ModuleKind.ES6) { return emitExternalImportDeclaration(node); } @@ -5494,7 +5758,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi let isExportedImport = node.kind === SyntaxKind.ImportEqualsDeclaration && (node.flags & NodeFlags.Export) !== 0; let namespaceDeclaration = getNamespaceDeclarationNode(node); - if (compilerOptions.module !== ModuleKind.AMD) { + if (modulekind !== ModuleKind.AMD) { emitLeadingComments(node); emitStart(node); if (namespaceDeclaration && !isDefaultImport(node)) { @@ -5606,15 +5870,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } function emitExportDeclaration(node: ExportDeclaration) { - Debug.assert(compilerOptions.module !== ModuleKind.System); + Debug.assert(modulekind !== ModuleKind.System); - if (languageVersion < ScriptTarget.ES6) { + if (modulekind !== ModuleKind.ES6) { if (node.moduleSpecifier && (!node.exportClause || resolver.isValueAliasDeclaration(node))) { emitStart(node); let generatedName = getGeneratedNameForNode(node); if (node.exportClause) { // export { x, y, ... } from "foo" - if (compilerOptions.module !== ModuleKind.AMD) { + if (modulekind !== ModuleKind.AMD) { write("var "); write(generatedName); write(" = "); @@ -5641,7 +5905,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi // export * from "foo" writeLine(); write("__export("); - if (compilerOptions.module !== ModuleKind.AMD) { + if (modulekind !== ModuleKind.AMD) { emitRequire(getExternalModuleName(node)); } else { @@ -5674,7 +5938,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } function emitExportOrImportSpecifierList(specifiers: ImportOrExportSpecifier[], shouldEmit: (node: Node) => boolean) { - Debug.assert(languageVersion >= ScriptTarget.ES6); + Debug.assert(modulekind === ModuleKind.ES6); let needsComma = false; for (let specifier of specifiers) { @@ -5694,7 +5958,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi function emitExportAssignment(node: ExportAssignment) { if (!node.isExportEquals && resolver.isValueAliasDeclaration(node)) { - if (languageVersion >= ScriptTarget.ES6) { + if (modulekind === ModuleKind.ES6) { writeLine(); emitStart(node); write("export default "); @@ -5709,7 +5973,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi else { writeLine(); emitStart(node); - if (compilerOptions.module === ModuleKind.System) { + if (modulekind === ModuleKind.System) { write(`${exportFunctionForFile}("default",`); emit(node.expression); write(")"); @@ -5719,7 +5983,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitContainingModuleName(node); if (languageVersion === ScriptTarget.ES3) { write("[\"default\"] = "); - } else { + } + else { write(".default = "); } emit(node.expression); @@ -5812,7 +6077,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi function getExternalModuleNameText(importNode: ImportDeclaration | ExportDeclaration | ImportEqualsDeclaration): string { let moduleName = getExternalModuleName(importNode); if (moduleName.kind === SyntaxKind.StringLiteral) { - return tryRenameExternalModule(moduleName) || getLiteralText(moduleName); + return tryRenameExternalModule(moduleName) || getLiteralText(moduleName); } return undefined; @@ -6155,7 +6420,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } function isCurrentFileSystemExternalModule() { - return compilerOptions.module === ModuleKind.System && isExternalModule(currentSourceFile); + return modulekind === ModuleKind.System && isExternalModule(currentSourceFile); } function emitSystemModuleBody(node: SourceFile, dependencyGroups: DependencyGroup[], startIndex: number): void { @@ -6214,7 +6479,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi function emitSetters(exportStarFunction: string, dependencyGroups: DependencyGroup[]) { write("setters:["); - + for (let i = 0; i < dependencyGroups.length; ++i) { if (i !== 0) { write(","); @@ -6222,17 +6487,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi writeLine(); increaseIndent(); - + let group = dependencyGroups[i]; - + // derive a unique name for parameter from the first named entry in the group let parameterName = makeUniqueName(forEach(group, getLocalNameForExternalImport) || ""); write(`function (${parameterName}) {`); increaseIndent(); - - for(let entry of group) { + + for (let entry of group) { let importVariableName = getLocalNameForExternalImport(entry) || ""; - + switch (entry.kind) { case SyntaxKind.ImportDeclaration: if (!(entry).importClause) { @@ -6268,7 +6533,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write(","); writeLine(); } - + let e = (entry).exportClause.elements[i]; write(`"`); emitNodeWithCommentsAndWithoutSourcemap(e.name); @@ -6278,7 +6543,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } decreaseIndent(); writeLine(); - write("});") + write("});"); } else { writeLine(); @@ -6313,7 +6578,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi // - import declarations are not emitted since they are already handled in setters // - export declarations with module specifiers are not emitted since they were already written in setters // - export declarations without module specifiers are emitted preserving the order - case SyntaxKind.FunctionDeclaration: + case SyntaxKind.FunctionDeclaration: case SyntaxKind.ImportDeclaration: continue; case SyntaxKind.ExportDeclaration: @@ -6333,16 +6598,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi default: writeLine(); emit(statement); - } + } } decreaseIndent(); writeLine(); write("}"); // execute } - - type DependencyGroup = Array; - - function emitSystemModule(node: SourceFile, startIndex: number): void { + + function emitSystemModule(node: SourceFile): void { collectExternalModuleInfo(node); // System modules has the following shape // System.register(['dep-1', ... 'dep-n'], function(exports) {/* module body function */}) @@ -6361,7 +6624,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write(`"${node.moduleName}", `); } write("["); - + let groupIndices: Map = {}; let dependencyGroups: DependencyGroup[] = []; @@ -6381,12 +6644,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi if (i !== 0) { write(", "); } - + write(text); } write(`], function(${exportFunctionForFile}) {`); writeLine(); increaseIndent(); + let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true); emitEmitHelpers(node); emitCaptureThisForNodeIfNecessary(node); emitSystemModuleBody(node, dependencyGroups, startIndex); @@ -6395,19 +6659,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write("});"); } - function emitAMDDependencies(node: SourceFile, includeNonAmdDependencies: boolean) { - // An AMD define function has the following shape: - // define(id?, dependencies?, factory); - // - // This has the shape of - // define(name, ["module1", "module2"], function (module1Alias) { - // The location of the alias in the parameter list in the factory function needs to - // match the position of the module name in the dependency list. - // - // To ensure this is true in cases of modules with no aliases, e.g.: - // `import "module"` or `` - // we need to add modules without alias names to the end of the dependencies list + interface AMDDependencyNames { + aliasedModuleNames: string[]; + unaliasedModuleNames: string[]; + importAliasNames: string[]; + } + function getAMDDependencyNames(node: SourceFile, includeNonAmdDependencies: boolean): AMDDependencyNames { // names of modules with corresponding parameter in the factory function let aliasedModuleNames: string[] = []; // names of modules with no corresponding parameters in factory function @@ -6442,6 +6700,29 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } } + return { aliasedModuleNames, unaliasedModuleNames, importAliasNames }; + } + + function emitAMDDependencies(node: SourceFile, includeNonAmdDependencies: boolean) { + // An AMD define function has the following shape: + // define(id?, dependencies?, factory); + // + // This has the shape of + // define(name, ["module1", "module2"], function (module1Alias) { + // The location of the alias in the parameter list in the factory function needs to + // match the position of the module name in the dependency list. + // + // To ensure this is true in cases of modules with no aliases, e.g.: + // `import "module"` or `` + // we need to add modules without alias names to the end of the dependencies list + + let dependencyNames = getAMDDependencyNames(node, includeNonAmdDependencies); + emitAMDDependencyList(dependencyNames); + write(", "); + emitAMDFactoryHeader(dependencyNames); + } + + function emitAMDDependencyList({ aliasedModuleNames, unaliasedModuleNames }: AMDDependencyNames) { write("[\"require\", \"exports\""); if (aliasedModuleNames.length) { write(", "); @@ -6451,14 +6732,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write(", "); write(unaliasedModuleNames.join(", ")); } - write("], function (require, exports"); + write("]"); + } + + function emitAMDFactoryHeader({ importAliasNames }: AMDDependencyNames) { + write("function (require, exports"); if (importAliasNames.length) { write(", "); write(importAliasNames.join(", ")); } + write(") {"); } - function emitAMDModule(node: SourceFile, startIndex: number) { + function emitAMDModule(node: SourceFile) { emitEmitHelpers(node); collectExternalModuleInfo(node); @@ -6468,8 +6754,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write("\"" + node.moduleName + "\", "); } emitAMDDependencies(node, /*includeNonAmdDependencies*/ true); - write(") {"); increaseIndent(); + let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true); emitExportStarHelper(); emitCaptureThisForNodeIfNecessary(node); emitLinesStartingAt(node.statements, startIndex); @@ -6480,7 +6766,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write("});"); } - function emitCommonJSModule(node: SourceFile, startIndex: number) { + function emitCommonJSModule(node: SourceFile) { + let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false); emitEmitHelpers(node); collectExternalModuleInfo(node); emitExportStarHelper(); @@ -6490,22 +6777,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitExportEquals(/*emitAsReturn*/ false); } - function emitUMDModule(node: SourceFile, startIndex: number) { + function emitUMDModule(node: SourceFile) { emitEmitHelpers(node); collectExternalModuleInfo(node); + let dependencyNames = getAMDDependencyNames(node, /*includeNonAmdDependencies*/ false); + // Module is detected first to support Browserify users that load into a browser with an AMD loader - writeLines(`(function (deps, factory) { + writeLines(`(function (factory) { if (typeof module === 'object' && typeof module.exports === 'object') { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === 'function' && define.amd) { - define(deps, factory); - } + define(`); + emitAMDDependencyList(dependencyNames); + write(", factory);"); + writeLines(` } })(`); - emitAMDDependencies(node, false); - write(") {"); + emitAMDFactoryHeader(dependencyNames); increaseIndent(); + let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ true); emitExportStarHelper(); emitCaptureThisForNodeIfNecessary(node); emitLinesStartingAt(node.statements, startIndex); @@ -6516,11 +6807,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi write("});"); } - function emitES6Module(node: SourceFile, startIndex: number) { + function emitES6Module(node: SourceFile) { externalImports = undefined; exportSpecifiers = undefined; exportEquals = undefined; hasExportStars = false; + let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false); emitEmitHelpers(node); emitCaptureThisForNodeIfNecessary(node); emitLinesStartingAt(node.statements, startIndex); @@ -6567,7 +6859,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi if (isLineBreak(c)) { if (firstNonWhitespace !== -1 && (lastNonWhitespace - firstNonWhitespace + 1 > 0)) { let part = text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1); - result = (result ? result + "\" + ' ' + \"" : "") + part; + result = (result ? result + "\" + ' ' + \"" : "") + escapeString(part); } firstNonWhitespace = -1; } @@ -6581,7 +6873,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi if (firstNonWhitespace !== -1) { let part = text.substr(firstNonWhitespace); - result = (result ? result + "\" + ' ' + \"" : "") + part; + result = (result ? result + "\" + ' ' + \"" : "") + escapeString(part); } if (result) { @@ -6709,27 +7001,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi emitShebang(); emitDetachedComments(node); - // emit prologue directives prior to __extends - let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false); - if (isExternalModule(node) || compilerOptions.isolatedModules) { - if (languageVersion >= ScriptTarget.ES6) { - emitES6Module(node, startIndex); - } - else if (compilerOptions.module === ModuleKind.AMD) { - emitAMDModule(node, startIndex); - } - else if (compilerOptions.module === ModuleKind.System) { - emitSystemModule(node, startIndex); - } - else if (compilerOptions.module === ModuleKind.UMD) { - emitUMDModule(node, startIndex); - } - else { - emitCommonJSModule(node, startIndex); - } + let emitModule = moduleEmitDelegates[modulekind] || moduleEmitDelegates[ModuleKind.CommonJS]; + emitModule(node); } else { + // emit prologue directives prior to __extends + let startIndex = emitDirectivePrologues(node.statements, /*startWithNewLine*/ false); externalImports = undefined; exportSpecifiers = undefined; exportEquals = undefined; @@ -6807,7 +7085,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi return shouldEmitEnumDeclaration(node); } - // If the node is emitted in specialized fashion, dont emit comments as this node will handle + // If the node is emitted in specialized fashion, dont emit comments as this node will handle // emitting comments when emitting itself Debug.assert(!isSpecializedCommentHandling(node)); @@ -7081,7 +7359,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi if (compilerOptions.removeComments) { return; } - + let leadingComments: CommentRange[]; if (isEmittedNode) { leadingComments = getLeadingCommentsToEmit(node); @@ -7214,7 +7492,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } } } - + function emitShebang() { let shebang = getShebang(currentSourceFile.text); if (shebang) { @@ -7231,260 +7509,4 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi } } } - - var entities: Map = { - "quot": 0x0022, - "amp": 0x0026, - "apos": 0x0027, - "lt": 0x003C, - "gt": 0x003E, - "nbsp": 0x00A0, - "iexcl": 0x00A1, - "cent": 0x00A2, - "pound": 0x00A3, - "curren": 0x00A4, - "yen": 0x00A5, - "brvbar": 0x00A6, - "sect": 0x00A7, - "uml": 0x00A8, - "copy": 0x00A9, - "ordf": 0x00AA, - "laquo": 0x00AB, - "not": 0x00AC, - "shy": 0x00AD, - "reg": 0x00AE, - "macr": 0x00AF, - "deg": 0x00B0, - "plusmn": 0x00B1, - "sup2": 0x00B2, - "sup3": 0x00B3, - "acute": 0x00B4, - "micro": 0x00B5, - "para": 0x00B6, - "middot": 0x00B7, - "cedil": 0x00B8, - "sup1": 0x00B9, - "ordm": 0x00BA, - "raquo": 0x00BB, - "frac14": 0x00BC, - "frac12": 0x00BD, - "frac34": 0x00BE, - "iquest": 0x00BF, - "Agrave": 0x00C0, - "Aacute": 0x00C1, - "Acirc": 0x00C2, - "Atilde": 0x00C3, - "Auml": 0x00C4, - "Aring": 0x00C5, - "AElig": 0x00C6, - "Ccedil": 0x00C7, - "Egrave": 0x00C8, - "Eacute": 0x00C9, - "Ecirc": 0x00CA, - "Euml": 0x00CB, - "Igrave": 0x00CC, - "Iacute": 0x00CD, - "Icirc": 0x00CE, - "Iuml": 0x00CF, - "ETH": 0x00D0, - "Ntilde": 0x00D1, - "Ograve": 0x00D2, - "Oacute": 0x00D3, - "Ocirc": 0x00D4, - "Otilde": 0x00D5, - "Ouml": 0x00D6, - "times": 0x00D7, - "Oslash": 0x00D8, - "Ugrave": 0x00D9, - "Uacute": 0x00DA, - "Ucirc": 0x00DB, - "Uuml": 0x00DC, - "Yacute": 0x00DD, - "THORN": 0x00DE, - "szlig": 0x00DF, - "agrave": 0x00E0, - "aacute": 0x00E1, - "acirc": 0x00E2, - "atilde": 0x00E3, - "auml": 0x00E4, - "aring": 0x00E5, - "aelig": 0x00E6, - "ccedil": 0x00E7, - "egrave": 0x00E8, - "eacute": 0x00E9, - "ecirc": 0x00EA, - "euml": 0x00EB, - "igrave": 0x00EC, - "iacute": 0x00ED, - "icirc": 0x00EE, - "iuml": 0x00EF, - "eth": 0x00F0, - "ntilde": 0x00F1, - "ograve": 0x00F2, - "oacute": 0x00F3, - "ocirc": 0x00F4, - "otilde": 0x00F5, - "ouml": 0x00F6, - "divide": 0x00F7, - "oslash": 0x00F8, - "ugrave": 0x00F9, - "uacute": 0x00FA, - "ucirc": 0x00FB, - "uuml": 0x00FC, - "yacute": 0x00FD, - "thorn": 0x00FE, - "yuml": 0x00FF, - "OElig": 0x0152, - "oelig": 0x0153, - "Scaron": 0x0160, - "scaron": 0x0161, - "Yuml": 0x0178, - "fnof": 0x0192, - "circ": 0x02C6, - "tilde": 0x02DC, - "Alpha": 0x0391, - "Beta": 0x0392, - "Gamma": 0x0393, - "Delta": 0x0394, - "Epsilon": 0x0395, - "Zeta": 0x0396, - "Eta": 0x0397, - "Theta": 0x0398, - "Iota": 0x0399, - "Kappa": 0x039A, - "Lambda": 0x039B, - "Mu": 0x039C, - "Nu": 0x039D, - "Xi": 0x039E, - "Omicron": 0x039F, - "Pi": 0x03A0, - "Rho": 0x03A1, - "Sigma": 0x03A3, - "Tau": 0x03A4, - "Upsilon": 0x03A5, - "Phi": 0x03A6, - "Chi": 0x03A7, - "Psi": 0x03A8, - "Omega": 0x03A9, - "alpha": 0x03B1, - "beta": 0x03B2, - "gamma": 0x03B3, - "delta": 0x03B4, - "epsilon": 0x03B5, - "zeta": 0x03B6, - "eta": 0x03B7, - "theta": 0x03B8, - "iota": 0x03B9, - "kappa": 0x03BA, - "lambda": 0x03BB, - "mu": 0x03BC, - "nu": 0x03BD, - "xi": 0x03BE, - "omicron": 0x03BF, - "pi": 0x03C0, - "rho": 0x03C1, - "sigmaf": 0x03C2, - "sigma": 0x03C3, - "tau": 0x03C4, - "upsilon": 0x03C5, - "phi": 0x03C6, - "chi": 0x03C7, - "psi": 0x03C8, - "omega": 0x03C9, - "thetasym": 0x03D1, - "upsih": 0x03D2, - "piv": 0x03D6, - "ensp": 0x2002, - "emsp": 0x2003, - "thinsp": 0x2009, - "zwnj": 0x200C, - "zwj": 0x200D, - "lrm": 0x200E, - "rlm": 0x200F, - "ndash": 0x2013, - "mdash": 0x2014, - "lsquo": 0x2018, - "rsquo": 0x2019, - "sbquo": 0x201A, - "ldquo": 0x201C, - "rdquo": 0x201D, - "bdquo": 0x201E, - "dagger": 0x2020, - "Dagger": 0x2021, - "bull": 0x2022, - "hellip": 0x2026, - "permil": 0x2030, - "prime": 0x2032, - "Prime": 0x2033, - "lsaquo": 0x2039, - "rsaquo": 0x203A, - "oline": 0x203E, - "frasl": 0x2044, - "euro": 0x20AC, - "image": 0x2111, - "weierp": 0x2118, - "real": 0x211C, - "trade": 0x2122, - "alefsym": 0x2135, - "larr": 0x2190, - "uarr": 0x2191, - "rarr": 0x2192, - "darr": 0x2193, - "harr": 0x2194, - "crarr": 0x21B5, - "lArr": 0x21D0, - "uArr": 0x21D1, - "rArr": 0x21D2, - "dArr": 0x21D3, - "hArr": 0x21D4, - "forall": 0x2200, - "part": 0x2202, - "exist": 0x2203, - "empty": 0x2205, - "nabla": 0x2207, - "isin": 0x2208, - "notin": 0x2209, - "ni": 0x220B, - "prod": 0x220F, - "sum": 0x2211, - "minus": 0x2212, - "lowast": 0x2217, - "radic": 0x221A, - "prop": 0x221D, - "infin": 0x221E, - "ang": 0x2220, - "and": 0x2227, - "or": 0x2228, - "cap": 0x2229, - "cup": 0x222A, - "int": 0x222B, - "there4": 0x2234, - "sim": 0x223C, - "cong": 0x2245, - "asymp": 0x2248, - "ne": 0x2260, - "equiv": 0x2261, - "le": 0x2264, - "ge": 0x2265, - "sub": 0x2282, - "sup": 0x2283, - "nsub": 0x2284, - "sube": 0x2286, - "supe": 0x2287, - "oplus": 0x2295, - "otimes": 0x2297, - "perp": 0x22A5, - "sdot": 0x22C5, - "lceil": 0x2308, - "rceil": 0x2309, - "lfloor": 0x230A, - "rfloor": 0x230B, - "lang": 0x2329, - "rang": 0x232A, - "loz": 0x25CA, - "spades": 0x2660, - "clubs": 0x2663, - "hearts": 0x2665, - "diams": 0x2666 - } } diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 330ad05518b..09fa2ba3b82 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -57,11 +57,17 @@ namespace ts { return visitNode(cbNode, (node).name) || visitNode(cbNode, (node).constraint) || visitNode(cbNode, (node).expression); + case SyntaxKind.ShorthandPropertyAssignment: + return visitNodes(cbNodes, node.decorators) || + visitNodes(cbNodes, node.modifiers) || + visitNode(cbNode, (node).name) || + visitNode(cbNode, (node).questionToken) || + visitNode(cbNode, (node).equalsToken) || + visitNode(cbNode, (node).objectAssignmentInitializer); case SyntaxKind.Parameter: case SyntaxKind.PropertyDeclaration: case SyntaxKind.PropertySignature: case SyntaxKind.PropertyAssignment: - case SyntaxKind.ShorthandPropertyAssignment: case SyntaxKind.VariableDeclaration: case SyntaxKind.BindingElement: return visitNodes(cbNodes, node.decorators) || @@ -425,7 +431,7 @@ namespace ts { // Implement the parser as a singleton module. We do this for perf reasons because creating // parser instances can actually be expensive enough to impact us on projects with many source // files. - module Parser { + namespace Parser { // Share a single scanner across all calls to parse a source file. This helps speed things // up by avoiding the cost of creating/compiling scanners over and over again. const scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ true); @@ -518,7 +524,7 @@ namespace ts { // // Note: any errors at the end of the file that do not precede a regular node, should get // attached to the EOF token. - let parseErrorBeforeNextFinishedNode: boolean = false; + let parseErrorBeforeNextFinishedNode = false; export function parseSourceFile(fileName: string, _sourceText: string, languageVersion: ScriptTarget, _syntaxCursor: IncrementalParser.SyntaxCursor, setParentNodes?: boolean): SourceFile { initializeState(fileName, _sourceText, languageVersion, _syntaxCursor); @@ -856,7 +862,7 @@ namespace ts { let saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode; // Note: it is not actually necessary to save/restore the context flags here. That's - // because the saving/restorating of these flags happens naturally through the recursive + // because the saving/restoring of these flags happens naturally through the recursive // descent nature of our parser. However, we still store this here just so we can // assert that that invariant holds. let saveContextFlags = contextFlags; @@ -1124,7 +1130,15 @@ namespace ts { if (token === SyntaxKind.DefaultKeyword) { return nextTokenIsClassOrFunction(); } + if (token === SyntaxKind.StaticKeyword) { + nextToken(); + return canFollowModifier(); + } + nextToken(); + if (scanner.hasPrecedingLineBreak()) { + return false; + } return canFollowModifier(); } @@ -2360,6 +2374,7 @@ namespace ts { let node = tryParse(parseKeywordAndNoDot); return node || parseTypeReferenceOrTypePredicate(); case SyntaxKind.VoidKeyword: + case SyntaxKind.ThisKeyword: return parseTokenNode(); case SyntaxKind.TypeOfKeyword: return parseTypeQuery(); @@ -2382,6 +2397,7 @@ namespace ts { case SyntaxKind.BooleanKeyword: case SyntaxKind.SymbolKeyword: case SyntaxKind.VoidKeyword: + case SyntaxKind.ThisKeyword: case SyntaxKind.TypeOfKeyword: case SyntaxKind.OpenBraceToken: case SyntaxKind.OpenBracketToken: @@ -3748,11 +3764,23 @@ namespace ts { return parseMethodDeclaration(fullStart, decorators, modifiers, asteriskToken, propertyName, questionToken); } - // Parse to check if it is short-hand property assignment or normal property assignment - if ((token === SyntaxKind.CommaToken || token === SyntaxKind.CloseBraceToken) && tokenIsIdentifier) { + // check if it is short-hand property assignment or normal property assignment + // NOTE: if token is EqualsToken it is interpreted as CoverInitializedName production + // CoverInitializedName[Yield] : + // IdentifierReference[?Yield] Initializer[In, ?Yield] + // this is necessary because ObjectLiteral productions are also used to cover grammar for ObjectAssignmentPattern + const isShorthandPropertyAssignment = + tokenIsIdentifier && (token === SyntaxKind.CommaToken || token === SyntaxKind.CloseBraceToken || token === SyntaxKind.EqualsToken); + + if (isShorthandPropertyAssignment) { let shorthandDeclaration = createNode(SyntaxKind.ShorthandPropertyAssignment, fullStart); shorthandDeclaration.name = propertyName; shorthandDeclaration.questionToken = questionToken; + const equalsToken = parseOptionalToken(SyntaxKind.EqualsToken); + if (equalsToken) { + shorthandDeclaration.equalsToken = equalsToken; + shorthandDeclaration.objectAssignmentInitializer = allowInAnd(parseAssignmentExpressionOrHigher); + } return finishNode(shorthandDeclaration); } else { @@ -3938,7 +3966,8 @@ namespace ts { forOfStatement.expression = allowInAnd(parseAssignmentExpressionOrHigher); parseExpected(SyntaxKind.CloseParenToken); forOrForInOrForOfStatement = forOfStatement; - } else { + } + else { let forStatement = createNode(SyntaxKind.ForStatement, pos); forStatement.initializer = initializer; parseExpected(SyntaxKind.SemicolonToken); @@ -4154,8 +4183,12 @@ namespace ts { case SyntaxKind.ModuleKeyword: case SyntaxKind.NamespaceKeyword: return nextTokenIsIdentifierOrStringLiteralOnSameLine(); + case SyntaxKind.AbstractKeyword: case SyntaxKind.AsyncKeyword: case SyntaxKind.DeclareKeyword: + case SyntaxKind.PrivateKeyword: + case SyntaxKind.ProtectedKeyword: + case SyntaxKind.PublicKeyword: nextToken(); // ASI takes effect for this modifier. if (scanner.hasPrecedingLineBreak()) { @@ -4175,11 +4208,7 @@ namespace ts { } continue; - case SyntaxKind.PublicKeyword: - case SyntaxKind.PrivateKeyword: - case SyntaxKind.ProtectedKeyword: case SyntaxKind.StaticKeyword: - case SyntaxKind.AbstractKeyword: nextToken(); continue; default: @@ -4809,7 +4838,7 @@ namespace ts { node.decorators = decorators; setModifiers(node, modifiers); parseExpected(SyntaxKind.ClassKeyword); - node.name = parseOptionalIdentifier(); + node.name = parseNameOfClassDeclarationOrExpression(); node.typeParameters = parseTypeParameters(); node.heritageClauses = parseHeritageClauses(/*isClassHeritageClause*/ true); @@ -4826,6 +4855,21 @@ namespace ts { return finishNode(node); } + function parseNameOfClassDeclarationOrExpression(): Identifier { + // implements is a future reserved word so + // 'class implements' might mean either + // - class expression with omitted name, 'implements' starts heritage clause + // - class with name 'implements' + // 'isImplementsClause' helps to disambiguate between these two cases + return isIdentifier() && !isImplementsClause() + ? parseIdentifier() + : undefined; + } + + function isImplementsClause() { + return token === SyntaxKind.ImplementsKeyword && lookAhead(nextTokenIsIdentifierOrKeyword); + } + function parseHeritageClauses(isClassHeritageClause: boolean): NodeArray { // ClassTail[Yield,Await] : (Modified) See 14.5 // ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt } @@ -5300,7 +5344,7 @@ namespace ts { Unknown } - export module JSDocParser { + export namespace JSDocParser { export function isJSDocType() { switch (token) { case SyntaxKind.AsteriskToken: @@ -5945,7 +5989,7 @@ namespace ts { } } - module IncrementalParser { + namespace IncrementalParser { export function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks: boolean): SourceFile { aggressiveChecks = aggressiveChecks || Debug.shouldAssert(AssertionLevel.Aggressive); diff --git a/src/compiler/program.ts b/src/compiler/program.ts index 946bf9e75bb..73920fd238a 100644 --- a/src/compiler/program.ts +++ b/src/compiler/program.ts @@ -9,9 +9,9 @@ namespace ts { /* @internal */ export let ioWriteTime = 0; /** The version of the TypeScript compiler release */ - + let emptyArray: any[] = []; - + export const version = "1.7.0"; export function findConfigFile(searchPath: string): string { @@ -29,36 +29,36 @@ namespace ts { } return undefined; } - + export function resolveTripleslashReference(moduleName: string, containingFile: string): string { let basePath = getDirectoryPath(containingFile); let referencedFileName = isRootedDiskPath(moduleName) ? moduleName : combinePaths(basePath, moduleName); return normalizePath(referencedFileName); } - + export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations { - let moduleResolution = compilerOptions.moduleResolution !== undefined + let moduleResolution = compilerOptions.moduleResolution !== undefined ? compilerOptions.moduleResolution : compilerOptions.module === ModuleKind.CommonJS ? ModuleResolutionKind.NodeJs : ModuleResolutionKind.Classic; - + switch (moduleResolution) { case ModuleResolutionKind.NodeJs: return nodeModuleNameResolver(moduleName, containingFile, host); case ModuleResolutionKind.Classic: return classicNameResolver(moduleName, containingFile, compilerOptions, host); } } - + export function nodeModuleNameResolver(moduleName: string, containingFile: string, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations { - let containingDirectory = getDirectoryPath(containingFile); + let containingDirectory = getDirectoryPath(containingFile); if (getRootLength(moduleName) !== 0 || nameStartsWithDotSlashOrDotDotSlash(moduleName)) { let failedLookupLocations: string[] = []; let candidate = normalizePath(combinePaths(containingDirectory, moduleName)); let resolvedFileName = loadNodeModuleFromFile(candidate, failedLookupLocations, host); - + if (resolvedFileName) { return { resolvedModule: { resolvedFileName }, failedLookupLocations }; } - + resolvedFileName = loadNodeModuleFromDirectory(candidate, failedLookupLocations, host); return resolvedFileName ? { resolvedModule: { resolvedFileName }, failedLookupLocations } @@ -68,10 +68,10 @@ namespace ts { return loadModuleFromNodeModules(moduleName, containingDirectory, host); } } - + function loadNodeModuleFromFile(candidate: string, failedLookupLocation: string[], host: ModuleResolutionHost): string { return forEach(moduleFileExtensions, tryLoad); - + function tryLoad(ext: string): string { let fileName = fileExtensionIs(candidate, ext) ? candidate : candidate + ext; if (host.fileExists(fileName)) { @@ -83,13 +83,13 @@ namespace ts { } } } - + function loadNodeModuleFromDirectory(candidate: string, failedLookupLocation: string[], host: ModuleResolutionHost): string { let packageJsonPath = combinePaths(candidate, "package.json"); if (host.fileExists(packageJsonPath)) { - + let jsonContent: { typings?: string }; - + try { let jsonText = host.readFile(packageJsonPath); jsonContent = jsonText ? <{ typings?: string }>JSON.parse(jsonText) : { typings: undefined }; @@ -98,7 +98,7 @@ namespace ts { // gracefully handle if readFile fails or returns not JSON jsonContent = { typings: undefined }; } - + if (jsonContent.typings) { let result = loadNodeModuleFromFile(normalizePath(combinePaths(candidate, jsonContent.typings)), failedLookupLocation, host); if (result) { @@ -110,12 +110,12 @@ namespace ts { // record package json as one of failed lookup locations - in the future if this file will appear it will invalidate resolution results failedLookupLocation.push(packageJsonPath); } - + return loadNodeModuleFromFile(combinePaths(candidate, "index"), failedLookupLocation, host); } - + function loadModuleFromNodeModules(moduleName: string, directory: string, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations { - let failedLookupLocations: string[] = []; + let failedLookupLocations: string[] = []; directory = normalizeSlashes(directory); while (true) { let baseName = getBaseFileName(directory); @@ -126,36 +126,36 @@ namespace ts { if (result) { return { resolvedModule: { resolvedFileName: result, isExternalLibraryImport: true }, failedLookupLocations }; } - + result = loadNodeModuleFromDirectory(candidate, failedLookupLocations, host); if (result) { return { resolvedModule: { resolvedFileName: result, isExternalLibraryImport: true }, failedLookupLocations }; } } - + let parentPath = getDirectoryPath(directory); if (parentPath === directory) { break; } - + directory = parentPath; } - + return { resolvedModule: undefined, failedLookupLocations }; } - + function nameStartsWithDotSlashOrDotDotSlash(name: string) { let i = name.lastIndexOf("./", 1); return i === 0 || (i === 1 && name.charCodeAt(0) === CharacterCodes.dot); } export function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost): ResolvedModuleWithFailedLookupLocations { - + // module names that contain '!' are used to reference resources and are not resolved to actual files on disk - if (moduleName.indexOf('!') != -1) { + if (moduleName.indexOf("!") != -1) { return { resolvedModule: undefined, failedLookupLocations: [] }; } - + let searchPath = getDirectoryPath(containingFile); let searchName: string; @@ -170,7 +170,7 @@ namespace ts { // 'logical not' handles both undefined and None cases return undefined; } - + let candidate = searchName + extension; if (host.fileExists(candidate)) { return candidate; @@ -272,8 +272,7 @@ namespace ts { } const newLine = getNewLineCharacter(options); - - + return { getSourceFile, getDefaultLibFileName: options => combinePaths(getDirectoryPath(normalizePath(sys.getExecutingFilePath())), getDefaultLibFileName(options)), @@ -342,26 +341,26 @@ namespace ts { let start = new Date().getTime(); host = host || createCompilerHost(options); - + const resolveModuleNamesWorker = host.resolveModuleNames ? ((moduleNames: string[], containingFile: string) => host.resolveModuleNames(moduleNames, containingFile)) : ((moduleNames: string[], containingFile: string) => map(moduleNames, moduleName => resolveModuleName(moduleName, containingFile, options, host).resolvedModule)); let filesByName = createFileMap(fileName => host.getCanonicalFileName(fileName)); - + if (oldProgram) { // check properties that can affect structure of the program or module resolution strategy // if any of these properties has changed - structure cannot be reused let oldOptions = oldProgram.getCompilerOptions(); - if ((oldOptions.module !== options.module) || - (oldOptions.noResolve !== options.noResolve) || - (oldOptions.target !== options.target) || + if ((oldOptions.module !== options.module) || + (oldOptions.noResolve !== options.noResolve) || + (oldOptions.target !== options.target) || (oldOptions.noLib !== options.noLib) || (oldOptions.jsx !== options.jsx)) { oldProgram = undefined; } } - + if (!tryReuseStructureFromOldProgram()) { forEach(rootNames, name => processRootFile(name, false)); // Do not process the default library if: @@ -422,7 +421,7 @@ namespace ts { if (!oldProgram) { return false; } - + Debug.assert(!oldProgram.structureIsReused); // there is an old program, check if we can reuse its structure @@ -430,7 +429,7 @@ namespace ts { if (!arrayIsEqualTo(oldRootNames, rootNames)) { return false; } - + // check if program source files has changed in the way that can affect structure of the program let newSourceFiles: SourceFile[] = []; let modifiedSourceFiles: SourceFile[] = []; @@ -440,7 +439,7 @@ namespace ts { return false; } - if (oldSourceFile !== newSourceFile) { + if (oldSourceFile !== newSourceFile) { if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) { // value of no-default-lib has changed // this will affect if default library is injected into the list of files @@ -452,14 +451,14 @@ namespace ts { // tripleslash references has changed return false; } - + // check imports collectExternalModuleReferences(newSourceFile); if (!arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) { // imports has changed return false; } - + if (resolveModuleNamesWorker) { let moduleNames = map(newSourceFile.imports, name => name.text); let resolutions = resolveModuleNamesWorker(moduleNames, newSourceFile.fileName); @@ -468,11 +467,11 @@ namespace ts { let newResolution = resolutions[i]; let oldResolution = getResolvedModule(oldSourceFile, moduleNames[i]); let resolutionChanged = oldResolution - ? !newResolution || + ? !newResolution || oldResolution.resolvedFileName !== newResolution.resolvedFileName || !!oldResolution.isExternalLibraryImport !== !!newResolution.isExternalLibraryImport : newResolution; - + if (resolutionChanged) { return false; } @@ -486,24 +485,24 @@ namespace ts { // file has no changes - use it as is newSourceFile = oldSourceFile; } - + // if file has passed all checks it should be safe to reuse it newSourceFiles.push(newSourceFile); } - + // update fileName -> file mapping for (let file of newSourceFiles) { filesByName.set(file.fileName, file); } - + files = newSourceFiles; fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics(); - + for (let modifiedFile of modifiedSourceFiles) { fileProcessingDiagnostics.reattachFileDiagnostics(modifiedFile); } oldProgram.structureIsReused = true; - + return true; } @@ -549,7 +548,7 @@ namespace ts { // This is because in the -out scenario all files need to be emitted, and therefore all // files need to be type checked. And the way to specify that all files need to be type // checked is to not pass the file to getEmitResolver. - let emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out)? undefined : sourceFile); + let emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile); let start = new Date().getTime(); @@ -563,7 +562,9 @@ namespace ts { } function getSourceFile(fileName: string) { - return filesByName.get(fileName); + // first try to use file name as is to find file + // then try to convert relative file name to absolute and use it to retrieve source file + return filesByName.get(fileName) || filesByName.get(getNormalizedAbsolutePath(fileName, host.getCurrentDirectory())); } function getDiagnosticsHelper( @@ -651,7 +652,7 @@ namespace ts { function getOptionsDiagnostics(): Diagnostic[] { let allDiagnostics: Diagnostic[] = []; - addRange(allDiagnostics, fileProcessingDiagnostics.getGlobalDiagnostics()) + addRange(allDiagnostics, fileProcessingDiagnostics.getGlobalDiagnostics()); addRange(allDiagnostics, programDiagnostics.getGlobalDiagnostics()); return sortAndDeduplicateDiagnostics(allDiagnostics); } @@ -668,23 +669,29 @@ namespace ts { function processRootFile(fileName: string, isDefaultLib: boolean) { processSourceFile(normalizePath(fileName), isDefaultLib); - } - + } + function fileReferenceIsEqualTo(a: FileReference, b: FileReference): boolean { return a.fileName === b.fileName; } - + function moduleNameIsEqualTo(a: LiteralExpression, b: LiteralExpression): boolean { return a.text === b.text; } - + function collectExternalModuleReferences(file: SourceFile): void { if (file.imports) { return; } - + let imports: LiteralExpression[]; for (let node of file.statements) { + collect(node, /* allowRelativeModuleNames */ true); + } + + file.imports = imports || emptyArray; + + function collect(node: Node, allowRelativeModuleNames: boolean): void { switch (node.kind) { case SyntaxKind.ImportDeclaration: case SyntaxKind.ImportEqualsDeclaration: @@ -697,7 +704,9 @@ namespace ts { break; } - (imports || (imports = [])).push(moduleNameExpr); + if (allowRelativeModuleNames || !isExternalModuleNameRelative((moduleNameExpr).text)) { + (imports || (imports = [])).push(moduleNameExpr); + } break; case SyntaxKind.ModuleDeclaration: if ((node).name.kind === SyntaxKind.StringLiteral && (node.flags & NodeFlags.Ambient || isDeclarationFile(file))) { @@ -707,23 +716,15 @@ namespace ts { // The StringLiteral must specify a top - level external module name. // Relative external module names are not permitted forEachChild((node).body, node => { - if (isExternalModuleImportEqualsDeclaration(node) && - getExternalModuleImportEqualsDeclarationExpression(node).kind === SyntaxKind.StringLiteral) { - let moduleName = getExternalModuleImportEqualsDeclarationExpression(node); - // TypeScript 1.0 spec (April 2014): 12.1.6 - // An ExternalImportDeclaration in anAmbientExternalModuleDeclaration may reference other external modules - // only through top - level external module names. Relative external module names are not permitted. - if (moduleName) { - (imports || (imports = [])).push(moduleName); - } - } + // TypeScript 1.0 spec (April 2014): 12.1.6 + // An ExternalImportDeclaration in anAmbientExternalModuleDeclaration may reference other external modules + // only through top - level external module names. Relative external module names are not permitted. + collect(node, /* allowRelativeModuleNames */ false); }); } break; } } - - file.imports = imports || emptyArray; } function processSourceFile(fileName: string, isDefaultLib: boolean, refFile?: SourceFile, refPos?: number, refEnd?: number) { @@ -770,60 +771,62 @@ namespace ts { // Get source file from normalized fileName function findSourceFile(fileName: string, isDefaultLib: boolean, refFile?: SourceFile, refPos?: number, refEnd?: number): SourceFile { - let canonicalName = host.getCanonicalFileName(normalizeSlashes(fileName)); - if (filesByName.contains(canonicalName)) { + if (filesByName.contains(fileName)) { // We've already looked for this file, use cached result - return getSourceFileFromCache(fileName, canonicalName, /*useAbsolutePath*/ false); + return getSourceFileFromCache(fileName, /*useAbsolutePath*/ false); } - else { - let normalizedAbsolutePath = getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); - let canonicalAbsolutePath = host.getCanonicalFileName(normalizedAbsolutePath); - if (filesByName.contains(canonicalAbsolutePath)) { - return getSourceFileFromCache(normalizedAbsolutePath, canonicalAbsolutePath, /*useAbsolutePath*/ true); - } - - // We haven't looked for this file, do so now and cache result - let file = host.getSourceFile(fileName, options.target, hostErrorMessage => { - if (refFile !== undefined && refPos !== undefined && refEnd !== undefined) { - fileProcessingDiagnostics.add(createFileDiagnostic(refFile, refPos, refEnd - refPos, - Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); - } - else { - fileProcessingDiagnostics.add(createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); - } - }); - filesByName.set(canonicalName, file); - if (file) { - skipDefaultLib = skipDefaultLib || file.hasNoDefaultLib; - - // Set the source file for normalized absolute path - filesByName.set(canonicalAbsolutePath, file); - - let basePath = getDirectoryPath(fileName); - if (!options.noResolve) { - processReferencedFiles(file, basePath); - } - - // always process imported modules to record module name resolutions - processImportedModules(file, basePath); - - if (isDefaultLib) { - file.isDefaultLib = true; - files.unshift(file); - } - else { - files.push(file); - } - } + let normalizedAbsolutePath = getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); + if (filesByName.contains(normalizedAbsolutePath)) { + const file = getSourceFileFromCache(normalizedAbsolutePath, /*useAbsolutePath*/ true); + // we don't have resolution for this relative file name but the match was found by absolute file name + // store resolution for relative name as well + filesByName.set(fileName, file); return file; } - function getSourceFileFromCache(fileName: string, canonicalName: string, useAbsolutePath: boolean): SourceFile { - let file = filesByName.get(canonicalName); + // We haven't looked for this file, do so now and cache result + let file = host.getSourceFile(fileName, options.target, hostErrorMessage => { + if (refFile !== undefined && refPos !== undefined && refEnd !== undefined) { + fileProcessingDiagnostics.add(createFileDiagnostic(refFile, refPos, refEnd - refPos, + Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); + } + else { + fileProcessingDiagnostics.add(createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, hostErrorMessage)); + } + }); + + filesByName.set(fileName, file); + if (file) { + skipDefaultLib = skipDefaultLib || file.hasNoDefaultLib; + + // Set the source file for normalized absolute path + filesByName.set(normalizedAbsolutePath, file); + + let basePath = getDirectoryPath(fileName); + if (!options.noResolve) { + processReferencedFiles(file, basePath); + } + + // always process imported modules to record module name resolutions + processImportedModules(file, basePath); + + if (isDefaultLib) { + file.isDefaultLib = true; + files.unshift(file); + } + else { + files.push(file); + } + } + + return file; + + function getSourceFileFromCache(fileName: string, useAbsolutePath: boolean): SourceFile { + let file = filesByName.get(fileName); if (file && host.useCaseSensitiveFileNames()) { let sourceFileName = useAbsolutePath ? getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory()) : file.fileName; - if (canonicalName !== sourceFileName) { + if (normalizeSlashes(fileName) !== normalizeSlashes(sourceFileName)) { if (refFile !== undefined && refPos !== undefined && refEnd !== undefined) { fileProcessingDiagnostics.add(createFileDiagnostic(refFile, refPos, refEnd - refPos, Diagnostics.File_name_0_differs_from_already_included_file_name_1_only_in_casing, fileName, sourceFileName)); @@ -843,7 +846,7 @@ namespace ts { processSourceFile(referencedFileName, /* isDefaultLib */ false, file, ref.pos, ref.end); }); } - + function processImportedModules(file: SourceFile, basePath: string) { collectExternalModuleReferences(file); if (file.imports.length) { @@ -857,11 +860,11 @@ namespace ts { const importedFile = findModuleSourceFile(resolution.resolvedFileName, file.imports[i]); if (importedFile && resolution.isExternalLibraryImport) { if (!isExternalModule(importedFile)) { - let start = getTokenPosOfNode(file.imports[i], file) + let start = getTokenPosOfNode(file.imports[i], file); fileProcessingDiagnostics.add(createFileDiagnostic(file, start, file.imports[i].end - start, Diagnostics.Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_the_package_definition, importedFile.fileName)); } else if (!fileExtensionIs(importedFile.fileName, ".d.ts")) { - let start = getTokenPosOfNode(file.imports[i], file) + let start = getTokenPosOfNode(file.imports[i], file); fileProcessingDiagnostics.add(createFileDiagnostic(file, start, file.imports[i].end - start, Diagnostics.Exported_external_package_typings_can_only_be_in_d_ts_files_Please_contact_the_package_author_to_update_the_package_definition)); } else if (importedFile.referencedFiles.length) { @@ -1017,9 +1020,9 @@ namespace ts { programDiagnostics.add(createFileDiagnostic(firstExternalModuleSourceFile, span.start, span.length, Diagnostics.Cannot_compile_modules_unless_the_module_flag_is_provided)); } - // Cannot specify module gen target when in es6 or above - if (options.module && languageVersion >= ScriptTarget.ES6) { - programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Cannot_compile_modules_into_commonjs_amd_system_or_umd_when_targeting_ES6_or_higher)); + // Cannot specify module gen target of es6 when below es6 + if (options.module === ModuleKind.ES6 && languageVersion < ScriptTarget.ES6) { + programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Cannot_compile_modules_into_es6_when_targeting_ES5_or_lower)); } // there has to be common source directory if user specified --outdir || --sourceRoot diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts index 82fbc8c2a59..ee4dea04f09 100644 --- a/src/compiler/scanner.ts +++ b/src/compiler/scanner.ts @@ -224,7 +224,7 @@ namespace ts { } // Perform binary search in one of the Unicode range maps - let lo: number = 0; + let lo = 0; let hi: number = map.length; let mid: number; @@ -657,7 +657,7 @@ namespace ts { export function getTrailingCommentRanges(text: string, pos: number): CommentRange[] { return getCommentRanges(text, pos, /*trailing*/ true); } - + /** Optionally, get the shebang */ export function getShebang(text: string): string { return shebangTriviaRegex.test(text) @@ -739,18 +739,6 @@ namespace ts { } } - function isIdentifierStart(ch: number): boolean { - return ch >= CharacterCodes.A && ch <= CharacterCodes.Z || ch >= CharacterCodes.a && ch <= CharacterCodes.z || - ch === CharacterCodes.$ || ch === CharacterCodes._ || - ch > CharacterCodes.maxAsciiCharacter && isUnicodeIdentifierStart(ch, languageVersion); - } - - function isIdentifierPart(ch: number): boolean { - return ch >= CharacterCodes.A && ch <= CharacterCodes.Z || ch >= CharacterCodes.a && ch <= CharacterCodes.z || - ch >= CharacterCodes._0 && ch <= CharacterCodes._9 || ch === CharacterCodes.$ || ch === CharacterCodes._ || - ch > CharacterCodes.maxAsciiCharacter && isUnicodeIdentifierPart(ch, languageVersion); - } - function scanNumber(): number { let start = pos; while (isDigit(text.charCodeAt(pos))) pos++; @@ -1064,12 +1052,12 @@ namespace ts { let start = pos; while (pos < end) { let ch = text.charCodeAt(pos); - if (isIdentifierPart(ch)) { + if (isIdentifierPart(ch, languageVersion)) { pos++; } else if (ch === CharacterCodes.backslash) { ch = peekUnicodeEscape(); - if (!(ch >= 0 && isIdentifierPart(ch))) { + if (!(ch >= 0 && isIdentifierPart(ch, languageVersion))) { break; } result += text.substring(start, pos); @@ -1373,7 +1361,9 @@ namespace ts { if (text.charCodeAt(pos + 1) === CharacterCodes.equals) { return pos += 2, token = SyntaxKind.LessThanEqualsToken; } - if (text.charCodeAt(pos + 1) === CharacterCodes.slash && languageVariant === LanguageVariant.JSX) { + if (languageVariant === LanguageVariant.JSX && + text.charCodeAt(pos + 1) === CharacterCodes.slash && + text.charCodeAt(pos + 2) !== CharacterCodes.asterisk) { return pos += 2, token = SyntaxKind.LessThanSlashToken; } return pos++, token = SyntaxKind.LessThanToken; @@ -1439,7 +1429,7 @@ namespace ts { return pos++, token = SyntaxKind.AtToken; case CharacterCodes.backslash: let cookedChar = peekUnicodeEscape(); - if (cookedChar >= 0 && isIdentifierStart(cookedChar)) { + if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) { pos += 6; tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts(); return token = getIdentifierToken(); @@ -1447,9 +1437,9 @@ namespace ts { error(Diagnostics.Invalid_character); return pos++, token = SyntaxKind.Unknown; default: - if (isIdentifierStart(ch)) { + if (isIdentifierStart(ch, languageVersion)) { pos++; - while (pos < end && isIdentifierPart(ch = text.charCodeAt(pos))) pos++; + while (pos < end && isIdentifierPart(ch = text.charCodeAt(pos), languageVersion)) pos++; tokenValue = text.substring(tokenPos, pos); if (ch === CharacterCodes.backslash) { tokenValue += scanIdentifierParts(); @@ -1536,7 +1526,7 @@ namespace ts { p++; } - while (p < end && isIdentifierPart(text.charCodeAt(p))) { + while (p < end && isIdentifierPart(text.charCodeAt(p), languageVersion)) { p++; } pos = p; @@ -1599,7 +1589,7 @@ namespace ts { let firstCharPosition = pos; while (pos < end) { let ch = text.charCodeAt(pos); - if (ch === CharacterCodes.minus || ((firstCharPosition === pos) ? isIdentifierStart(ch) : isIdentifierPart(ch))) { + if (ch === CharacterCodes.minus || ((firstCharPosition === pos) ? isIdentifierStart(ch, languageVersion) : isIdentifierPart(ch, languageVersion))) { pos++; } else { diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts index 5b46324601b..76f12666878 100644 --- a/src/compiler/sys.ts +++ b/src/compiler/sys.ts @@ -8,7 +8,7 @@ namespace ts { write(s: string): void; readFile(path: string, encoding?: string): string; writeFile(path: string, data: string, writeByteOrderMark?: boolean): void; - watchFile?(path: string, callback: (path: string) => void): FileWatcher; + watchFile?(path: string, callback: (path: string, removed: boolean) => void): FileWatcher; resolvePath(path: string): string; fileExists(path: string): boolean; directoryExists(path: string): boolean; @@ -29,8 +29,8 @@ namespace ts { declare var process: any; declare var global: any; declare var __filename: string; - declare var Buffer: { - new (str: string, encoding?: string): any; + declare var Buffer: { + new (str: string, encoding?: string): any; }; declare class Enumerator { @@ -116,7 +116,7 @@ namespace ts { return path.toLowerCase(); } - function getNames(collection: any): string[]{ + function getNames(collection: any): string[] { let result: string[] = []; for (let e = new Enumerator(collection); !e.atEnd(); e.moveNext()) { result.push(e.item().Name); @@ -270,9 +270,9 @@ namespace ts { args: process.argv.slice(2), newLine: _os.EOL, useCaseSensitiveFileNames: useCaseSensitiveFileNames, - write(s: string): void { - const buffer = new Buffer(s, "utf8"); - let offset: number = 0; + write(s: string): void { + const buffer = new Buffer(s, "utf8"); + let offset = 0; let toWrite: number = buffer.length; let written = 0; // 1 is a standard descriptor for stdout @@ -280,7 +280,7 @@ namespace ts { offset += written; toWrite -= written; } - }, + }, readFile, writeFile, watchFile: (fileName, callback) => { @@ -292,11 +292,16 @@ namespace ts { }; function fileChanged(curr: any, prev: any) { + // mtime.getTime() equals 0 if file was removed + if (curr.mtime.getTime() === 0) { + callback(fileName, /* removed */ true); + return; + } if (+curr.mtime <= +prev.mtime) { return; } - callback(fileName); + callback(fileName, /* removed */ false); } }, resolvePath: function (path: string): string { diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts index 96759b68250..7b74024aec4 100644 --- a/src/compiler/tsc.ts +++ b/src/compiler/tsc.ts @@ -86,7 +86,6 @@ namespace ts { if (diagnostic.file) { let loc = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start); - output += `${ diagnostic.file.fileName }(${ loc.line + 1 },${ loc.character + 1 }): `; } @@ -102,6 +101,19 @@ namespace ts { } } + function reportWatchDiagnostic(diagnostic: Diagnostic) { + let output = new Date().toLocaleTimeString() + " - "; + + if (diagnostic.file) { + let loc = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start); + output += `${ diagnostic.file.fileName }(${ loc.line + 1 },${ loc.character + 1 }): `; + } + + output += `${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }${ sys.newLine }`; + + sys.write(output); + } + function padLeft(s: string, length: number) { while (s.length < length) { s = " " + s; @@ -218,7 +230,7 @@ namespace ts { let result = readConfigFile(configFileName, sys.readFile); if (result.error) { - reportDiagnostic(result.error); + reportWatchDiagnostic(result.error); return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped); } @@ -247,7 +259,7 @@ namespace ts { } setCachedProgram(compileResult.program); - reportDiagnostic(createCompilerDiagnostic(Diagnostics.Compilation_complete_Watching_for_file_changes)); + reportWatchDiagnostic(createCompilerDiagnostic(Diagnostics.Compilation_complete_Watching_for_file_changes)); } function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void) { @@ -263,7 +275,7 @@ namespace ts { let sourceFile = hostGetSourceFile(fileName, languageVersion, onError); if (sourceFile && compilerOptions.watch) { // Attach a file watcher - sourceFile.fileWatcher = sys.watchFile(sourceFile.fileName, () => sourceFileChanged(sourceFile)); + sourceFile.fileWatcher = sys.watchFile(sourceFile.fileName, (fileName, removed) => sourceFileChanged(sourceFile, removed)); } return sourceFile; } @@ -285,9 +297,15 @@ namespace ts { } // If a source file changes, mark it as unwatched and start the recompilation timer - function sourceFileChanged(sourceFile: SourceFile) { + function sourceFileChanged(sourceFile: SourceFile, removed: boolean) { sourceFile.fileWatcher.close(); sourceFile.fileWatcher = undefined; + if (removed) { + let index = rootFileNames.indexOf(sourceFile.fileName); + if (index >= 0) { + rootFileNames.splice(index, 1); + } + } startTimer(); } @@ -309,7 +327,7 @@ namespace ts { function recompile() { timerHandle = undefined; - reportDiagnostic(createCompilerDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation)); + reportWatchDiagnostic(createCompilerDiagnostic(Diagnostics.File_change_detected_Starting_incremental_compilation)); performCompilation(); } } @@ -361,7 +379,7 @@ namespace ts { function compileProgram(): ExitStatus { let diagnostics: Diagnostic[]; - + // First get and report any syntactic errors. diagnostics = program.getSyntacticDiagnostics(); @@ -497,7 +515,7 @@ namespace ts { function writeConfigFile(options: CompilerOptions, fileNames: string[]) { let currentDirectory = sys.getCurrentDirectory(); - let file = combinePaths(currentDirectory, 'tsconfig.json'); + let file = combinePaths(currentDirectory, "tsconfig.json"); if (sys.fileExists(file)) { reportDiagnostic(createCompilerDiagnostic(Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file)); } @@ -519,8 +537,8 @@ namespace ts { return; - function serializeCompilerOptions(options: CompilerOptions): Map { - let result: Map = {}; + function serializeCompilerOptions(options: CompilerOptions): Map { + let result: Map = {}; let optionsNameMap = getOptionNameMap().optionNameMap; for (let name in options) { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index d2757bb7937..cbaa3e65e27 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -376,6 +376,7 @@ namespace ts { OctalLiteral = 0x00010000, // Octal numeric literal Namespace = 0x00020000, // Namespace declaration ExportContext = 0x00040000, // Export context (initialized by binding) + ContainsThis = 0x00080000, // Interface contains references to "this" Modifier = Export | Ambient | Public | Private | Protected | Static | Abstract | Default | Async, AccessibilityModifier = Public | Private | Protected, @@ -561,6 +562,10 @@ namespace ts { export interface ShorthandPropertyAssignment extends ObjectLiteralElement { name: Identifier; questionToken?: Node; + // used when ObjectLiteralExpression is used in ObjectAssignmentPattern + // it is grammar error to appear in actual object initializer + equalsToken?: Node; + objectAssignmentInitializer?: Expression; } // SyntaxKind.VariableDeclaration @@ -1244,7 +1249,7 @@ namespace ts { moduleName: string; referencedFiles: FileReference[]; languageVariant: LanguageVariant; - + // this map is used by transpiler to supply alternative names for dependencies (i.e. in case of bundling) /* @internal */ renamedDependencies?: Map; @@ -1312,12 +1317,12 @@ namespace ts { } export interface Program extends ScriptReferenceHost { - + /** * Get a list of root file names that were passed to a 'createProgram' */ - getRootFileNames(): string[] - + getRootFileNames(): string[]; + /** * Get a list of files in the program */ @@ -1496,6 +1501,7 @@ namespace ts { // declaration emitter to help determine if it should patch up the final declaration file // with import statements it previously saw (but chose not to emit). trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void; + reportInaccessibleThisError(): void; } export const enum TypeFormatFlags { @@ -1596,9 +1602,8 @@ namespace ts { isEntityNameVisible(entityName: EntityName | Expression, enclosingDeclaration: Node): SymbolVisibilityResult; // Returns the constant value this property access resolves to, or 'undefined' for a non-constant getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number; - getBlockScopedVariableId(node: Identifier): number; getReferencedValueDeclaration(reference: Identifier): Declaration; - getTypeReferenceSerializationKind(typeName: EntityName): TypeReferenceSerializationKind; + getTypeReferenceSerializationKind(typeName: EntityName): TypeReferenceSerializationKind; isOptionalParameter(node: ParameterDeclaration): boolean; } @@ -1797,6 +1802,7 @@ namespace ts { /* @internal */ ContainsAnyFunctionType = 0x00800000, // Type is or contains object literal type ESSymbol = 0x01000000, // Type of symbol primitive introduced in ES6 + ThisType = 0x02000000, // This type /* @internal */ Intrinsic = Any | String | Number | Boolean | ESSymbol | Void | Undefined | Null, @@ -1842,6 +1848,7 @@ namespace ts { typeParameters: TypeParameter[]; // Type parameters (undefined if non-generic) outerTypeParameters: TypeParameter[]; // Outer type parameters (undefined if none) localTypeParameters: TypeParameter[]; // Local type parameters (undefined if none) + thisType: TypeParameter; // The "this" type (undefined if none) /* @internal */ resolvedBaseConstructorType?: Type; // Resolved base constructor type of class /* @internal */ @@ -1856,10 +1863,17 @@ namespace ts { declaredNumberIndexType: Type; // Declared numeric index type } - // Type references (TypeFlags.Reference) + // Type references (TypeFlags.Reference). When a class or interface has type parameters or + // a "this" type, references to the class or interface are made using type references. The + // typeArguments property specififes the types to substitute for the type parameters of the + // class or interface and optionally includes an extra element that specifies the type to + // substitute for "this" in the resulting instantiation. When no extra argument is present, + // the type reference itself is substituted for "this". The typeArguments property is undefined + // if the class or interface has no type parameters and the reference isn't specifying an + // explicit "this" argument. export interface TypeReference extends ObjectType { target: GenericType; // Type reference target - typeArguments: Type[]; // Type reference type arguments + typeArguments: Type[]; // Type reference type arguments (undefined if none) } // Generic class and interface types @@ -1869,7 +1883,7 @@ namespace ts { } export interface TupleType extends ObjectType { - elementTypes: Type[]; // Element types + elementTypes: Type[]; // Element types } export interface UnionOrIntersectionType extends Type { @@ -1884,6 +1898,13 @@ namespace ts { export interface IntersectionType extends UnionOrIntersectionType { } + /* @internal */ + // An instantiated anonymous type has a target and a mapper + export interface AnonymousType extends ObjectType { + target?: AnonymousType; // Instantiation target + mapper?: TypeMapper; // Instantiation mapper + } + /* @internal */ // Resolved object, union, or intersection type export interface ResolvedType extends ObjectType, UnionOrIntersectionType { @@ -2014,12 +2035,12 @@ namespace ts { Error, Message, } - + export const enum ModuleResolutionKind { Classic = 1, NodeJs = 2 } - + export interface CompilerOptions { allowNonTsExtensions?: boolean; charset?: string; @@ -2061,7 +2082,7 @@ namespace ts { experimentalDecorators?: boolean; experimentalAsyncFunctions?: boolean; emitDecoratorMetadata?: boolean; - moduleResolution?: ModuleResolutionKind + moduleResolution?: ModuleResolutionKind; /* @internal */ stripInternal?: boolean; // Skip checking lib.d.ts to help speed up tests. @@ -2076,6 +2097,7 @@ namespace ts { AMD = 2, UMD = 3, System = 4, + ES6 = 5, } export const enum JsxEmit { @@ -2275,15 +2297,15 @@ namespace ts { byteOrderMark = 0xFEFF, tab = 0x09, // \t verticalTab = 0x0B, // \v - } - + } + export interface ModuleResolutionHost { fileExists(fileName: string): boolean; // readFile function is used to read arbitrary text files on disk, i.e. when resolution procedure needs the content of 'package.json' // to determine location of bundled typings for node module readFile(fileName: string): string; } - + export interface ResolvedModule { resolvedFileName: string; /* @@ -2294,12 +2316,12 @@ namespace ts { */ isExternalLibraryImport?: boolean; } - + export interface ResolvedModuleWithFailedLookupLocations { resolvedModule: ResolvedModule; failedLookupLocations: string[]; } - + export interface CompilerHost extends ModuleResolutionHost { getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile; getCancellationToken?(): CancellationToken; @@ -2309,7 +2331,7 @@ namespace ts { getCanonicalFileName(fileName: string): string; useCaseSensitiveFileNames(): boolean; getNewLine(): string; - + /* * CompilerHost must either implement resolveModuleNames (in case if it wants to be completely in charge of * module name resolution) or provide implementation for methods from ModuleResolutionHost (in this case compiler @@ -2348,7 +2370,7 @@ namespace ts { // operation caused diagnostics to be returned by storing and comparing the return value // of this method before/after the operation is performed. getModificationCount(): number; - + /* @internal */ reattachFileDiagnostics(newFile: SourceFile): void; } } diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 3397cd242b1..5127b98ab3a 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -65,7 +65,8 @@ namespace ts { increaseIndent: () => { }, decreaseIndent: () => { }, clear: () => str = "", - trackSymbol: () => { } + trackSymbol: () => { }, + reportInaccessibleThisError: () => { } }; } @@ -98,8 +99,8 @@ namespace ts { } return true; - } - + } + export function hasResolvedModule(sourceFile: SourceFile, moduleNameText: string): boolean { return sourceFile.resolvedModules && hasProperty(sourceFile.resolvedModules, moduleNameText); } @@ -468,13 +469,12 @@ namespace ts { else if (node.parent.kind === SyntaxKind.PropertyAccessExpression && (node.parent).name === node) { node = node.parent; } - // fall through - case SyntaxKind.QualifiedName: - case SyntaxKind.PropertyAccessExpression: // At this point, node is either a qualified name or an identifier Debug.assert(node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.PropertyAccessExpression, "'node' was expected to be a qualified name, identifier or property access in 'isTypeNode'."); - + case SyntaxKind.QualifiedName: + case SyntaxKind.PropertyAccessExpression: + case SyntaxKind.ThisKeyword: let parent = node.parent; if (parent.kind === SyntaxKind.TypeQuery) { return false; @@ -621,7 +621,7 @@ namespace ts { return node && (node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression); } - export function isFunctionLike(node: Node): boolean { + export function isFunctionLike(node: Node): node is FunctionLikeDeclaration { if (node) { switch (node.kind) { case SyntaxKind.Constructor: @@ -733,6 +733,9 @@ namespace ts { case SyntaxKind.Constructor: case SyntaxKind.GetAccessor: case SyntaxKind.SetAccessor: + case SyntaxKind.CallSignature: + case SyntaxKind.ConstructSignature: + case SyntaxKind.IndexSignature: case SyntaxKind.EnumDeclaration: case SyntaxKind.SourceFile: return node; @@ -895,7 +898,6 @@ namespace ts { export function isExpression(node: Node): boolean { switch (node.kind) { - case SyntaxKind.ThisKeyword: case SyntaxKind.SuperKeyword: case SyntaxKind.NullKeyword: case SyntaxKind.TrueKeyword: @@ -928,6 +930,7 @@ namespace ts { case SyntaxKind.JsxElement: case SyntaxKind.JsxSelfClosingElement: case SyntaxKind.YieldExpression: + case SyntaxKind.AwaitExpression: return true; case SyntaxKind.QualifiedName: while (node.parent.kind === SyntaxKind.QualifiedName) { @@ -941,6 +944,7 @@ namespace ts { // fall through case SyntaxKind.NumericLiteral: case SyntaxKind.StringLiteral: + case SyntaxKind.ThisKeyword: let parent = node.parent; switch (parent.kind) { case SyntaxKind.VariableDeclaration: @@ -981,6 +985,7 @@ namespace ts { return node === (parent).expression; case SyntaxKind.Decorator: case SyntaxKind.JsxExpression: + case SyntaxKind.JsxSpreadAttribute: return true; case SyntaxKind.ExpressionWithTypeArguments: return (parent).expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent); @@ -993,6 +998,12 @@ namespace ts { return false; } + export function isExternalModuleNameRelative(moduleName: string): boolean { + // TypeScript 1.0 spec (April 2014): 11.2.1 + // An external module name is "relative" if the first term is "." or "..". + return moduleName.substr(0, 2) === "./" || moduleName.substr(0, 3) === "../" || moduleName.substr(0, 2) === ".\\" || moduleName.substr(0, 3) === "..\\"; + } + export function isInstantiatedModule(node: ModuleDeclaration, preserveConstEnums: boolean) { let moduleState = getModuleInstanceState(node); return moduleState === ModuleInstanceState.Instantiated || @@ -1516,12 +1527,12 @@ namespace ts { function getModificationCount() { return modificationCount; } - + function reattachFileDiagnostics(newFile: SourceFile): void { if (!hasProperty(fileDiagnostics, newFile.fileName)) { return; } - + for (let diagnostic of fileDiagnostics[newFile.fileName]) { diagnostic.file = newFile; } diff --git a/src/harness/compilerRunner.ts b/src/harness/compilerRunner.ts index a24ed30ae14..108c6f4518a 100644 --- a/src/harness/compilerRunner.ts +++ b/src/harness/compilerRunner.ts @@ -1,6 +1,7 @@ /// /// /// +/* tslint:disable:no-null */ const enum CompilerTestType { Conformance, @@ -32,7 +33,8 @@ class CompilerBaselineRunner extends RunnerBase { } else if (testType === CompilerTestType.Test262) { this.testSuiteName = "test262"; - } else { + } + else { this.testSuiteName = "compiler"; // default to this for historical reasons } this.basePath += "/" + this.testSuiteName; @@ -82,7 +84,8 @@ class CompilerBaselineRunner extends RunnerBase { otherFiles.push({ unitName: rootDir + unit.name, content: unit.content }); } }); - } else { + } + else { toBeCompiled = units.map(unit => { return { unitName: rootDir + unit.name, content: unit.content }; }); @@ -193,7 +196,8 @@ class CompilerBaselineRunner extends RunnerBase { if (jsCode.length > 0) { return tsCode + "\r\n\r\n" + jsCode; - } else { + } + else { return null; } }); diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts index 1d333a29ccb..3a628bb62c1 100644 --- a/src/harness/fourslash.ts +++ b/src/harness/fourslash.ts @@ -18,8 +18,9 @@ /// /// /// +/* tslint:disable:no-null */ -module FourSlash { +namespace FourSlash { ts.disableIncrementalParsing = false; // Represents a parsed source file with metadata @@ -99,6 +100,8 @@ module FourSlash { end: number; } + export import IndentStyle = ts.IndentStyle; + let entityMap: ts.Map = { "&": "&", "\"": """, @@ -156,7 +159,7 @@ module FourSlash { return true; } - public setCancelled(numberOfCalls: number = 0): void { + public setCancelled(numberOfCalls = 0): void { ts.Debug.assert(numberOfCalls >= 0); this.numberOfCallsBeforeCancellation = numberOfCalls; } @@ -258,7 +261,8 @@ module FourSlash { this.inputFiles[file.fileName] = file.content; if (!startResolveFileRef && file.fileOptions[metadataOptionNames.resolveReference] === "true") { startResolveFileRef = file; - } else if (startResolveFileRef) { + } + else if (startResolveFileRef) { // If entry point for resolving file references is already specified, report duplication error throw new Error("There exists a Fourslash file which has resolveReference flag specified; remove duplicated resolveReference flag"); } @@ -307,6 +311,7 @@ module FourSlash { TabSize: 4, NewLineCharacter: Harness.IO.newLine(), ConvertTabsToSpaces: true, + IndentStyle: ts.IndentStyle.Smart, InsertSpaceAfterCommaDelimiter: true, InsertSpaceAfterSemicolonInForStatements: true, InsertSpaceBeforeAndAfterBinaryOperators: true, @@ -361,7 +366,8 @@ module FourSlash { this.currentCaretPosition = Math.min(this.currentCaretPosition, this.getFileContent(this.activeFile.fileName).length); if (count > 0) { this.scenarioActions.push(``); - } else { + } + else { this.scenarioActions.push(``); } } @@ -436,7 +442,8 @@ module FourSlash { predicate = function (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) { return ((errorMinChar >= startPos) && (errorLimChar >= startPos)) ? true : false; }; - } else { + } + else { predicate = function (errorMinChar: number, errorLimChar: number, startPos: number, endPos: number) { return ((errorMinChar <= startPos) && (errorLimChar <= startPos)) ? true : false; }; @@ -476,7 +483,8 @@ module FourSlash { private printErrorLog(expectErrors: boolean, errors: ts.Diagnostic[]) { if (expectErrors) { Harness.IO.log("Expected error not found. Error list is:"); - } else { + } + else { Harness.IO.log("Unexpected error(s) found. Error list is:"); } @@ -549,10 +557,12 @@ module FourSlash { if (negative) { this.verifyMemberListIsEmpty(false); return; - } else { + } + else { this.scenarioActions.push(""); } - } else { + } + else { this.scenarioActions.push(""); this.scenarioActions.push(``); } @@ -595,14 +605,16 @@ module FourSlash { public verifyMemberListIsEmpty(negative: boolean) { if (negative) { this.scenarioActions.push(""); - } else { + } + else { this.scenarioActions.push(""); } let members = this.getMemberListAtCaret(); if ((!members || members.entries.length === 0) && negative) { this.raiseError("Member list is empty at Caret"); - } else if ((members && members.entries.length !== 0) && !negative) { + } + else if ((members && members.entries.length !== 0) && !negative) { let errorMsg = "\n" + "Member List contains: [" + members.entries[0].name; for (let i = 1; i < members.entries.length; i++) { @@ -639,7 +651,8 @@ module FourSlash { if ((completions && !completions.isNewIdentifierLocation) && !negative) { this.raiseError("Expected builder completion entry"); - } else if ((completions && completions.isNewIdentifierLocation) && negative) { + } + else if ((completions && completions.isNewIdentifierLocation) && negative) { this.raiseError("Un-expected builder completion entry"); } } @@ -751,7 +764,7 @@ module FourSlash { this.raiseError(`verifyReferencesAtPositionListContains failed - could not find the item: ${JSON.stringify(missingItem)} in the returned list: (${JSON.stringify(references)})`); } - public verifyReferencesCountIs(count: number, localFilesOnly: boolean = true) { + public verifyReferencesCountIs(count: number, localFilesOnly = true) { this.taoInvalidReason = "verifyReferences NYI"; let references = this.getReferencesAtCaret(); @@ -832,7 +845,8 @@ module FourSlash { if (expectedDocumentation != undefined) { assert.notEqual(actualQuickInfoDocumentation, expectedDocumentation, this.messageAtLastKnownMarker("quick info doc comment")); } - } else { + } + else { if (expectedText !== undefined) { assert.equal(actualQuickInfoText, expectedText, this.messageAtLastKnownMarker("quick info text")); } @@ -1014,7 +1028,8 @@ module FourSlash { if (!actual) { this.raiseError("Expected signature help to be present, but it wasn't"); } - } else { + } + else { if (actual) { this.raiseError(`Expected no signature help, but got "${JSON.stringify(actual)}"`); } @@ -1371,7 +1386,8 @@ module FourSlash { public type(text: string) { if (text === "") { this.taoInvalidReason = "Test used empty-insert workaround."; - } else { + } + else { this.scenarioActions.push(``); } @@ -1398,7 +1414,8 @@ module FourSlash { if (ch === "(" || ch === ",") { /* Signature help*/ this.languageService.getSignatureHelpItems(this.activeFile.fileName, offset); - } else if (prevChar === " " && /A-Za-z_/.test(ch)) { + } + else if (prevChar === " " && /A-Za-z_/.test(ch)) { /* Completions */ this.languageService.getCompletionsAtPosition(this.activeFile.fileName, offset); } @@ -1547,7 +1564,8 @@ module FourSlash { if (marker.position < limChar) { // Marker is inside the edit - mark it as invalidated (?) marker.position = -1; - } else { + } + else { // Move marker back/forward by the appropriate amount marker.position += (minChar - limChar) + text.length; } @@ -1568,7 +1586,8 @@ module FourSlash { public goToDefinition(definitionIndex: number) { if (definitionIndex === 0) { this.scenarioActions.push(""); - } else { + } + else { this.taoInvalidReason = "GoToDefinition not supported for non-zero definition indices"; } @@ -1650,7 +1669,8 @@ module FourSlash { if (negative) { assert.notEqual(actualDefinitionName, expectedName, this.messageAtLastKnownMarker("Definition Info Name")); assert.notEqual(actualDefinitionContainerName, expectedContainerName, this.messageAtLastKnownMarker("Definition Info Container Name")); - } else { + } + else { assert.equal(actualDefinitionName, expectedName, this.messageAtLastKnownMarker("Definition Info Name")); assert.equal(actualDefinitionContainerName, expectedContainerName, this.messageAtLastKnownMarker("Definition Info Container Name")); } @@ -1678,24 +1698,28 @@ module FourSlash { } } - private getIndentation(fileName: string, position: number): number { - return this.languageService.getIndentationAtPosition(fileName, position, this.formatCodeOptions); + private getIndentation(fileName: string, position: number, indentStyle: ts.IndentStyle): number { + + let formatOptions = ts.clone(this.formatCodeOptions); + formatOptions.IndentStyle = indentStyle; + + return this.languageService.getIndentationAtPosition(fileName, position, formatOptions); } - public verifyIndentationAtCurrentPosition(numberOfSpaces: number) { + public verifyIndentationAtCurrentPosition(numberOfSpaces: number, indentStyle: ts.IndentStyle = ts.IndentStyle.Smart) { this.taoInvalidReason = "verifyIndentationAtCurrentPosition NYI"; - let actual = this.getIndentation(this.activeFile.fileName, this.currentCaretPosition); + let actual = this.getIndentation(this.activeFile.fileName, this.currentCaretPosition, indentStyle); let lineCol = this.getLineColStringAtPosition(this.currentCaretPosition); if (actual !== numberOfSpaces) { this.raiseError(`verifyIndentationAtCurrentPosition failed at ${lineCol} - expected: ${numberOfSpaces}, actual: ${actual}`); } } - public verifyIndentationAtPosition(fileName: string, position: number, numberOfSpaces: number) { + public verifyIndentationAtPosition(fileName: string, position: number, numberOfSpaces: number, indentStyle: ts.IndentStyle = ts.IndentStyle.Smart) { this.taoInvalidReason = "verifyIndentationAtPosition NYI"; - let actual = this.getIndentation(fileName, position); + let actual = this.getIndentation(fileName, position, indentStyle); let lineCol = this.getLineColStringAtPosition(position); if (actual !== numberOfSpaces) { this.raiseError(`verifyIndentationAtPosition failed at ${lineCol} - expected: ${numberOfSpaces}, actual: ${actual}`); @@ -1897,26 +1921,33 @@ module FourSlash { if (expected === undefined) { if (actual) { - this.raiseError(name + ' failed - expected no template but got {newText: \"' + actual.newText + '\" caretOffset: ' + actual.caretOffset + '}'); + this.raiseError(name + " failed - expected no template but got {newText: \"" + actual.newText + "\" caretOffset: " + actual.caretOffset + "}"); } return; } else { if (actual === undefined) { - this.raiseError(name + ' failed - expected the template {newText: \"' + actual.newText + '\" caretOffset: ' + actual.caretOffset + '} but got nothing instead'); + this.raiseError(name + " failed - expected the template {newText: \"" + actual.newText + "\" caretOffset: " + actual.caretOffset + "} but got nothing instead"); } if (actual.newText !== expected.newText) { - this.raiseError(name + ' failed - expected insertion:\n' + expected.newText + '\nactual insertion:\n' + actual.newText); + this.raiseError(name + " failed - expected insertion:\n" + this.clarifyNewlines(expected.newText) + "\nactual insertion:\n" + this.clarifyNewlines(actual.newText)); } if (actual.caretOffset !== expected.caretOffset) { - this.raiseError(name + ' failed - expected caretOffset: ' + expected.caretOffset + ',\nactual caretOffset:' + actual.caretOffset); + this.raiseError(name + " failed - expected caretOffset: " + expected.caretOffset + ",\nactual caretOffset:" + actual.caretOffset); } } } + private clarifyNewlines(str: string) { + return str.replace(/\r?\n/g, lineEnding => { + const representation = lineEnding === "\r\n" ? "CRLF" : "LF"; + return "# - " + representation + lineEnding; + }); + } + public verifyMatchingBracePosition(bracePosition: number, expectedMatchPosition: number) { this.taoInvalidReason = "verifyMatchingBracePosition NYI"; @@ -1929,9 +1960,11 @@ module FourSlash { let actualMatchPosition = -1; if (bracePosition === actual[0].start) { actualMatchPosition = actual[1].start; - } else if (bracePosition === actual[1].start) { + } + else if (bracePosition === actual[1].start) { actualMatchPosition = actual[0].start; - } else { + } + else { this.raiseError(`verifyMatchingBracePosition failed - could not find the brace position: ${bracePosition} in the returned list: (${actual[0].start},${ts.textSpanEnd(actual[0])}) and (${actual[1].start},${ts.textSpanEnd(actual[1])})`); } @@ -2101,7 +2134,7 @@ module FourSlash { let occurrences = this.getOccurrencesAtCurrentPosition(); if (!occurrences || occurrences.length === 0) { - this.raiseError('verifyOccurrencesAtPositionListContains failed - found 0 references, expected at least one.'); + this.raiseError("verifyOccurrencesAtPositionListContains failed - found 0 references, expected at least one."); } for (let occurrence of occurrences) { @@ -2133,12 +2166,12 @@ module FourSlash { } public verifyDocumentHighlightsAtPositionListContains(fileName: string, start: number, end: number, fileNamesToSearch: string[], kind?: string) { - this.taoInvalidReason = 'verifyDocumentHighlightsAtPositionListContains NYI'; + this.taoInvalidReason = "verifyDocumentHighlightsAtPositionListContains NYI"; let documentHighlights = this.getDocumentHighlightsAtCurrentPosition(fileNamesToSearch); if (!documentHighlights || documentHighlights.length === 0) { - this.raiseError('verifyDocumentHighlightsAtPositionListContains failed - found 0 highlights, expected at least one.'); + this.raiseError("verifyDocumentHighlightsAtPositionListContains failed - found 0 highlights, expected at least one."); } for (let documentHighlight of documentHighlights) { @@ -2161,15 +2194,15 @@ module FourSlash { } public verifyDocumentHighlightsAtPositionListCount(expectedCount: number, fileNamesToSearch: string[]) { - this.taoInvalidReason = 'verifyDocumentHighlightsAtPositionListCount NYI'; + this.taoInvalidReason = "verifyDocumentHighlightsAtPositionListCount NYI"; let documentHighlights = this.getDocumentHighlightsAtCurrentPosition(fileNamesToSearch); - let actualCount = documentHighlights - ? documentHighlights.reduce((currentCount, { highlightSpans }) => currentCount + highlightSpans.length, 0) + let actualCount = documentHighlights + ? documentHighlights.reduce((currentCount, { highlightSpans }) => currentCount + highlightSpans.length, 0) : 0; if (expectedCount !== actualCount) { - this.raiseError('verifyDocumentHighlightsAtPositionListCount failed - actual: ' + actualCount + ', expected:' + expectedCount); + this.raiseError("verifyDocumentHighlightsAtPositionListCount failed - actual: " + actualCount + ", expected:" + expectedCount); } } @@ -2243,10 +2276,12 @@ module FourSlash { let index = indexOrName; if (index >= this.testData.files.length) { throw new Error(`File index (${index}) in openFile was out of range. There are only ${this.testData.files.length} files in this test.`); - } else { + } + else { result = this.testData.files[index]; } - } else if (typeof indexOrName === "string") { + } + else if (typeof indexOrName === "string") { let name = indexOrName; // names are stored in the compiler with this relative path, this allows people to use goTo.file on just the fileName @@ -2269,7 +2304,8 @@ module FourSlash { if (!foundIt) { throw new Error(`No test file named "${name}" exists. Available file names are: ${availableNames.join(", ")}`); } - } else { + } + else { throw new Error("Unknown argument type"); } @@ -2287,7 +2323,8 @@ module FourSlash { let markerNames: string[] = []; for (let m in this.testData.markerPositions) markerNames.push(m); throw new Error(`Unknown marker "${markerName}" Available markers: ${markerNames.map(m => "\"" + m + "\"").join(", ")}`); - } else { + } + else { return markerPos; } } @@ -2432,13 +2469,15 @@ module FourSlash { // Append to the current subfile content, inserting a newline needed if (currentFileContent === null) { currentFileContent = ""; - } else { + } + else { // End-of-line currentFileContent = currentFileContent + "\n"; } currentFileContent = currentFileContent + line.substr(4); - } else if (line.substr(0, 2) === "//") { + } + else if (line.substr(0, 2) === "//") { // Comment line, check for global/file @options and record them let match = optionRegex.exec(line.substr(2)); if (match) { @@ -2468,17 +2507,20 @@ module FourSlash { currentFileName = basePath + "/" + match[2]; currentFileOptions[match[1]] = match[2]; - } else { + } + else { // Add other fileMetadata flag currentFileOptions[match[1]] = match[2]; } } } // TODO: should be '==='? - } else if (line == "" || lineLength === 0) { + } + else if (line == "" || lineLength === 0) { // Previously blank lines between fourslash content caused it to be considered as 2 files, // Remove this behavior since it just causes errors now - } else { + } + else { // Empty line or code line, terminate current subfile if there is one if (currentFileContent) { let file = parseFileContent(currentFileContent, currentFileName, markerPositions, markers, ranges); @@ -2548,7 +2590,8 @@ module FourSlash { try { // Attempt to parse the marker value as JSON markerValue = JSON.parse("{ " + text + " }"); - } catch (e) { + } + catch (e) { reportError(fileName, location.sourceLine, location.sourceColumn, "Unable to parse marker text " + e.message); } @@ -2584,7 +2627,8 @@ module FourSlash { let message = "Marker '" + name + "' is duplicated in the source file contents."; reportError(marker.fileName, location.sourceLine, location.sourceColumn, message); return null; - } else { + } + else { markerMap[name] = marker; markers.push(marker); return marker; @@ -2598,7 +2642,7 @@ module FourSlash { let validMarkerChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz$1234567890_"; /// The file content (minus metacharacters) so far - let output: string = ""; + let output = ""; /// The current marker (or maybe multi-line comment?) we're parsing, possibly let openMarker: ILocationInformation = null; @@ -2610,22 +2654,23 @@ module FourSlash { let localRanges: Range[] = []; /// The latest position of the start of an unflushed plain text area - let lastNormalCharPosition: number = 0; + let lastNormalCharPosition = 0; /// The total number of metacharacters removed from the file (so far) - let difference: number = 0; + let difference = 0; /// The fourslash file state object we are generating let state: State = State.none; /// Current position data - let line: number = 1; - let column: number = 1; + let line = 1; + let column = 1; let flush = (lastSafeCharIndex: number) => { if (lastSafeCharIndex === undefined) { output = output + content.substr(lastNormalCharPosition); - } else { + } + else { output = output + content.substr(lastNormalCharPosition, lastSafeCharIndex - lastNormalCharPosition); } }; @@ -2648,7 +2693,8 @@ module FourSlash { flush(i - 1); lastNormalCharPosition = i + 1; difference += 2; - } else if (previousChar === "|" && currentChar === "]") { + } + else if (previousChar === "|" && currentChar === "]") { // found a range end let rangeStart = openRanges.pop(); if (!rangeStart) { @@ -2667,7 +2713,8 @@ module FourSlash { flush(i - 1); lastNormalCharPosition = i + 1; difference += 2; - } else if (previousChar === "/" && currentChar === "*") { + } + else if (previousChar === "/" && currentChar === "*") { // found a possible marker start state = State.inSlashStarMarker; openMarker = { @@ -2676,7 +2723,8 @@ module FourSlash { sourceLine: line, sourceColumn: column, }; - } else if (previousChar === "{" && currentChar === "|") { + } + else if (previousChar === "{" && currentChar === "|") { // found an object marker start state = State.inObjectMarker; openMarker = { @@ -2729,10 +2777,12 @@ module FourSlash { // Reset the state openMarker = null; state = State.none; - } else if (validMarkerChars.indexOf(currentChar) < 0) { + } + else if (validMarkerChars.indexOf(currentChar) < 0) { if (currentChar === "*" && i < content.length - 1 && content.charAt(i + 1) === "/") { // The marker is about to be closed, ignore the 'invalid' char - } else { + } + else { // We've hit a non-valid marker character, so we were actually in a block comment // Bail out the text we've gathered so far back into the output flush(i); @@ -2748,7 +2798,8 @@ module FourSlash { if (currentChar === "\n" && previousChar === "\r") { // Ignore trailing \n after a \r continue; - } else if (currentChar === "\n" || currentChar === "\r") { + } + else if (currentChar === "\n" || currentChar === "\r") { line++; column = 1; continue; diff --git a/src/harness/fourslashRunner.ts b/src/harness/fourslashRunner.ts index d30a30d88e3..867c0d5a4d6 100644 --- a/src/harness/fourslashRunner.ts +++ b/src/harness/fourslashRunner.ts @@ -1,6 +1,7 @@ /// /// /// +/* tslint:disable:no-null */ const enum FourSlashTestType { Native, @@ -25,8 +26,8 @@ class FourSlashRunner extends RunnerBase { this.testSuiteName = "fourslash-shims"; break; case FourSlashTestType.ShimsWithPreprocess: - this.basePath = 'tests/cases/fourslash/shims-pp'; - this.testSuiteName = 'fourslash-shims-pp'; + this.basePath = "tests/cases/fourslash/shims-pp"; + this.testSuiteName = "fourslash-shims-pp"; break; case FourSlashTestType.Server: this.basePath = "tests/cases/fourslash/server"; @@ -87,7 +88,8 @@ class FourSlashRunner extends RunnerBase { FourSlash.xmlData.forEach(xml => { if (xml.invalidReason !== null) { lines.push(""); - } else { + } + else { lines.push(" "); xml.actions.forEach(action => { lines.push(" " + action); diff --git a/src/harness/harness.ts b/src/harness/harness.ts index 57eb848ac23..a37b647a124 100644 --- a/src/harness/harness.ts +++ b/src/harness/harness.ts @@ -23,6 +23,7 @@ /// /// /// +/* tslint:disable:no-null */ // Block scoped definitions work poorly for global variables, temporarily enable var /* tslint:disable:no-var-keyword */ @@ -35,7 +36,7 @@ declare var __dirname: string; // Node-specific var global = Function("return this").call(null); /* tslint:enable:no-var-keyword */ -module Utils { +namespace Utils { // Setup some globals based on the current environment export const enum ExecutionEnvironment { Node, @@ -54,17 +55,17 @@ module Utils { return ExecutionEnvironment.Node; } } - + export let currentExecutionEnvironment = getExecutionEnvironment(); - const Buffer: BufferConstructor = currentExecutionEnvironment !== ExecutionEnvironment.Browser - ? require("buffer").Buffer + const Buffer: BufferConstructor = currentExecutionEnvironment !== ExecutionEnvironment.Browser + ? require("buffer").Buffer : undefined; export function encodeString(s: string): string { return Buffer ? (new Buffer(s)).toString("utf8") : s; } - + export function evalFile(fileContents: string, fileName: string, nodeContext?: any) { let environment = getExecutionEnvironment(); switch (environment) { @@ -76,7 +77,8 @@ module Utils { let vm = require("vm"); if (nodeContext) { vm.runInNewContext(fileContents, nodeContext, fileName); - } else { + } + else { vm.runInThisContext(fileContents, fileName); } break; @@ -126,7 +128,8 @@ module Utils { let cachedResult = cache[key]; if (cachedResult) { return cachedResult; - } else { + } + else { return cache[key] = f.apply(this, arguments); } }); @@ -396,7 +399,7 @@ module Utils { } } -module Harness.Path { +namespace Harness.Path { export function getFileName(fullPath: string) { return fullPath.replace(/^.*[\\\/]/, ""); } @@ -409,7 +412,7 @@ module Harness.Path { } } -module Harness { +namespace Harness { export interface IO { newLine(): string; getCurrentDirectory(): string; @@ -431,11 +434,11 @@ module Harness { readDirectory(path: string, extension?: string, exclude?: string[]): string[]; } export var IO: IO; - + // harness always uses one kind of new line const harnessNewLine = "\r\n"; - - module IOImpl { + + namespace IOImpl { declare class Enumerator { public atEnd(): boolean; public moveNext(): boolean; @@ -443,14 +446,15 @@ module Harness { constructor(o: any); } - export module CScript { + export namespace CScript { let fso: any; if (global.ActiveXObject) { fso = new global.ActiveXObject("Scripting.FileSystemObject"); - } else { + } + else { fso = {}; } - + export const args = () => ts.sys.args; export const getExecutingFilePath = () => ts.sys.getExecutingFilePath(); export const exit = (exitCode: number) => ts.sys.exit(exitCode); @@ -511,16 +515,17 @@ module Harness { }; } - export module Node { + export namespace Node { declare let require: any; let fs: any, pathModule: any; if (require) { fs = require("fs"); pathModule = require("path"); - } else { + } + else { fs = pathModule = {}; } - + export const resolvePath = (path: string) => ts.sys.resolvePath(path); export const getCurrentDirectory = () => ts.sys.getCurrentDirectory(); export const newLine = () => harnessNewLine; @@ -545,7 +550,8 @@ module Harness { export function deleteFile(path: string) { try { fs.unlinkSync(path); - } catch (e) { + } + catch (e) { } } @@ -559,7 +565,8 @@ module Harness { // Node will just continue to repeat the root path, rather than return null if (dirPath === path) { dirPath = null; - } else { + } + else { return dirPath; } } @@ -596,7 +603,7 @@ module Harness { }; } - export module Network { + export namespace Network { let serverRoot = "http://localhost:8888/"; export const newLine = () => harnessNewLine; @@ -605,10 +612,11 @@ module Harness { export const args = () => []; export const getExecutingFilePath = () => ""; export const exit = (exitCode: number) => {}; - - let supportsCodePage = () => false; - module Http { + let supportsCodePage = () => false; + export let log = (s: string) => console.log(s); + + namespace Http { function waitForXHR(xhr: XMLHttpRequest) { while (xhr.readyState !== 4) { } return { status: xhr.status, responseText: xhr.responseText }; @@ -683,10 +691,12 @@ module Harness { if (dirPath.match(/localhost:\d+$/) || dirPath.match(/localhost:\d+\/$/)) { dirPath = null; // path + fileName - } else if (dirPath.indexOf(".") === -1) { + } + else if (dirPath.indexOf(".") === -1) { dirPath = dirPath.substring(0, dirPath.lastIndexOf("/")); // path - } else { + } + else { // strip any trailing slash if (dirPath.match(/.*\/$/)) { dirPath = dirPath.substring(0, dirPath.length - 2); @@ -710,7 +720,8 @@ module Harness { let results = response.responseText.split(","); if (spec) { return results.filter(file => spec.test(file)); - } else { + } + else { return results; } } @@ -720,13 +731,12 @@ module Harness { }; export let listFiles = Utils.memoize(_listFilesImpl); - export let log = (s: string) => console.log(s); - export function readFile(file: string) { let response = Http.getFileFromServerSync(serverRoot + file); if (response.status === 200) { return response.responseText; - } else { + } + else { return null; } } @@ -754,7 +764,7 @@ module Harness { } } -module Harness { +namespace Harness { let tcServicesFileName = "typescriptServices.js"; export let libFolder: string; @@ -785,7 +795,7 @@ module Harness { export let lightMode = false; /** Functionality for compiling TypeScript code */ - export module Compiler { + export namespace Compiler { /** Aggregate various writes into a single array of lines. Useful for passing to the * TypeScript compiler to fill with source code or errors. */ @@ -864,7 +874,7 @@ module Harness { languageVersion: ts.ScriptTarget) { // We'll only assert inletiants outside of light mode. const shouldAssertInvariants = !Harness.lightMode; - + // Only set the parent nodes if we're asserting inletiants. We don't need them otherwise. let result = ts.createSourceFile(fileName, sourceText, languageVersion, /*setParentNodes:*/ shouldAssertInvariants); @@ -1102,7 +1112,7 @@ module Harness { } let useCaseSensitiveFileNames = options.useCaseSensitiveFileNames !== undefined ? options.useCaseSensitiveFileNames : Harness.IO.useCaseSensitiveFileNames(); - + let fileOutputs: GeneratedFile[] = []; let programFiles = inputFiles.concat(includeBuiltFiles).map(file => file.unitName); @@ -1231,12 +1241,12 @@ module Harness { .filter(s => s.length > 0) .map(s => "!!! " + ts.DiagnosticCategory[error.category].toLowerCase() + " TS" + error.code + ": " + s); errLines.forEach(e => outputLines.push(e)); - + // do not count errors from lib.d.ts here, they are computed separately as numLibraryDiagnostics // if lib.d.ts is explicitly included in input files and there are some errors in it (i.e. because of duplicate identifiers) // then they will be added twice thus triggering 'total errors' assertion with condition // 'totalErrorsReportedInNonLibraryFiles + numLibraryDiagnostics + numTest262HarnessDiagnostics, diagnostics.length - + if (!error.file || !isLibraryFile(error.file.fileName)) { totalErrorsReportedInNonLibraryFiles++; } @@ -1280,7 +1290,8 @@ module Harness { // On the last line of the file, fake the next line start number so that we handle errors on the last character of the file correctly if (lineIndex === lines.length - 1) { nextLineStart = inputFile.content.length; - } else { + } + else { nextLineStart = lineStarts[lineIndex + 1]; } // Emit this line from the original file @@ -1344,7 +1355,7 @@ module Harness { // FileName header + content result += "/*====== " + outputFile.fileName + " ======*/\r\n"; - + result += outputFile.code; } @@ -1444,7 +1455,7 @@ module Harness { } } - export module TestCaseParser { + export namespace TestCaseParser { /** all the necessary information to set the right compiler settings */ export interface CompilerSettings { [name: string]: string; @@ -1497,7 +1508,8 @@ module Harness { let metaDataName = testMetaData[1].toLowerCase(); if (metaDataName === "filename") { currentFileOptions[testMetaData[1]] = testMetaData[2]; - } else { + } + else { continue; } @@ -1518,16 +1530,19 @@ module Harness { currentFileOptions = {}; currentFileName = testMetaData[2]; refs = []; - } else { + } + else { // First metadata marker in the file currentFileName = testMetaData[2]; } - } else { + } + else { // Subfile content line // Append to the current subfile content, inserting a newline needed if (currentFileContent === null) { currentFileContent = ""; - } else { + } + else { // End-of-line currentFileContent = currentFileContent + "\n"; } @@ -1553,7 +1568,7 @@ module Harness { } /** Support class for baseline files */ - export module Baseline { + export namespace Baseline { export interface BaselineOptions { Subfolder?: string; @@ -1581,7 +1596,8 @@ module Harness { function baselinePath(fileName: string, type: string, baselineFolder: string, subfolder?: string) { if (subfolder !== undefined) { return Harness.userSpecifiedRoot + baselineFolder + "/" + subfolder + "/" + type + "/" + fileName; - } else { + } + else { return Harness.userSpecifiedRoot + baselineFolder + "/" + type + "/" + fileName; } } @@ -1673,7 +1689,8 @@ module Harness { actual = generateActual(actualFileName, generateContent); let comparison = compareToBaseline(actual, relativeFileName, opts); writeComparison(comparison.expected, comparison.actual, relativeFileName, actualFileName, descriptionForDescribe); - } else { + } + else { actual = generateActual(actualFileName, generateContent); let comparison = compareToBaseline(actual, relativeFileName, opts); diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts index c97ce50d275..dfde2bd1c08 100644 --- a/src/harness/harnessLanguageService.ts +++ b/src/harness/harnessLanguageService.ts @@ -3,11 +3,11 @@ /// /// -module Harness.LanguageService { +namespace Harness.LanguageService { export class ScriptInfo { public version: number = 1; public editRanges: { length: number; textChangeRange: ts.TextChangeRange; }[] = []; - public lineMap: number[] = null; + public lineMap: number[] = undefined; constructor(public fileName: string, public content: string) { this.setContent(content); @@ -95,8 +95,8 @@ module Harness.LanguageService { let oldShim = oldScript; let range = this.scriptSnapshot.getChangeRange(oldShim.scriptSnapshot); - if (range === null) { - return null; + if (range === undefined) { + return undefined; } return JSON.stringify({ span: { start: range.span.start, length: range.span.length }, newLength: range.newLength }); @@ -118,11 +118,11 @@ module Harness.LanguageService { getPreProcessedFileInfo(fileName: string, fileContents: string): ts.PreProcessedFileInfo; } - export class LanguageServiceAdapterHost { + export class LanguageServiceAdapterHost { protected fileNameToScript: ts.Map = {}; - + constructor(protected cancellationToken = DefaultHostCancellationToken.Instance, - protected settings = ts.getDefaultCompilerOptions()) { + protected settings = ts.getDefaultCompilerOptions()) { } public getNewLine(): string { @@ -145,7 +145,7 @@ module Harness.LanguageService { public editScript(fileName: string, start: number, end: number, newText: string) { let script = this.getScriptInfo(fileName); - if (script !== null) { + if (script !== undefined) { script.editContent(start, end, newText); return; } @@ -169,7 +169,7 @@ module Harness.LanguageService { } /// Native adapter - class NativeLanguageServiceHost extends LanguageServiceAdapterHost implements ts.LanguageServiceHost { + class NativeLanguageServiceHost extends LanguageServiceAdapterHost implements ts.LanguageServiceHost { getCompilationSettings() { return this.settings; } getCancellationToken() { return this.cancellationToken; } getCurrentDirectory(): string { return ""; } @@ -191,7 +191,7 @@ module Harness.LanguageService { export class NativeLanugageServiceAdapter implements LanguageServiceAdapter { private host: NativeLanguageServiceHost; - constructor(cancellationToken?: ts.HostCancellationToken, options?: ts.CompilerOptions) { + constructor(cancellationToken?: ts.HostCancellationToken, options?: ts.CompilerOptions) { this.host = new NativeLanguageServiceHost(cancellationToken, options); } getHost() { return this.host; } @@ -204,14 +204,14 @@ module Harness.LanguageService { class ShimLanguageServiceHost extends LanguageServiceAdapterHost implements ts.LanguageServiceShimHost, ts.CoreServicesShimHost { private nativeHost: NativeLanguageServiceHost; - public getModuleResolutionsForFile: (fileName: string)=> string; + public getModuleResolutionsForFile: (fileName: string) => string; constructor(preprocessToResolve: boolean, cancellationToken?: ts.HostCancellationToken, options?: ts.CompilerOptions) { super(cancellationToken, options); this.nativeHost = new NativeLanguageServiceHost(cancellationToken, options); if (preprocessToResolve) { - let compilerOptions = this.nativeHost.getCompilationSettings() + let compilerOptions = this.nativeHost.getCompilationSettings(); let moduleResolutionHost: ts.ModuleResolutionHost = { fileExists: fileName => this.getScriptInfo(fileName) !== undefined, readFile: fileName => { @@ -230,7 +230,7 @@ module Harness.LanguageService { } } return JSON.stringify(imports); - } + }; } } @@ -247,7 +247,7 @@ module Harness.LanguageService { getScriptFileNames(): string { return JSON.stringify(this.nativeHost.getScriptFileNames()); } getScriptSnapshot(fileName: string): ts.ScriptSnapshotShim { let nativeScriptSnapshot = this.nativeHost.getScriptSnapshot(fileName); - return nativeScriptSnapshot && new ScriptSnapshotProxy(nativeScriptSnapshot); + return nativeScriptSnapshot && new ScriptSnapshotProxy(nativeScriptSnapshot); } getScriptVersion(fileName: string): string { return this.nativeHost.getScriptVersion(fileName); } getLocalizedDiagnosticMessages(): string { return JSON.stringify({}); } @@ -255,17 +255,17 @@ module Harness.LanguageService { readDirectory(rootDir: string, extension: string): string { throw new Error("NYI"); } - fileExists(fileName: string) { return this.getScriptInfo(fileName) !== undefined; } - readFile(fileName: string) { + fileExists(fileName: string) { return this.getScriptInfo(fileName) !== undefined; } + readFile(fileName: string) { let snapshot = this.nativeHost.getScriptSnapshot(fileName); return snapshot && snapshot.getText(0, snapshot.getLength()); - } + } log(s: string): void { this.nativeHost.log(s); } trace(s: string): void { this.nativeHost.trace(s); } error(s: string): void { this.nativeHost.error(s); } } - class ClassifierShimProxy implements ts.Classifier { + class ClassifierShimProxy implements ts.Classifier { constructor(private shim: ts.ClassifierShim) { } getEncodedLexicalClassifications(text: string, lexState: ts.EndOfLineState, classifyKeywordsInGenerics?: boolean): ts.Classifications { @@ -302,7 +302,7 @@ module Harness.LanguageService { if (parsedResult.error) { throw new Error("Language Service Shim Error: " + JSON.stringify(parsedResult.error)); } - else if (parsedResult.canceled) { + else if (parsedResult.canceled) { throw new ts.OperationCanceledException(); } return parsedResult.result; @@ -369,7 +369,7 @@ module Harness.LanguageService { getDefinitionAtPosition(fileName: string, position: number): ts.DefinitionInfo[] { return unwrapJSONCallResult(this.shim.getDefinitionAtPosition(fileName, position)); } - getTypeDefinitionAtPosition(fileName: string, position: number): ts.DefinitionInfo[]{ + getTypeDefinitionAtPosition(fileName: string, position: number): ts.DefinitionInfo[] { return unwrapJSONCallResult(this.shim.getTypeDefinitionAtPosition(fileName, position)); } getReferencesAtPosition(fileName: string, position: number): ts.ReferenceEntry[] { @@ -474,19 +474,19 @@ module Harness.LanguageService { } // Server adapter - class SessionClientHost extends NativeLanguageServiceHost implements ts.server.SessionClientHost { + class SessionClientHost extends NativeLanguageServiceHost implements ts.server.SessionClientHost { private client: ts.server.SessionClient; constructor(cancellationToken: ts.HostCancellationToken, settings: ts.CompilerOptions) { super(cancellationToken, settings); } - onMessage(message: string): void { - + onMessage(message: string): void { + } - writeMessage(message: string): void { - + writeMessage(message: string): void { + } setClient(client: ts.server.SessionClient) { @@ -504,7 +504,7 @@ module Harness.LanguageService { } } - class SessionServerHost implements ts.server.ServerHost, ts.server.Logger { + class SessionServerHost implements ts.server.ServerHost, ts.server.Logger { args: string[] = []; newLine: string; useCaseSensitiveFileNames: boolean = false; @@ -513,23 +513,23 @@ module Harness.LanguageService { this.newLine = this.host.getNewLine(); } - onMessage(message: string): void { - + onMessage(message: string): void { + } writeMessage(message: string): void { } - write(message: string): void { + write(message: string): void { this.writeMessage(message); } readFile(fileName: string): string { - if (fileName.indexOf(Harness.Compiler.defaultLibFileName) >= 0) { + if (fileName.indexOf(Harness.Compiler.defaultLibFileName) >= 0) { fileName = Harness.Compiler.defaultLibFileName; } - + let snapshot = this.host.getScriptSnapshot(fileName); return snapshot && snapshot.getText(0, snapshot.getLength()); } @@ -567,8 +567,8 @@ module Harness.LanguageService { readDirectory(path: string, extension?: string): string[] { throw new Error("Not implemented Yet."); } - - watchFile(fileName: string, callback: (fileName: string) => void): ts.FileWatcher { + + watchFile(fileName: string, callback: (fileName: string) => void): ts.FileWatcher { return { close() { } }; } @@ -582,7 +582,7 @@ module Harness.LanguageService { msg(message: string) { return this.host.log(message); } - + loggingEnabled() { return true; } @@ -602,7 +602,7 @@ module Harness.LanguageService { startGroup(): void { } } - + export class ServerLanugageServiceAdapter implements LanguageServiceAdapter { private host: SessionClientHost; private client: ts.server.SessionClient; diff --git a/src/harness/loggedIO.ts b/src/harness/loggedIO.ts index d0801612500..d60756edf19 100644 --- a/src/harness/loggedIO.ts +++ b/src/harness/loggedIO.ts @@ -1,6 +1,7 @@ /// /// /// +/* tslint:disable:no-null */ interface FileInformation { contents: string; @@ -76,7 +77,7 @@ interface PlaybackControl { endRecord(): void; } -module Playback { +namespace Playback { let recordLog: IOLog = undefined; let replayLog: IOLog = undefined; let recordLogFileNameBase = ""; @@ -95,7 +96,7 @@ module Playback { run.reset = () => { lookup = null; }; - + return run; } diff --git a/src/harness/projectsRunner.ts b/src/harness/projectsRunner.ts index fe4ab8ea8ea..862e446352d 100644 --- a/src/harness/projectsRunner.ts +++ b/src/harness/projectsRunner.ts @@ -1,5 +1,6 @@ /// /// +/* tslint:disable:no-null */ // Test case is json of below type in tests/cases/project/ interface ProjectRunnerTestCase { @@ -199,7 +200,7 @@ class ProjectRunner extends RunnerBase { } } - function batchCompilerProjectTestCase(moduleKind: ts.ModuleKind): BatchCompileProjectTestCaseResult{ + function batchCompilerProjectTestCase(moduleKind: ts.ModuleKind): BatchCompileProjectTestCaseResult { let nonSubfolderDiskFiles = 0; let outputFiles: BatchCompileProjectTestCaseEmittedFile[] = []; @@ -300,7 +301,7 @@ class ProjectRunner extends RunnerBase { allInputFiles.unshift(findOutpuDtsFile(outputDtsFileName)); } else { - let outputDtsFileName = ts.removeFileExtension(compilerOptions.outFile|| compilerOptions.out) + ".d.ts"; + let outputDtsFileName = ts.removeFileExtension(compilerOptions.outFile || compilerOptions.out) + ".d.ts"; let outputDtsFile = findOutpuDtsFile(outputDtsFileName); if (!ts.contains(allInputFiles, outputDtsFile)) { allInputFiles.unshift(outputDtsFile); diff --git a/src/harness/runner.ts b/src/harness/runner.ts index 822fcdebe8c..366355520a2 100644 --- a/src/harness/runner.ts +++ b/src/harness/runner.ts @@ -20,8 +20,10 @@ /// /// +/* tslint:disable:no-null */ + let runners: RunnerBase[] = []; -let iterations: number = 1; +let iterations = 1; function runTests(runners: RunnerBase[]) { for (let i = iterations; i > 0; i--) { @@ -68,10 +70,10 @@ if (testConfigFile !== "") { case "fourslash-shims": runners.push(new FourSlashRunner(FourSlashTestType.Shims)); break; - case 'fourslash-shims-pp': + case "fourslash-shims-pp": runners.push(new FourSlashRunner(FourSlashTestType.ShimsWithPreprocess)); break; - case 'fourslash-server': + case "fourslash-server": runners.push(new FourSlashRunner(FourSlashTestType.Server)); break; case "fourslash-generated": diff --git a/src/harness/runnerbase.ts b/src/harness/runnerbase.ts index afe757ea829..7469325475a 100644 --- a/src/harness/runnerbase.ts +++ b/src/harness/runnerbase.ts @@ -25,12 +25,12 @@ abstract class RunnerBase { let fixedPath = path; // full paths either start with a drive letter or / for *nix, shouldn't have \ in the path at this point - let fullPath = /(\w+:|\/)?([\w+\-\.]|\/)*\.tsx?/g; + let fullPath = /(\w+:|\/)?([\w+\-\.]|\/)*\.tsx?/g; let fullPathList = fixedPath.match(fullPath); if (fullPathList) { fullPathList.forEach((match: string) => fixedPath = fixedPath.replace(match, Harness.Path.getFileName(match))); } - + // when running in the browser the 'full path' is the host name, shows up in error baselines let localHost = /http:\/localhost:\d+/g; fixedPath = fixedPath.replace(localHost, ""); diff --git a/src/harness/rwcRunner.ts b/src/harness/rwcRunner.ts index 1e81392049d..3027afae9dc 100644 --- a/src/harness/rwcRunner.ts +++ b/src/harness/rwcRunner.ts @@ -2,8 +2,9 @@ /// /// /// +/* tslint:disable:no-null */ -module RWC { +namespace RWC { function runWithIOLog(ioLog: IOLog, fn: (oldIO: Harness.IO) => void) { let oldIO = Harness.IO; @@ -105,7 +106,7 @@ module RWC { } otherFiles.push(getHarnessCompilerInputUnit(fileRead.path)); } - else if (!opts.options.noLib && Harness.isLibraryFile(fileRead.path)){ + else if (!opts.options.noLib && Harness.isLibraryFile(fileRead.path)) { if (!inInputList) { // If useCustomLibraryFile is true, we will use lib.d.ts from json object // otherwise use the lib.d.ts from built/local diff --git a/src/harness/sourceMapRecorder.ts b/src/harness/sourceMapRecorder.ts index 55ca9ea9651..dcdc59a2a40 100644 --- a/src/harness/sourceMapRecorder.ts +++ b/src/harness/sourceMapRecorder.ts @@ -15,14 +15,14 @@ /// -module Harness.SourceMapRecoder { +namespace Harness.SourceMapRecoder { interface SourceMapSpanWithDecodeErrors { sourceMapSpan: ts.SourceMapSpan; decodeErrors: string[]; } - module SourceMapDecoder { + namespace SourceMapDecoder { let sourceMapMappings: string; let sourceMapNames: string[]; let decodingIndex: number; @@ -202,7 +202,7 @@ module Harness.SourceMapRecoder { } } - module SourceMapSpanWriter { + namespace SourceMapSpanWriter { let sourceMapRecoder: Compiler.WriterAggregator; let sourceMapSources: string[]; let sourceMapNames: string[]; @@ -442,7 +442,7 @@ module Harness.SourceMapRecoder { for (let i = 0; i < sourceMapDataList.length; i++) { let sourceMapData = sourceMapDataList[i]; - let prevSourceFile: ts.SourceFile = null; + let prevSourceFile: ts.SourceFile; SourceMapSpanWriter.intializeSourceMapSpanWriter(sourceMapRecoder, sourceMapData, jsFiles[i]); for (let j = 0; j < sourceMapData.sourceMapDecodedMappings.length; j++) { diff --git a/src/harness/test262Runner.ts b/src/harness/test262Runner.ts index d9bbd55e7a3..491c71a5839 100644 --- a/src/harness/test262Runner.ts +++ b/src/harness/test262Runner.ts @@ -1,5 +1,6 @@ /// /// +/* tslint:disable:no-null */ class Test262BaselineRunner extends RunnerBase { private static basePath = "internal/cases/test262"; diff --git a/src/harness/typeWriter.ts b/src/harness/typeWriter.ts index 0fef0779965..9db4fbcd41c 100644 --- a/src/harness/typeWriter.ts +++ b/src/harness/typeWriter.ts @@ -57,7 +57,9 @@ class TypeWriterWalker { symbolString += ", "; let declSourceFile = declaration.getSourceFile(); let declLineAndCharacter = declSourceFile.getLineAndCharacterOfPosition(declaration.pos); - symbolString += `Decl(${ ts.getBaseFileName(declSourceFile.fileName) }, ${ declLineAndCharacter.line }, ${ declLineAndCharacter.character })`; + let fileName = ts.getBaseFileName(declSourceFile.fileName); + let isLibFile = /lib(.*)\.d\.ts/i.test(fileName); + symbolString += `Decl(${ fileName }, ${ isLibFile ? "--" : declLineAndCharacter.line }, ${ isLibFile ? "--" : declLineAndCharacter.character })`; } } symbolString += ")"; diff --git a/src/lib/dom.generated.d.ts b/src/lib/dom.generated.d.ts index 90075a290a4..fa985344412 100644 --- a/src/lib/dom.generated.d.ts +++ b/src/lib/dom.generated.d.ts @@ -202,8 +202,8 @@ interface AnalyserNode extends AudioNode { smoothingTimeConstant: number; getByteFrequencyData(array: Uint8Array): void; getByteTimeDomainData(array: Uint8Array): void; - getFloatFrequencyData(array: any): void; - getFloatTimeDomainData(array: any): void; + getFloatFrequencyData(array: Float32Array): void; + getFloatTimeDomainData(array: Float32Array): void; } declare var AnalyserNode: { @@ -290,7 +290,7 @@ interface AudioBuffer { length: number; numberOfChannels: number; sampleRate: number; - getChannelData(channel: number): any; + getChannelData(channel: number): Float32Array; } declare var AudioBuffer: { @@ -334,7 +334,7 @@ interface AudioContext extends EventTarget { createMediaElementSource(mediaElement: HTMLMediaElement): MediaElementAudioSourceNode; createOscillator(): OscillatorNode; createPanner(): PannerNode; - createPeriodicWave(real: any, imag: any): PeriodicWave; + createPeriodicWave(real: Float32Array, imag: Float32Array): PeriodicWave; createScriptProcessor(bufferSize?: number, numberOfInputChannels?: number, numberOfOutputChannels?: number): ScriptProcessorNode; createStereoPanner(): StereoPannerNode; createWaveShaper(): WaveShaperNode; @@ -392,7 +392,7 @@ interface AudioParam { linearRampToValueAtTime(value: number, endTime: number): void; setTargetAtTime(target: number, startTime: number, timeConstant: number): void; setValueAtTime(value: number, startTime: number): void; - setValueCurveAtTime(values: any, startTime: number, duration: number): void; + setValueCurveAtTime(values: Float32Array, startTime: number, duration: number): void; } declare var AudioParam: { @@ -468,7 +468,7 @@ interface BiquadFilterNode extends AudioNode { frequency: AudioParam; gain: AudioParam; type: string; - getFrequencyResponse(frequencyHz: any, magResponse: any, phaseResponse: any): void; + getFrequencyResponse(frequencyHz: Float32Array, magResponse: Float32Array, phaseResponse: Float32Array): void; } declare var BiquadFilterNode: { @@ -1067,7 +1067,7 @@ declare var CanvasPattern: { interface CanvasRenderingContext2D { canvas: HTMLCanvasElement; - fillStyle: any; + fillStyle: string | CanvasGradient | CanvasPattern; font: string; globalAlpha: number; globalCompositeOperation: string; @@ -1082,7 +1082,7 @@ interface CanvasRenderingContext2D { shadowColor: string; shadowOffsetX: number; shadowOffsetY: number; - strokeStyle: any; + strokeStyle: string | CanvasGradient | CanvasPattern; textAlign: string; textBaseline: string; arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void; @@ -2450,8 +2450,6 @@ interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEven importNode(importedNode: Node, deep: boolean): Node; msElementsFromPoint(x: number, y: number): NodeList; msElementsFromRect(left: number, top: number, width: number, height: number): NodeList; - msGetPrintDocumentForNamedFlow(flowName: string): Document; - msSetPrintDocumentUriForNamedFlow(flowName: string, uri: string): void; /** * Opens a new window and loads a document specified by a given URL. Also, opens a new window that uses the url parameter and the name parameter to collect the output of the write method and the writeln method. * @param url Specifies a MIME type for the document. @@ -7273,27 +7271,6 @@ declare var MSHTMLWebViewElement: { new(): MSHTMLWebViewElement; } -interface MSHeaderFooter { - URL: string; - dateLong: string; - dateShort: string; - font: string; - htmlFoot: string; - htmlHead: string; - page: number; - pageTotal: number; - textFoot: string; - textHead: string; - timeLong: string; - timeShort: string; - title: string; -} - -declare var MSHeaderFooter: { - prototype: MSHeaderFooter; - new(): MSHeaderFooter; -} - interface MSInputMethodContext extends EventTarget { compositionEndOffset: number; compositionStartOffset: number; @@ -7452,24 +7429,6 @@ declare var MSPointerEvent: { new(typeArg: string, eventInitDict?: PointerEventInit): MSPointerEvent; } -interface MSPrintManagerTemplatePrinter extends MSTemplatePrinter, EventTarget { - percentScale: number; - showHeaderFooter: boolean; - shrinkToFit: boolean; - drawPreviewPage(element: HTMLElement, pageNumber: number): void; - endPrint(): void; - getPrintTaskOptionValue(key: string): any; - invalidatePreview(): void; - setPageCount(pageCount: number): void; - startPrint(): void; - addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; -} - -declare var MSPrintManagerTemplatePrinter: { - prototype: MSPrintManagerTemplatePrinter; - new(): MSPrintManagerTemplatePrinter; -} - interface MSRangeCollection { length: number; item(index: number): Range; @@ -7517,63 +7476,6 @@ declare var MSStreamReader: { new(): MSStreamReader; } -interface MSTemplatePrinter { - collate: boolean; - copies: number; - currentPage: boolean; - currentPageAvail: boolean; - duplex: boolean; - footer: string; - frameActive: boolean; - frameActiveEnabled: boolean; - frameAsShown: boolean; - framesetDocument: boolean; - header: string; - headerFooterFont: string; - marginBottom: number; - marginLeft: number; - marginRight: number; - marginTop: number; - orientation: string; - pageFrom: number; - pageHeight: number; - pageTo: number; - pageWidth: number; - selectedPages: boolean; - selection: boolean; - selectionEnabled: boolean; - unprintableBottom: number; - unprintableLeft: number; - unprintableRight: number; - unprintableTop: number; - usePrinterCopyCollate: boolean; - createHeaderFooter(): MSHeaderFooter; - deviceSupports(property: string): any; - ensurePrintDialogDefaults(): boolean; - getPageMarginBottom(pageRule: CSSPageRule, pageWidth: number, pageHeight: number): any; - getPageMarginBottomImportant(pageRule: CSSPageRule): boolean; - getPageMarginLeft(pageRule: CSSPageRule, pageWidth: number, pageHeight: number): any; - getPageMarginLeftImportant(pageRule: CSSPageRule): boolean; - getPageMarginRight(pageRule: CSSPageRule, pageWidth: number, pageHeight: number): any; - getPageMarginRightImportant(pageRule: CSSPageRule): boolean; - getPageMarginTop(pageRule: CSSPageRule, pageWidth: number, pageHeight: number): any; - getPageMarginTopImportant(pageRule: CSSPageRule): boolean; - printBlankPage(): void; - printNonNative(document: any): boolean; - printNonNativeFrames(document: any, activeFrame: boolean): void; - printPage(element: HTMLElement): void; - showPageSetupDialog(): boolean; - showPrintDialog(): boolean; - startDoc(title: string): boolean; - stopDoc(): void; - updatePageStatus(status: number): void; -} - -declare var MSTemplatePrinter: { - prototype: MSTemplatePrinter; - new(): MSTemplatePrinter; -} - interface MSWebViewAsyncOperation extends EventTarget { error: DOMError; oncomplete: (ev: Event) => any; @@ -7991,6 +7893,10 @@ declare var Node: { } interface NodeFilter { + acceptNode(n: Node): number; +} + +declare var NodeFilter: { FILTER_ACCEPT: number; FILTER_REJECT: number; FILTER_SKIP: number; @@ -8008,7 +7914,6 @@ interface NodeFilter { SHOW_PROCESSING_INSTRUCTION: number; SHOW_TEXT: number; } -declare var NodeFilter: NodeFilter; interface NodeIterator { expandEntityReferences: boolean; @@ -8718,7 +8623,6 @@ declare var SVGDescElement: { interface SVGElement extends Element { id: string; - className: any; onclick: (ev: MouseEvent) => any; ondblclick: (ev: MouseEvent) => any; onfocusin: (ev: FocusEvent) => any; @@ -8732,6 +8636,7 @@ interface SVGElement extends Element { ownerSVGElement: SVGSVGElement; viewportElement: SVGElement; xmlbase: string; + className: any; addEventListener(type: "MSGestureChange", listener: (ev: MSGestureEvent) => any, useCapture?: boolean): void; addEventListener(type: "MSGestureDoubleTap", listener: (ev: MSGestureEvent) => any, useCapture?: boolean): void; addEventListener(type: "MSGestureEnd", listener: (ev: MSGestureEvent) => any, useCapture?: boolean): void; @@ -10893,7 +10798,7 @@ declare var WEBGL_depth_texture: { } interface WaveShaperNode extends AudioNode { - curve: any; + curve: Float32Array; oversample: string; } @@ -11080,34 +10985,34 @@ interface WebGLRenderingContext { texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, video: HTMLVideoElement): void; texSubImage2D(target: number, level: number, xoffset: number, yoffset: number, format: number, type: number, pixels: ImageData): void; uniform1f(location: WebGLUniformLocation, x: number): void; - uniform1fv(location: WebGLUniformLocation, v: any): void; + uniform1fv(location: WebGLUniformLocation, v: Float32Array): void; uniform1i(location: WebGLUniformLocation, x: number): void; uniform1iv(location: WebGLUniformLocation, v: Int32Array): void; uniform2f(location: WebGLUniformLocation, x: number, y: number): void; - uniform2fv(location: WebGLUniformLocation, v: any): void; + uniform2fv(location: WebGLUniformLocation, v: Float32Array): void; uniform2i(location: WebGLUniformLocation, x: number, y: number): void; uniform2iv(location: WebGLUniformLocation, v: Int32Array): void; uniform3f(location: WebGLUniformLocation, x: number, y: number, z: number): void; - uniform3fv(location: WebGLUniformLocation, v: any): void; + uniform3fv(location: WebGLUniformLocation, v: Float32Array): void; uniform3i(location: WebGLUniformLocation, x: number, y: number, z: number): void; uniform3iv(location: WebGLUniformLocation, v: Int32Array): void; uniform4f(location: WebGLUniformLocation, x: number, y: number, z: number, w: number): void; - uniform4fv(location: WebGLUniformLocation, v: any): void; + uniform4fv(location: WebGLUniformLocation, v: Float32Array): void; uniform4i(location: WebGLUniformLocation, x: number, y: number, z: number, w: number): void; uniform4iv(location: WebGLUniformLocation, v: Int32Array): void; - uniformMatrix2fv(location: WebGLUniformLocation, transpose: boolean, value: any): void; - uniformMatrix3fv(location: WebGLUniformLocation, transpose: boolean, value: any): void; - uniformMatrix4fv(location: WebGLUniformLocation, transpose: boolean, value: any): void; + uniformMatrix2fv(location: WebGLUniformLocation, transpose: boolean, value: Float32Array): void; + uniformMatrix3fv(location: WebGLUniformLocation, transpose: boolean, value: Float32Array): void; + uniformMatrix4fv(location: WebGLUniformLocation, transpose: boolean, value: Float32Array): void; useProgram(program: WebGLProgram): void; validateProgram(program: WebGLProgram): void; vertexAttrib1f(indx: number, x: number): void; - vertexAttrib1fv(indx: number, values: any): void; + vertexAttrib1fv(indx: number, values: Float32Array): void; vertexAttrib2f(indx: number, x: number, y: number): void; - vertexAttrib2fv(indx: number, values: any): void; + vertexAttrib2fv(indx: number, values: Float32Array): void; vertexAttrib3f(indx: number, x: number, y: number, z: number): void; - vertexAttrib3fv(indx: number, values: any): void; + vertexAttrib3fv(indx: number, values: Float32Array): void; vertexAttrib4f(indx: number, x: number, y: number, z: number, w: number): void; - vertexAttrib4fv(indx: number, values: any): void; + vertexAttrib4fv(indx: number, values: Float32Array): void; vertexAttribPointer(indx: number, size: number, type: number, normalized: boolean, stride: number, offset: number): void; viewport(x: number, y: number, width: number, height: number): void; ACTIVE_ATTRIBUTES: number; @@ -11871,7 +11776,6 @@ interface Window extends EventTarget, WindowTimers, WindowSessionStorage, Window locationbar: BarProp; menubar: BarProp; msAnimationStartTime: number; - msTemplatePrinter: MSTemplatePrinter; name: string; navigator: Navigator; offscreenBuffering: string | boolean; @@ -12608,7 +12512,6 @@ interface XMLHttpRequestEventTarget { addEventListener(type: string, listener: EventListenerOrEventListenerObject, useCapture?: boolean): void; } - interface NodeListOf extends NodeList { length: number; item(index: number): TNode; @@ -12629,8 +12532,6 @@ interface EventListenerObject { handleEvent(evt: Event): void; } -declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject; - interface MessageEventInit extends EventInit { data?: any; origin?: string; @@ -12646,6 +12547,8 @@ interface ProgressEventInit extends EventInit { total?: number; } +declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject; + interface ErrorEventHandler { (message: string, filename?: string, lineno?: number, colno?: number, error?:Error): void; } @@ -12706,7 +12609,6 @@ declare var location: Location; declare var locationbar: BarProp; declare var menubar: BarProp; declare var msAnimationStartTime: number; -declare var msTemplatePrinter: MSTemplatePrinter; declare var name: string; declare var navigator: Navigator; declare var offscreenBuffering: string | boolean; diff --git a/src/lib/webworker.generated.d.ts b/src/lib/webworker.generated.d.ts index 9353047e9c6..7e160fffa45 100644 --- a/src/lib/webworker.generated.d.ts +++ b/src/lib/webworker.generated.d.ts @@ -17,7 +17,7 @@ interface AudioBuffer { length: number; numberOfChannels: number; sampleRate: number; - getChannelData(channel: number): any; + getChannelData(channel: number): Float32Array; } declare var AudioBuffer: { @@ -894,7 +894,6 @@ interface WorkerUtils extends Object, WindowBase64 { setTimeout(handler: any, timeout?: any, ...args: any[]): number; } - interface BlobPropertyBag { type?: string; endings?: string; @@ -909,8 +908,6 @@ interface EventListenerObject { handleEvent(evt: Event): void; } -declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject; - interface MessageEventInit extends EventInit { data?: any; origin?: string; @@ -926,6 +923,8 @@ interface ProgressEventInit extends EventInit { total?: number; } +declare type EventListenerOrEventListenerObject = EventListener | EventListenerObject; + interface ErrorEventHandler { (message: string, filename?: string, lineno?: number, colno?: number, error?:Error): void; } diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts index 7ab46fc689e..436b97821cc 100644 --- a/src/server/editorServices.ts +++ b/src/server/editorServices.ts @@ -1177,6 +1177,7 @@ namespace ts.server { TabSize: 4, NewLineCharacter: ts.sys ? ts.sys.newLine : '\n', ConvertTabsToSpaces: true, + IndentStyle: ts.IndentStyle.Smart, InsertSpaceAfterCommaDelimiter: true, InsertSpaceAfterSemicolonInForStatements: true, InsertSpaceBeforeAndAfterBinaryOperators: true, @@ -1187,7 +1188,6 @@ namespace ts.server { PlaceOpenBraceOnNewLineForFunctions: false, PlaceOpenBraceOnNewLineForControlBlocks: false, } - } export interface LineCollection { diff --git a/src/server/server.ts b/src/server/server.ts index 843197b918a..c3942b01a39 100644 --- a/src/server/server.ts +++ b/src/server/server.ts @@ -11,7 +11,7 @@ namespace ts.server { input: process.stdin, output: process.stdout, terminal: false, - }); + }); class Logger implements ts.server.Logger { fd = -1; @@ -58,7 +58,7 @@ namespace ts.server { isVerbose() { return this.loggingEnabled() && (this.level == "verbose"); } - + msg(s: string, type = "Err") { if (this.fd < 0) { @@ -85,7 +85,7 @@ namespace ts.server { interface WatchedFile { fileName: string; - callback: (fileName: string) => void; + callback: (fileName: string, removed: boolean) => void; mtime: Date; } @@ -121,11 +121,11 @@ namespace ts.server { fs.stat(watchedFile.fileName,(err, stats) => { if (err) { - watchedFile.callback(watchedFile.fileName); + watchedFile.callback(watchedFile.fileName, /* removed */ false); } else if (watchedFile.mtime.getTime() !== stats.mtime.getTime()) { watchedFile.mtime = WatchedFileSet.getModifiedTime(watchedFile.fileName); - watchedFile.callback(watchedFile.fileName); + watchedFile.callback(watchedFile.fileName, watchedFile.mtime.getTime() === 0); } }); } @@ -153,7 +153,7 @@ namespace ts.server { }, this.interval); } - addFile(fileName: string, callback: (fileName: string) => void ): WatchedFile { + addFile(fileName: string, callback: (fileName: string, removed: boolean) => void ): WatchedFile { var file: WatchedFile = { fileName, callback, @@ -170,7 +170,7 @@ namespace ts.server { removeFile(file: WatchedFile) { this.watchedFiles = WatchedFileSet.copyListRemovingItem(file, this.watchedFiles); } - } + } class IOSession extends Session { constructor(host: ServerHost, logger: ts.server.Logger) { @@ -243,11 +243,11 @@ namespace ts.server { // TODO: check that this location is writable var logger = createLoggerFromEnv(); - + // REVIEW: for now this implementation uses polling. // The advantage of polling is that it works reliably // on all os and with network mounted files. - // For 90 referenced files, the average time to detect + // For 90 referenced files, the average time to detect // changes is 2*msInterval (by default 5 seconds). // The overhead of this is .04 percent (1/2500) with // average pause of < 1 millisecond (and max @@ -271,4 +271,4 @@ namespace ts.server { }); // Start listening ioSession.listen(); -} \ No newline at end of file +} diff --git a/src/server/session.ts b/src/server/session.ts index da044e7b4c6..f3d3826409e 100644 --- a/src/server/session.ts +++ b/src/server/session.ts @@ -606,6 +606,7 @@ namespace ts.server { TabSize: formatOptions.TabSize, NewLineCharacter: "\n", ConvertTabsToSpaces: formatOptions.ConvertTabsToSpaces, + IndentStyle: ts.IndentStyle.Smart, }; var indentPosition = compilerService.languageService.getIndentationAtPosition(file, position, editorOptions); diff --git a/src/services/formatting/formatting.ts b/src/services/formatting/formatting.ts index fad3ebe6e2b..4a7033c6f3e 100644 --- a/src/services/formatting/formatting.ts +++ b/src/services/formatting/formatting.ts @@ -325,7 +325,7 @@ namespace ts.formatting { let lastIndentedLine: number; let indentationOnLastIndentedLine: number; - + let edits: TextChange[] = []; formattingScanner.advance(); @@ -354,12 +354,12 @@ namespace ts.formatting { * 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, - range: TextRange, + function tryComputeIndentationForListItem(startPos: number, + endPos: number, + parentStartLine: number, + range: TextRange, inheritedIndentation: number): number { - + if (rangeOverlapsWithStartEnd(range, startPos, endPos)) { if (inheritedIndentation !== Constants.Unknown) { return inheritedIndentation; @@ -376,7 +376,7 @@ namespace ts.formatting { return Constants.Unknown; } - + function computeIndentation( node: TextRangeWithKind, startLine: number, @@ -419,8 +419,8 @@ namespace ts.formatting { // if node is located on the same line with the parent // - inherit indentation from the parent // - push children if either parent of node itself has non-zero delta - indentation = startLine === lastIndentedLine - ? indentationOnLastIndentedLine + indentation = startLine === lastIndentedLine + ? indentationOnLastIndentedLine : parentDynamicIndentation.getIndentation(); delta = Math.min(options.IndentSize, parentDynamicIndentation.getDelta() + delta); } @@ -586,7 +586,7 @@ namespace ts.formatting { if (!rangeOverlapsWithStartEnd(originalRange, child.pos, child.end)) { return inheritedIndentation; } - + if (child.getFullWidth() === 0) { return inheritedIndentation; } @@ -624,8 +624,8 @@ namespace ts.formatting { return inheritedIndentation; } - function processChildNodes(nodes: NodeArray, - parent: Node, + function processChildNodes(nodes: NodeArray, + parent: Node, parentStartLine: number, parentDynamicIndentation: DynamicIndentation): void { @@ -751,7 +751,7 @@ namespace ts.formatting { // indent token only if is it is in target range and does not overlap with any error ranges if (tokenIndentation !== Constants.Unknown) { insertIndentation(currentTokenInfo.token.pos, tokenIndentation, lineAdded); - + lastIndentedLine = tokenStart.line; indentationOnLastIndentedLine = tokenIndentation; } @@ -772,12 +772,12 @@ namespace ts.formatting { } } - function processRange(range: TextRangeWithKind, - rangeStart: LineAndCharacter, - parent: Node, - contextNode: Node, + function processRange(range: TextRangeWithKind, + rangeStart: LineAndCharacter, + parent: Node, + contextNode: Node, dynamicIndentation: DynamicIndentation): boolean { - + let rangeHasError = rangeContainsError(range); let lineAdded: boolean; if (!rangeHasError && !previousRangeHasError) { @@ -787,7 +787,7 @@ namespace ts.formatting { trimTrailingWhitespacesForLines(originalStart.line, rangeStart.line); } else { - lineAdded = + lineAdded = processPair(range, rangeStart.line, parent, previousRange, previousRangeStartLine, previousParent, contextNode, dynamicIndentation) } } @@ -933,8 +933,8 @@ namespace ts.formatting { let lineStartPosition = getStartPositionOfLine(line, sourceFile); let lineEndPosition = getEndLinePosition(line, sourceFile); - // do not trim whitespaces in comments - if (range && isComment(range.kind) && range.pos <= lineEndPosition && range.end > lineEndPosition) { + // do not trim whitespaces in comments or template expression + if (range && (isComment(range.kind) || isStringOrRegularExpressionOrTemplateLiteral(range.kind)) && range.pos <= lineEndPosition && range.end > lineEndPosition) { continue; } diff --git a/src/services/formatting/formattingScanner.ts b/src/services/formatting/formattingScanner.ts index 6f6167d6ba9..58e2f304482 100644 --- a/src/services/formatting/formattingScanner.ts +++ b/src/services/formatting/formattingScanner.ts @@ -3,8 +3,14 @@ /* @internal */ namespace ts.formatting { - let scanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false); - + const standardScanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false, LanguageVariant.Standard); + const jsxScanner = createScanner(ScriptTarget.Latest, /*skipTrivia*/ false, LanguageVariant.JSX); + + /** + * Scanner that is currently used for formatting + */ + let scanner: Scanner; + export interface FormattingScanner { advance(): void; isOnToken(): boolean; @@ -22,6 +28,8 @@ namespace ts.formatting { } export function getFormattingScanner(sourceFile: SourceFile, startPos: number, endPos: number): FormattingScanner { + Debug.assert(scanner === undefined); + scanner = sourceFile.languageVariant === LanguageVariant.JSX ? jsxScanner : standardScanner; scanner.setText(sourceFile.text); scanner.setTextPos(startPos); @@ -40,12 +48,17 @@ namespace ts.formatting { isOnToken: isOnToken, lastTrailingTriviaWasNewLine: () => wasNewLine, close: () => { + Debug.assert(scanner !== undefined); + lastTokenInfo = undefined; scanner.setText(undefined); + scanner = undefined; } } function advance(): void { + Debug.assert(scanner !== undefined); + lastTokenInfo = undefined; let isStarted = scanner.getStartPos() !== startPos; @@ -138,6 +151,8 @@ namespace ts.formatting { } function readTokenInfo(n: Node): TokenInfo { + Debug.assert(scanner !== undefined); + if (!isOnToken()) { // scanner is not on the token (either advance was not called yet or scanner is already past the end position) return { @@ -245,6 +260,8 @@ namespace ts.formatting { } function isOnToken(): boolean { + Debug.assert(scanner !== undefined); + let current = (lastTokenInfo && lastTokenInfo.token.kind) || scanner.getToken(); let startPos = (lastTokenInfo && lastTokenInfo.token.pos) || scanner.getStartPos(); return startPos < endPos && current !== SyntaxKind.EndOfFileToken && !isTrivia(current); diff --git a/src/services/formatting/rules.ts b/src/services/formatting/rules.ts index 02e785f6b3e..12efb774dd3 100644 --- a/src/services/formatting/rules.ts +++ b/src/services/formatting/rules.ts @@ -214,10 +214,13 @@ namespace ts.formatting { public SpaceBetweenYieldOrYieldStarAndOperand: Rule; // Async functions + public SpaceBetweenAsyncAndOpenParen: Rule; public SpaceBetweenAsyncAndFunctionKeyword: Rule; - // Tagged template string + // Template strings public SpaceBetweenTagAndTemplateString: Rule; + public NoSpaceAfterTemplateHeadAndMiddle: Rule; + public NoSpaceBeforeTemplateMiddleAndTail: Rule; constructor() { /// @@ -367,10 +370,13 @@ namespace ts.formatting { this.SpaceBetweenYieldOrYieldStarAndOperand = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.YieldKeyword, SyntaxKind.AsteriskToken]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext, Rules.IsYieldOrYieldStarWithOperand), RuleAction.Space)); // Async-await + this.SpaceBetweenAsyncAndOpenParen = new Rule(RuleDescriptor.create1(SyntaxKind.AsyncKeyword, SyntaxKind.OpenParenToken), RuleOperation.create2(new RuleOperationContext(Rules.IsArrowFunctionContext, Rules.IsSameLineTokenContext), RuleAction.Space)); this.SpaceBetweenAsyncAndFunctionKeyword = new Rule(RuleDescriptor.create1(SyntaxKind.AsyncKeyword, SyntaxKind.FunctionKeyword), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space)); // template string this.SpaceBetweenTagAndTemplateString = new Rule(RuleDescriptor.create3(SyntaxKind.Identifier, Shared.TokenRange.FromTokens([SyntaxKind.NoSubstitutionTemplateLiteral, SyntaxKind.TemplateHead])), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Space)); + this.NoSpaceAfterTemplateHeadAndMiddle = new Rule(RuleDescriptor.create4(Shared.TokenRange.FromTokens([SyntaxKind.TemplateHead, SyntaxKind.TemplateMiddle]), Shared.TokenRange.Any), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Delete)); + this.NoSpaceBeforeTemplateMiddleAndTail = new Rule(RuleDescriptor.create4(Shared.TokenRange.Any, Shared.TokenRange.FromTokens([SyntaxKind.TemplateMiddle, SyntaxKind.TemplateTail])), RuleOperation.create2(new RuleOperationContext(Rules.IsSameLineTokenContext), RuleAction.Delete)); // These rules are higher in priority than user-configurable rules. this.HighPriorityCommonRules = @@ -398,8 +404,8 @@ namespace ts.formatting { this.NoSpaceBeforeOpenParenInFuncCall, this.SpaceBeforeBinaryKeywordOperator, this.SpaceAfterBinaryKeywordOperator, this.SpaceAfterVoidOperator, - this.SpaceBetweenAsyncAndFunctionKeyword, - this.SpaceBetweenTagAndTemplateString, + this.SpaceBetweenAsyncAndOpenParen, this.SpaceBetweenAsyncAndFunctionKeyword, + this.SpaceBetweenTagAndTemplateString, this.NoSpaceAfterTemplateHeadAndMiddle, this.NoSpaceBeforeTemplateMiddleAndTail, // TypeScript-specific rules this.NoSpaceAfterConstructor, this.NoSpaceAfterModuleImport, @@ -699,6 +705,10 @@ namespace ts.formatting { return context.currentTokenSpan.kind !== SyntaxKind.CommaToken; } + static IsArrowFunctionContext(context: FormattingContext): boolean { + return context.contextNode.kind === SyntaxKind.ArrowFunction; + } + static IsSameLineTokenContext(context: FormattingContext): boolean { return context.TokensAreOnSameLine(); } diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts index 8355fac03f5..3b68cd0ebb2 100644 --- a/src/services/formatting/smartIndenter.ts +++ b/src/services/formatting/smartIndenter.ts @@ -13,25 +13,45 @@ namespace ts.formatting { return 0; // past EOF } + // no indentation when the indent style is set to none, + // so we can return fast + if (options.IndentStyle === IndentStyle.None) { + return 0; + } + let precedingToken = findPrecedingToken(position, sourceFile); if (!precedingToken) { return 0; } // no indentation in string \regex\template literals - let precedingTokenIsLiteral = - precedingToken.kind === SyntaxKind.StringLiteral || - precedingToken.kind === SyntaxKind.RegularExpressionLiteral || - precedingToken.kind === SyntaxKind.NoSubstitutionTemplateLiteral || - precedingToken.kind === SyntaxKind.TemplateHead || - precedingToken.kind === SyntaxKind.TemplateMiddle || - precedingToken.kind === SyntaxKind.TemplateTail; + let precedingTokenIsLiteral = isStringOrRegularExpressionOrTemplateLiteral(precedingToken.kind); if (precedingTokenIsLiteral && precedingToken.getStart(sourceFile) <= position && precedingToken.end > position) { return 0; } let lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line; + // indentation is first non-whitespace character in a previous line + // for block indentation, we should look for a line which contains something that's not + // whitespace. + if (options.IndentStyle === IndentStyle.Block) { + + // move backwards until we find a line with a non-whitespace character, + // then find the first non-whitespace character for that line. + let current = position; + while (current > 0){ + let char = sourceFile.text.charCodeAt(current); + if (!isWhiteSpace(char) && !isLineBreak(char)) { + break; + } + current--; + } + + let lineStart = ts.getLineStartPositionForPosition(current, sourceFile); + return SmartIndenter.findFirstNonWhitespaceColumn(lineStart, current, sourceFile, options); + } + if (precedingToken.kind === SyntaxKind.CommaToken && precedingToken.parent.kind !== SyntaxKind.BinaryExpression) { // previous token is comma that separates items in list - find the previous item and try to derive indentation from it let actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options); @@ -224,7 +244,7 @@ namespace ts.formatting { function getStartLineAndCharacterForNode(n: Node, sourceFile: SourceFile): LineAndCharacter { return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)); } - + export function childStartsOnTheSameLineWithElseInIfStatement(parent: Node, child: TextRangeWithKind, childStartLine: number, sourceFile: SourceFile): boolean { if (parent.kind === SyntaxKind.IfStatement && (parent).elseStatement === child) { let elseKeyword = findChildOfKind(parent, SyntaxKind.ElseKeyword, sourceFile); @@ -325,7 +345,7 @@ namespace ts.formatting { } return Value.Unknown; - + function getStartingExpression(node: PropertyAccessExpression | CallExpression | ElementAccessExpression) { while (true) { switch (node.kind) { @@ -405,6 +425,7 @@ namespace ts.formatting { function nodeContentIsAlwaysIndented(kind: SyntaxKind): boolean { switch (kind) { + case SyntaxKind.ExpressionStatement: case SyntaxKind.ClassDeclaration: case SyntaxKind.ClassExpression: case SyntaxKind.InterfaceDeclaration: @@ -470,4 +491,4 @@ namespace ts.formatting { } } } -} \ No newline at end of file +} diff --git a/src/services/services.ts b/src/services/services.ts index 87cca1fe0f1..118c4ef3b7f 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -725,7 +725,7 @@ namespace ts { } getBaseTypes(): ObjectType[] { return this.flags & (TypeFlags.Class | TypeFlags.Interface) - ? this.checker.getBaseTypes(this) + ? this.checker.getBaseTypes(this) : undefined; } } @@ -1189,6 +1189,13 @@ namespace ts { TabSize: number; NewLineCharacter: string; ConvertTabsToSpaces: boolean; + IndentStyle: IndentStyle; + } + + export enum IndentStyle { + None = 0, + Block = 1, + Smart = 2, } export interface FormatCodeOptions extends EditorOptions { @@ -1850,8 +1857,8 @@ namespace ts { // so pass --noResolve to avoid reporting missing file errors. options.noResolve = true; - // Parse - let inputFileName = transpileOptions.fileName || "module.ts"; + // if jsx is specified then treat file as .tsx + let inputFileName = transpileOptions.fileName || (options.jsx ? "module.tsx" : "module.ts"); let sourceFile = createSourceFile(inputFileName, input, options.target); if (transpileOptions.moduleName) { sourceFile.moduleName = transpileOptions.moduleName; @@ -3549,6 +3556,9 @@ namespace ts { if (parent && (parent.kind === SyntaxKind.JsxSelfClosingElement || parent.kind === SyntaxKind.JsxOpeningElement)) { return parent; } + else if (parent.kind === SyntaxKind.JsxAttribute) { + return parent.parent; + } break; // The context token is the closing } or " of an attribute, which means @@ -3659,9 +3669,9 @@ namespace ts { return containingNodeKind === SyntaxKind.Parameter; case SyntaxKind.AsKeyword: - containingNodeKind === SyntaxKind.ImportSpecifier || - containingNodeKind === SyntaxKind.ExportSpecifier || - containingNodeKind === SyntaxKind.NamespaceImport; + return containingNodeKind === SyntaxKind.ImportSpecifier || + containingNodeKind === SyntaxKind.ExportSpecifier || + containingNodeKind === SyntaxKind.NamespaceImport; case SyntaxKind.ClassKeyword: case SyntaxKind.EnumKeyword: @@ -3680,14 +3690,20 @@ namespace ts { // Previous token may have been a keyword that was converted to an identifier. switch (contextToken.getText()) { + case "abstract": + case "async": case "class": - case "interface": + case "const": + case "declare": case "enum": case "function": - case "var": - case "static": + case "interface": case "let": - case "const": + case "private": + case "protected": + case "public": + case "static": + case "var": case "yield": return true; } @@ -6249,7 +6265,8 @@ namespace ts { } return node.parent.kind === SyntaxKind.TypeReference || - (node.parent.kind === SyntaxKind.ExpressionWithTypeArguments && !isExpressionWithTypeArgumentsInClassExtendsClause(node.parent)); + (node.parent.kind === SyntaxKind.ExpressionWithTypeArguments && !isExpressionWithTypeArgumentsInClassExtendsClause(node.parent)) || + node.kind === SyntaxKind.ThisKeyword && !isExpression(node); } function isNamespaceReference(node: Node): boolean { @@ -6997,8 +7014,12 @@ namespace ts { * Checks if position points to a valid position to add JSDoc comments, and if so, * returns the appropriate template. Otherwise returns an empty string. * Valid positions are - * - outside of comments, statements, and expressions, and - * - preceding a function declaration. + * - outside of comments, statements, and expressions, and + * - preceding a: + * - function/constructor/method declaration + * - class declarations + * - variable statements + * - namespace declarations * * Hosts should ideally check that: * - The line is all whitespace up to 'position' before performing the insertion. @@ -7025,16 +7046,37 @@ namespace ts { } // TODO: add support for: - // - methods - // - constructors - // - class decls - let containingFunction = getAncestor(tokenAtPos, SyntaxKind.FunctionDeclaration); + // - enums/enum members + // - interfaces + // - property declarations + // - potentially property assignments + let commentOwner: Node; + findOwner: for (commentOwner = tokenAtPos; commentOwner; commentOwner = commentOwner.parent) { + switch (commentOwner.kind) { + case SyntaxKind.FunctionDeclaration: + case SyntaxKind.MethodDeclaration: + case SyntaxKind.Constructor: + case SyntaxKind.ClassDeclaration: + case SyntaxKind.VariableStatement: + break findOwner; + case SyntaxKind.SourceFile: + return undefined; + case SyntaxKind.ModuleDeclaration: + // If in walking up the tree, we hit a a nested namespace declaration, + // then we must be somewhere within a dotted namespace name; however we don't + // want to give back a JSDoc template for the 'b' or 'c' in 'namespace a.b.c { }'. + if (commentOwner.parent.kind === SyntaxKind.ModuleDeclaration) { + return undefined; + } + break findOwner; + } + } - if (!containingFunction || containingFunction.getStart() < position) { + if (!commentOwner || commentOwner.getStart() < position) { return undefined; } - let parameters = containingFunction.parameters; + let parameters = getParametersForJsDocOwningNode(commentOwner); let posLineAndChar = sourceFile.getLineAndCharacterOfPosition(position); let lineStart = sourceFile.getLineStarts()[posLineAndChar.line]; @@ -7043,9 +7085,15 @@ namespace ts { // TODO: call a helper method instead once PR #4133 gets merged in. const newLine = host.getNewLine ? host.getNewLine() : "\r\n"; - let docParams = parameters.reduce((prev, cur, index) => - prev + - indentationStr + " * @param " + (cur.name.kind === SyntaxKind.Identifier ? (cur.name).text : "param" + index) + newLine, ""); + let docParams = ""; + for (let i = 0, numParams = parameters.length; i < numParams; i++) { + const currentName = parameters[i].name; + const paramName = currentName.kind === SyntaxKind.Identifier ? + (currentName).text : + "param" + i; + + docParams += `${indentationStr} * @param ${paramName}${newLine}`; + } // A doc comment consists of the following // * The opening comment line @@ -7065,6 +7113,52 @@ namespace ts { return { newText: result, caretOffset: preamble.length }; } + function getParametersForJsDocOwningNode(commentOwner: Node): ParameterDeclaration[] { + if (isFunctionLike(commentOwner)) { + return commentOwner.parameters; + } + + if (commentOwner.kind === SyntaxKind.VariableStatement) { + const varStatement = commentOwner; + const varDeclarations = varStatement.declarationList.declarations; + + if (varDeclarations.length === 1 && varDeclarations[0].initializer) { + return getParametersFromRightHandSideOfAssignment(varDeclarations[0].initializer); + } + } + + return emptyArray; + } + + /** + * Digs into an an initializer or RHS operand of an assignment operation + * to get the parameters of an apt signature corresponding to a + * function expression or a class expression. + * + * @param rightHandSide the expression which may contain an appropriate set of parameters + * @returns the parameters of a signature found on the RHS if one exists; otherwise 'emptyArray'. + */ + function getParametersFromRightHandSideOfAssignment(rightHandSide: Expression): ParameterDeclaration[] { + while (rightHandSide.kind === SyntaxKind.ParenthesizedExpression) { + rightHandSide = (rightHandSide).expression; + } + + switch (rightHandSide.kind) { + case SyntaxKind.FunctionExpression: + case SyntaxKind.ArrowFunction: + return (rightHandSide).parameters; + case SyntaxKind.ClassExpression: + for (let member of (rightHandSide).members) { + if (member.kind === SyntaxKind.Constructor) { + return (member).parameters; + } + } + break; + } + + return emptyArray; + } + function getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[] { // Note: while getting todo comments seems like a syntactic operation, we actually // treat it as a semantic operation here. This is because we expect our host to call @@ -7734,6 +7828,7 @@ namespace ts { case SyntaxKind.GreaterThanEqualsToken: case SyntaxKind.InstanceOfKeyword: case SyntaxKind.InKeyword: + case SyntaxKind.AsKeyword: case SyntaxKind.EqualsEqualsToken: case SyntaxKind.ExclamationEqualsToken: case SyntaxKind.EqualsEqualsEqualsToken: diff --git a/src/services/utilities.ts b/src/services/utilities.ts index 8b77dcb953b..a7198b4cc6d 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -9,7 +9,7 @@ namespace ts { export function getEndLinePosition(line: number, sourceFile: SourceFile): number { Debug.assert(line >= 0); let lineStarts = sourceFile.getLineStarts(); - + let lineIndex = line; if (lineIndex + 1 === lineStarts.length) { // last line - return EOF @@ -128,7 +128,8 @@ namespace ts { return isCompletedNode((n).thenStatement, sourceFile); case SyntaxKind.ExpressionStatement: - return isCompletedNode((n).expression, sourceFile); + return isCompletedNode((n).expression, sourceFile) || + hasChildOfKind(n, SyntaxKind.SemicolonToken); case SyntaxKind.ArrayLiteralExpression: case SyntaxKind.ArrayBindingPattern: @@ -170,7 +171,7 @@ namespace ts { case SyntaxKind.VoidExpression: case SyntaxKind.YieldExpression: case SyntaxKind.SpreadElementExpression: - let unaryWordExpression = (n); + let unaryWordExpression = (n); return isCompletedNode(unaryWordExpression.expression, sourceFile); case SyntaxKind.TaggedTemplateExpression: @@ -252,7 +253,7 @@ namespace ts { }); // Either we didn't find an appropriate list, or the list must contain us. - Debug.assert(!syntaxList || contains(syntaxList.getChildren(), node)); + Debug.assert(!syntaxList || contains(syntaxList.getChildren(), node)); return syntaxList; } @@ -388,7 +389,7 @@ namespace ts { // if this is the case - then we should assume that token in question is located in previous child. if (position < child.end && (nodeHasTokens(child) || child.kind === SyntaxKind.JsxText)) { const start = child.getStart(sourceFile); - const lookInPreviousChild = + const lookInPreviousChild = (start >= position) || // cursor in the leading trivia (child.kind === SyntaxKind.JsxText && start === child.end); // whitespace only JsxText @@ -425,7 +426,7 @@ namespace ts { } } } - + export function isInString(sourceFile: SourceFile, position: number) { let token = getTokenAtPosition(sourceFile, position); return token && token.kind === SyntaxKind.StringLiteral && position > token.getStart(); @@ -473,7 +474,7 @@ namespace ts { let commentRanges = getLeadingCommentRanges(sourceFile.text, token.pos); return forEach(commentRanges, jsDocPrefix); - + function jsDocPrefix(c: CommentRange): boolean { var text = sourceFile.text; return text.length >= c.pos + 3 && text[c.pos] === '/' && text[c.pos + 1] === '*' && text[c.pos + 2] === '*'; @@ -562,6 +563,15 @@ namespace ts { return kind === SyntaxKind.SingleLineCommentTrivia || kind === SyntaxKind.MultiLineCommentTrivia; } + export function isStringOrRegularExpressionOrTemplateLiteral(kind: SyntaxKind): boolean { + if (kind === SyntaxKind.StringLiteral + || kind === SyntaxKind.RegularExpressionLiteral + || isTemplateLiteralKind(kind)) { + return true; + } + return false; + } + export function isPunctuation(kind: SyntaxKind): boolean { return SyntaxKind.FirstPunctuation <= kind && kind <= SyntaxKind.LastPunctuation; } @@ -626,7 +636,8 @@ namespace ts { increaseIndent: () => { indent++; }, decreaseIndent: () => { indent--; }, clear: resetWriter, - trackSymbol: () => { } + trackSymbol: () => { }, + reportInaccessibleThisError: () => { } }; function writeIndent() { @@ -689,7 +700,7 @@ namespace ts { } export function displayPart(text: string, kind: SymbolDisplayPartKind, symbol?: Symbol): SymbolDisplayPart { - return { + return { text: text, kind: SymbolDisplayPartKind[kind] }; diff --git a/tests/baselines/reference/2dArrays.symbols b/tests/baselines/reference/2dArrays.symbols index c069f2dae8c..a42a40e2b6b 100644 --- a/tests/baselines/reference/2dArrays.symbols +++ b/tests/baselines/reference/2dArrays.symbols @@ -25,11 +25,11 @@ class Board { >allShipsSunk : Symbol(allShipsSunk, Decl(2dArrays.ts, 9, 18)) return this.ships.every(function (val) { return val.isSunk; }); ->this.ships.every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62)) +>this.ships.every : Symbol(Array.every, Decl(lib.d.ts, --, --)) >this.ships : Symbol(ships, Decl(2dArrays.ts, 7, 13)) >this : Symbol(Board, Decl(2dArrays.ts, 5, 1)) >ships : Symbol(ships, Decl(2dArrays.ts, 7, 13)) ->every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62)) +>every : Symbol(Array.every, Decl(lib.d.ts, --, --)) >val : Symbol(val, Decl(2dArrays.ts, 12, 42)) >val.isSunk : Symbol(Ship.isSunk, Decl(2dArrays.ts, 3, 12)) >val : Symbol(val, Decl(2dArrays.ts, 12, 42)) diff --git a/tests/baselines/reference/2dArrays.types b/tests/baselines/reference/2dArrays.types index b113ccdce7b..00805899294 100644 --- a/tests/baselines/reference/2dArrays.types +++ b/tests/baselines/reference/2dArrays.types @@ -28,7 +28,7 @@ class Board { >this.ships.every(function (val) { return val.isSunk; }) : boolean >this.ships.every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean >this.ships : Ship[] ->this : Board +>this : this >ships : Ship[] >every : (callbackfn: (value: Ship, index: number, array: Ship[]) => boolean, thisArg?: any) => boolean >function (val) { return val.isSunk; } : (val: Ship) => boolean diff --git a/tests/baselines/reference/ES5SymbolType1.symbols b/tests/baselines/reference/ES5SymbolType1.symbols index ea6c9084046..be316276f52 100644 --- a/tests/baselines/reference/ES5SymbolType1.symbols +++ b/tests/baselines/reference/ES5SymbolType1.symbols @@ -3,7 +3,7 @@ var s: symbol; >s : Symbol(s, Decl(ES5SymbolType1.ts, 0, 3)) s.toString(); ->s.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>s.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(ES5SymbolType1.ts, 0, 3)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.symbols b/tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.symbols index f56b2f526d4..90f2701b534 100644 --- a/tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.symbols +++ b/tests/baselines/reference/ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.symbols @@ -11,11 +11,11 @@ module A { export var beez: Array; >beez : Symbol(beez, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 5, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >B : Symbol(B, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 0, 10)) export var beez2 = new Array(); >beez2 : Symbol(beez2, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 6, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >B : Symbol(B, Decl(ExportVariableOfGenericTypeWithInaccessibleTypeAsTypeArgument.ts, 0, 10)) } diff --git a/tests/baselines/reference/TypeGuardWithArrayUnion.symbols b/tests/baselines/reference/TypeGuardWithArrayUnion.symbols index 57bcdf70e79..2ff91774b83 100644 --- a/tests/baselines/reference/TypeGuardWithArrayUnion.symbols +++ b/tests/baselines/reference/TypeGuardWithArrayUnion.symbols @@ -14,12 +14,12 @@ function saySize(message: Message | Message[]) { if (message instanceof Array) { >message : Symbol(message, Decl(TypeGuardWithArrayUnion.ts, 4, 17)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) return message.length; // Should have type Message[] here ->message.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>message.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >message : Symbol(message, Decl(TypeGuardWithArrayUnion.ts, 4, 17)) ->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/accessOverriddenBaseClassMember1.types b/tests/baselines/reference/accessOverriddenBaseClassMember1.types index 2aeb541d723..f444544ea48 100644 --- a/tests/baselines/reference/accessOverriddenBaseClassMember1.types +++ b/tests/baselines/reference/accessOverriddenBaseClassMember1.types @@ -15,11 +15,11 @@ class Point { >"x=" + this.x : string >"x=" : string >this.x : number ->this : Point +>this : this >x : number >" y=" : string >this.y : number ->this : Point +>this : this >y : number } } @@ -50,7 +50,7 @@ class ColoredPoint extends Point { >toString : () => string >" color=" : string >this.color : string ->this : ColoredPoint +>this : this >color : string } } diff --git a/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols b/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols index eff45630aae..bada6c561f1 100644 --- a/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols +++ b/tests/baselines/reference/additionOperatorWithAnyAndEveryType.symbols @@ -35,7 +35,7 @@ var d: string; var e: Object; >e : Symbol(e, Decl(additionOperatorWithAnyAndEveryType.ts, 12, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) // any as left operand, result is type Any except plusing string var r1 = a + a; diff --git a/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols b/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols index 0fb0f428716..68fac31d4f8 100644 --- a/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols +++ b/tests/baselines/reference/additionOperatorWithStringAndEveryType.symbols @@ -19,7 +19,7 @@ var d: string; var e: Object; >e : Symbol(e, Decl(additionOperatorWithStringAndEveryType.ts, 6, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var f: void; >f : Symbol(f, Decl(additionOperatorWithStringAndEveryType.ts, 7, 3)) diff --git a/tests/baselines/reference/aliasUsageInAccessorsOfClass.types b/tests/baselines/reference/aliasUsageInAccessorsOfClass.types index ea6ab451b11..c66f4c5c193 100644 --- a/tests/baselines/reference/aliasUsageInAccessorsOfClass.types +++ b/tests/baselines/reference/aliasUsageInAccessorsOfClass.types @@ -26,7 +26,7 @@ class C2 { return this.x; >this.x : IHasVisualizationModel ->this : C2 +>this : this >x : IHasVisualizationModel } set A(x) { diff --git a/tests/baselines/reference/ambientEnum1.errors.txt b/tests/baselines/reference/ambientEnum1.errors.txt index b4bb534f5dd..be8a19b34ba 100644 --- a/tests/baselines/reference/ambientEnum1.errors.txt +++ b/tests/baselines/reference/ambientEnum1.errors.txt @@ -1,17 +1,14 @@ -tests/cases/compiler/ambientEnum1.ts(2,9): error TS1066: Ambient enum elements can only have integer literal initializers. -tests/cases/compiler/ambientEnum1.ts(7,9): error TS1066: Ambient enum elements can only have integer literal initializers. +tests/cases/compiler/ambientEnum1.ts(7,13): error TS1066: In ambient enum declarations member initializer must be constant expression. -==== tests/cases/compiler/ambientEnum1.ts (2 errors) ==== +==== tests/cases/compiler/ambientEnum1.ts (1 errors) ==== declare enum E1 { y = 4.23 - ~ -!!! error TS1066: Ambient enum elements can only have integer literal initializers. } // Ambient enum with computer member declare enum E2 { x = 'foo'.length - ~ -!!! error TS1066: Ambient enum elements can only have integer literal initializers. + ~~~~~~~~~~~~ +!!! error TS1066: In ambient enum declarations member initializer must be constant expression. } \ No newline at end of file diff --git a/tests/baselines/reference/ambientEnumDeclaration1.errors.txt b/tests/baselines/reference/ambientEnumDeclaration1.errors.txt deleted file mode 100644 index 419f7e184ac..00000000000 --- a/tests/baselines/reference/ambientEnumDeclaration1.errors.txt +++ /dev/null @@ -1,24 +0,0 @@ -tests/cases/conformance/ambient/ambientEnumDeclaration1.ts(5,5): error TS1066: Ambient enum elements can only have integer literal initializers. -tests/cases/conformance/ambient/ambientEnumDeclaration1.ts(6,5): error TS1066: Ambient enum elements can only have integer literal initializers. -tests/cases/conformance/ambient/ambientEnumDeclaration1.ts(7,5): error TS1066: Ambient enum elements can only have integer literal initializers. -tests/cases/conformance/ambient/ambientEnumDeclaration1.ts(8,5): error TS1066: Ambient enum elements can only have integer literal initializers. - - -==== tests/cases/conformance/ambient/ambientEnumDeclaration1.ts (4 errors) ==== - // In ambient enum declarations, all values specified in enum member declarations must be classified as constant enum expressions. - - declare enum E { - a = 10, - b = 10 + 1, - ~ -!!! error TS1066: Ambient enum elements can only have integer literal initializers. - c = b, - ~ -!!! error TS1066: Ambient enum elements can only have integer literal initializers. - d = (c) + 1, - ~ -!!! error TS1066: Ambient enum elements can only have integer literal initializers. - e = 10 << 2 * 8, - ~ -!!! error TS1066: Ambient enum elements can only have integer literal initializers. - } \ No newline at end of file diff --git a/tests/baselines/reference/ambientEnumDeclaration1.symbols b/tests/baselines/reference/ambientEnumDeclaration1.symbols new file mode 100644 index 00000000000..62e6250cf95 --- /dev/null +++ b/tests/baselines/reference/ambientEnumDeclaration1.symbols @@ -0,0 +1,23 @@ +=== tests/cases/conformance/ambient/ambientEnumDeclaration1.ts === +// In ambient enum declarations, all values specified in enum member declarations must be classified as constant enum expressions. + +declare enum E { +>E : Symbol(E, Decl(ambientEnumDeclaration1.ts, 0, 0)) + + a = 10, +>a : Symbol(E.a, Decl(ambientEnumDeclaration1.ts, 2, 16)) + + b = 10 + 1, +>b : Symbol(E.b, Decl(ambientEnumDeclaration1.ts, 3, 11)) + + c = b, +>c : Symbol(E.c, Decl(ambientEnumDeclaration1.ts, 4, 15)) +>b : Symbol(E.b, Decl(ambientEnumDeclaration1.ts, 3, 11)) + + d = (c) + 1, +>d : Symbol(E.d, Decl(ambientEnumDeclaration1.ts, 5, 10)) +>c : Symbol(E.c, Decl(ambientEnumDeclaration1.ts, 4, 15)) + + e = 10 << 2 * 8, +>e : Symbol(E.e, Decl(ambientEnumDeclaration1.ts, 6, 16)) +} diff --git a/tests/baselines/reference/ambientEnumDeclaration1.types b/tests/baselines/reference/ambientEnumDeclaration1.types new file mode 100644 index 00000000000..3ef30e458da --- /dev/null +++ b/tests/baselines/reference/ambientEnumDeclaration1.types @@ -0,0 +1,35 @@ +=== tests/cases/conformance/ambient/ambientEnumDeclaration1.ts === +// In ambient enum declarations, all values specified in enum member declarations must be classified as constant enum expressions. + +declare enum E { +>E : E + + a = 10, +>a : E +>10 : number + + b = 10 + 1, +>b : E +>10 + 1 : number +>10 : number +>1 : number + + c = b, +>c : E +>b : E + + d = (c) + 1, +>d : E +>(c) + 1 : number +>(c) : E +>c : E +>1 : number + + e = 10 << 2 * 8, +>e : E +>10 << 2 * 8 : number +>10 : number +>2 * 8 : number +>2 : number +>8 : number +} diff --git a/tests/baselines/reference/ambientEnumElementInitializer3.errors.txt b/tests/baselines/reference/ambientEnumElementInitializer3.errors.txt deleted file mode 100644 index 56058210c16..00000000000 --- a/tests/baselines/reference/ambientEnumElementInitializer3.errors.txt +++ /dev/null @@ -1,9 +0,0 @@ -tests/cases/compiler/ambientEnumElementInitializer3.ts(2,2): error TS1066: Ambient enum elements can only have integer literal initializers. - - -==== tests/cases/compiler/ambientEnumElementInitializer3.ts (1 errors) ==== - declare enum E { - e = 3.3 // Decimal - ~ -!!! error TS1066: Ambient enum elements can only have integer literal initializers. - } \ No newline at end of file diff --git a/tests/baselines/reference/ambientEnumElementInitializer3.symbols b/tests/baselines/reference/ambientEnumElementInitializer3.symbols new file mode 100644 index 00000000000..ee0d5e4daea --- /dev/null +++ b/tests/baselines/reference/ambientEnumElementInitializer3.symbols @@ -0,0 +1,7 @@ +=== tests/cases/compiler/ambientEnumElementInitializer3.ts === +declare enum E { +>E : Symbol(E, Decl(ambientEnumElementInitializer3.ts, 0, 0)) + + e = 3.3 // Decimal +>e : Symbol(E.e, Decl(ambientEnumElementInitializer3.ts, 0, 16)) +} diff --git a/tests/baselines/reference/ambientEnumElementInitializer3.types b/tests/baselines/reference/ambientEnumElementInitializer3.types new file mode 100644 index 00000000000..f3d3b8f3ae2 --- /dev/null +++ b/tests/baselines/reference/ambientEnumElementInitializer3.types @@ -0,0 +1,8 @@ +=== tests/cases/compiler/ambientEnumElementInitializer3.ts === +declare enum E { +>E : E + + e = 3.3 // Decimal +>e : E +>3.3 : number +} diff --git a/tests/baselines/reference/ambientErrors.errors.txt b/tests/baselines/reference/ambientErrors.errors.txt index 16ce79a05dd..5e257c2de3f 100644 --- a/tests/baselines/reference/ambientErrors.errors.txt +++ b/tests/baselines/reference/ambientErrors.errors.txt @@ -1,22 +1,21 @@ tests/cases/conformance/ambient/ambientErrors.ts(2,15): error TS1039: Initializers are not allowed in ambient contexts. tests/cases/conformance/ambient/ambientErrors.ts(6,18): error TS2382: Specialized overload signature is not assignable to any non-specialized signature. tests/cases/conformance/ambient/ambientErrors.ts(17,22): error TS2371: A parameter initializer is only allowed in a function or constructor implementation. -tests/cases/conformance/ambient/ambientErrors.ts(20,24): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/conformance/ambient/ambientErrors.ts(24,5): error TS1066: Ambient enum elements can only have integer literal initializers. -tests/cases/conformance/ambient/ambientErrors.ts(29,5): error TS1066: Ambient enum elements can only have integer literal initializers. +tests/cases/conformance/ambient/ambientErrors.ts(20,24): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/ambient/ambientErrors.ts(29,9): error TS1066: In ambient enum declarations member initializer must be constant expression. tests/cases/conformance/ambient/ambientErrors.ts(34,11): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/conformance/ambient/ambientErrors.ts(35,19): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/ambient/ambientErrors.ts(35,19): error TS1183: An implementation cannot be declared in ambient contexts. tests/cases/conformance/ambient/ambientErrors.ts(37,20): error TS1039: Initializers are not allowed in ambient contexts. tests/cases/conformance/ambient/ambientErrors.ts(38,13): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/conformance/ambient/ambientErrors.ts(39,23): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/conformance/ambient/ambientErrors.ts(40,14): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/conformance/ambient/ambientErrors.ts(41,22): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/conformance/ambient/ambientErrors.ts(47,20): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/conformance/ambient/ambientErrors.ts(39,23): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/ambient/ambientErrors.ts(40,14): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/ambient/ambientErrors.ts(41,22): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/ambient/ambientErrors.ts(47,20): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/conformance/ambient/ambientErrors.ts(51,16): error TS2436: Ambient module declaration cannot specify relative module name. tests/cases/conformance/ambient/ambientErrors.ts(57,5): error TS2309: An export assignment cannot be used in a module with other exported elements. -==== tests/cases/conformance/ambient/ambientErrors.ts (16 errors) ==== +==== tests/cases/conformance/ambient/ambientErrors.ts (15 errors) ==== // Ambient variable with an initializer declare var x = 4; ~ @@ -44,20 +43,18 @@ tests/cases/conformance/ambient/ambientErrors.ts(57,5): error TS2309: An export // Ambient function with function body declare function fn4() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. // Ambient enum with non - integer literal constant member declare enum E1 { y = 4.23 - ~ -!!! error TS1066: Ambient enum elements can only have integer literal initializers. } // Ambient enum with computer member declare enum E2 { x = 'foo'.length - ~ -!!! error TS1066: Ambient enum elements can only have integer literal initializers. + ~~~~~~~~~~~~ +!!! error TS1066: In ambient enum declarations member initializer must be constant expression. } // Ambient module with initializers for values, bodies for functions / classes @@ -67,7 +64,7 @@ tests/cases/conformance/ambient/ambientErrors.ts(57,5): error TS2309: An export !!! error TS1039: Initializers are not allowed in ambient contexts. function fn() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. class C { static x = 3; ~ @@ -77,13 +74,13 @@ tests/cases/conformance/ambient/ambientErrors.ts(57,5): error TS2309: An export !!! error TS1039: Initializers are not allowed in ambient contexts. constructor() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. fn() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static sfn() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } } @@ -91,7 +88,7 @@ tests/cases/conformance/ambient/ambientErrors.ts(57,5): error TS2309: An export module M2 { declare module 'nope' { } ~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. } // Ambient external module with a string literal name that isn't a top level external module name diff --git a/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.errors.txt b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.errors.txt index 79f37c4764e..0e508470b13 100644 --- a/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.errors.txt +++ b/tests/baselines/reference/ambientExternalModuleInAnotherExternalModule.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts(5,16): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts(5,16): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts(10,22): error TS2307: Cannot find module 'ext'. @@ -9,7 +9,7 @@ tests/cases/compiler/ambientExternalModuleInAnotherExternalModule.ts(10,22): err declare module "ext" { ~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. export class C { } } diff --git a/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.errors.txt b/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.errors.txt index 87aae44840e..7e4ac795d0d 100644 --- a/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.errors.txt +++ b/tests/baselines/reference/ambientExternalModuleInsideNonAmbient.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbient.ts(2,27): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbient.ts(2,27): error TS2435: Ambient modules cannot be nested in other modules or namespaces. ==== tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbient.ts (1 errors) ==== module M { export declare module "M" { } ~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. } \ No newline at end of file diff --git a/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.errors.txt b/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.errors.txt index 763317ecc0c..e5905aaaf8f 100644 --- a/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.errors.txt +++ b/tests/baselines/reference/ambientExternalModuleInsideNonAmbientExternalModule.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbientExternalModule.ts(1,23): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbientExternalModule.ts(1,23): error TS2435: Ambient modules cannot be nested in other modules or namespaces. ==== tests/cases/conformance/ambient/ambientExternalModuleInsideNonAmbientExternalModule.ts (1 errors) ==== export declare module "M" { } ~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. \ No newline at end of file +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. \ No newline at end of file diff --git a/tests/baselines/reference/ambiguousCallsWhereReturnTypesAgree.types b/tests/baselines/reference/ambiguousCallsWhereReturnTypesAgree.types index d4df0f75d16..65f26f25770 100644 --- a/tests/baselines/reference/ambiguousCallsWhereReturnTypesAgree.types +++ b/tests/baselines/reference/ambiguousCallsWhereReturnTypesAgree.types @@ -31,7 +31,7 @@ class TestClass { this.bar(x); // should not error >this.bar(x) : void >this.bar : { (x: string): void; (x: string[]): void; } ->this : TestClass +>this : this >bar : { (x: string): void; (x: string[]): void; } >x : any } @@ -71,7 +71,7 @@ class TestClass2 { return this.bar(x); // should not error >this.bar(x) : number >this.bar : { (x: string): number; (x: string[]): number; } ->this : TestClass2 +>this : this >bar : { (x: string): number; (x: string[]): number; } >x : any } diff --git a/tests/baselines/reference/amdModuleName1.types b/tests/baselines/reference/amdModuleName1.types index 64bc7842451..c0db9c8b1b5 100644 --- a/tests/baselines/reference/amdModuleName1.types +++ b/tests/baselines/reference/amdModuleName1.types @@ -10,7 +10,7 @@ class Foo { this.x = 5; >this.x = 5 : number >this.x : number ->this : Foo +>this : this >x : number >5 : number } diff --git a/tests/baselines/reference/anyAssignabilityInInheritance.symbols b/tests/baselines/reference/anyAssignabilityInInheritance.symbols index 0f659dddd21..50148d7df99 100644 --- a/tests/baselines/reference/anyAssignabilityInInheritance.symbols +++ b/tests/baselines/reference/anyAssignabilityInInheritance.symbols @@ -56,8 +56,8 @@ var r3 = foo3(a); // any declare function foo5(x: Date): Date; >foo5 : Symbol(foo5, Decl(anyAssignabilityInInheritance.ts, 19, 17), Decl(anyAssignabilityInInheritance.ts, 21, 37)) >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 21, 22)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function foo5(x: any): any; >foo5 : Symbol(foo5, Decl(anyAssignabilityInInheritance.ts, 19, 17), Decl(anyAssignabilityInInheritance.ts, 21, 37)) @@ -71,8 +71,8 @@ var r3 = foo3(a); // any declare function foo6(x: RegExp): RegExp; >foo6 : Symbol(foo6, Decl(anyAssignabilityInInheritance.ts, 23, 17), Decl(anyAssignabilityInInheritance.ts, 25, 41)) >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 25, 22)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function foo6(x: any): any; >foo6 : Symbol(foo6, Decl(anyAssignabilityInInheritance.ts, 23, 17), Decl(anyAssignabilityInInheritance.ts, 25, 41)) @@ -277,8 +277,8 @@ var r3 = foo3(a); // any declare function foo17(x: Object): Object; >foo17 : Symbol(foo17, Decl(anyAssignabilityInInheritance.ts, 79, 17), Decl(anyAssignabilityInInheritance.ts, 81, 42)) >x : Symbol(x, Decl(anyAssignabilityInInheritance.ts, 81, 23)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function foo17(x: any): any; >foo17 : Symbol(foo17, Decl(anyAssignabilityInInheritance.ts, 79, 17), Decl(anyAssignabilityInInheritance.ts, 81, 42)) diff --git a/tests/baselines/reference/anyAssignableToEveryType.symbols b/tests/baselines/reference/anyAssignableToEveryType.symbols index 19dc94c7a43..b1b2f87c050 100644 --- a/tests/baselines/reference/anyAssignableToEveryType.symbols +++ b/tests/baselines/reference/anyAssignableToEveryType.symbols @@ -44,7 +44,7 @@ var d: boolean = a; var e: Date = a; >e : Symbol(e, Decl(anyAssignableToEveryType.ts, 17, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(anyAssignableToEveryType.ts, 0, 3)) var f: any = a; @@ -57,7 +57,7 @@ var g: void = a; var h: Object = a; >h : Symbol(h, Decl(anyAssignableToEveryType.ts, 20, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(anyAssignableToEveryType.ts, 0, 3)) var i: {} = a; @@ -70,7 +70,7 @@ var j: () => {} = a; var k: Function = a; >k : Symbol(k, Decl(anyAssignableToEveryType.ts, 23, 3)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(anyAssignableToEveryType.ts, 0, 3)) var l: (x: number) => string = a; @@ -109,12 +109,12 @@ var o: (x: T) => T = a; var p: Number = a; >p : Symbol(p, Decl(anyAssignableToEveryType.ts, 31, 3)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(anyAssignableToEveryType.ts, 0, 3)) var q: String = a; >q : Symbol(q, Decl(anyAssignableToEveryType.ts, 32, 3)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(anyAssignableToEveryType.ts, 0, 3)) function foo(x: T, y: U, z: V) { @@ -122,7 +122,7 @@ function foo(x: T, y: U, z: V) { >T : Symbol(T, Decl(anyAssignableToEveryType.ts, 34, 13)) >U : Symbol(U, Decl(anyAssignableToEveryType.ts, 34, 15)) >V : Symbol(V, Decl(anyAssignableToEveryType.ts, 34, 32)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(anyAssignableToEveryType.ts, 34, 49)) >T : Symbol(T, Decl(anyAssignableToEveryType.ts, 34, 13)) >y : Symbol(y, Decl(anyAssignableToEveryType.ts, 34, 54)) diff --git a/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols b/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols index daf7947e694..c1b5df88fb0 100644 --- a/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols +++ b/tests/baselines/reference/anyInferenceAnonymousFunctions.symbols @@ -3,9 +3,9 @@ var paired: any[]; >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3)) paired.reduce(function (a1, a2) { ->paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120)) +>paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3)) ->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120)) +>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a1 : Symbol(a1, Decl(anyInferenceAnonymousFunctions.ts, 2, 24)) >a2 : Symbol(a2, Decl(anyInferenceAnonymousFunctions.ts, 2, 27)) @@ -15,9 +15,9 @@ paired.reduce(function (a1, a2) { } , []); paired.reduce((b1, b2) => { ->paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120)) +>paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3)) ->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120)) +>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >b1 : Symbol(b1, Decl(anyInferenceAnonymousFunctions.ts, 8, 15)) >b2 : Symbol(b2, Decl(anyInferenceAnonymousFunctions.ts, 8, 18)) @@ -27,24 +27,24 @@ paired.reduce((b1, b2) => { } , []); paired.reduce((b3, b4) => b3.concat({}), []); ->paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120)) +>paired.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3)) ->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120)) +>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15)) >b4 : Symbol(b4, Decl(anyInferenceAnonymousFunctions.ts, 13, 18)) >b3 : Symbol(b3, Decl(anyInferenceAnonymousFunctions.ts, 13, 15)) paired.map((c1) => c1.count); ->paired.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>paired.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12)) >c1 : Symbol(c1, Decl(anyInferenceAnonymousFunctions.ts, 15, 12)) paired.map(function (c2) { return c2.count; }); ->paired.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>paired.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >paired : Symbol(paired, Decl(anyInferenceAnonymousFunctions.ts, 0, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21)) >c2 : Symbol(c2, Decl(anyInferenceAnonymousFunctions.ts, 16, 21)) diff --git a/tests/baselines/reference/argsInScope.symbols b/tests/baselines/reference/argsInScope.symbols index 7ea039819aa..6faf88facd9 100644 --- a/tests/baselines/reference/argsInScope.symbols +++ b/tests/baselines/reference/argsInScope.symbols @@ -11,9 +11,9 @@ class C { for (var i = 0; i < arguments.length; i++) { >i : Symbol(i, Decl(argsInScope.ts, 2, 15)) >i : Symbol(i, Decl(argsInScope.ts, 2, 15)) ->arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, 272, 25)) +>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) ->length : Symbol(IArguments.length, Decl(lib.d.ts, 272, 25)) +>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >i : Symbol(i, Decl(argsInScope.ts, 2, 15)) // WScript.Echo("param: " + arguments[i]); diff --git a/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols index b4351e579f5..d2d05cf3132 100644 --- a/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols +++ b/tests/baselines/reference/argumentsObjectIterator01_ES6.symbols @@ -14,9 +14,9 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe >arguments : Symbol(arguments) result.push(arg + arg); ->result.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>result.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >result : Symbol(result, Decl(argumentsObjectIterator01_ES6.ts, 2, 7)) ->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12)) >arg : Symbol(arg, Decl(argumentsObjectIterator01_ES6.ts, 3, 12)) } diff --git a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols index 2c5e611de68..7a4e75de66b 100644 --- a/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols +++ b/tests/baselines/reference/argumentsObjectIterator02_ES6.symbols @@ -9,9 +9,9 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe let blah = arguments[Symbol.iterator]; >blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7)) >arguments : Symbol(arguments) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) let result = []; >result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7)) @@ -21,9 +21,9 @@ function doubleAndReturnAsArray(x: number, y: number, z: number): [number, numbe >blah : Symbol(blah, Decl(argumentsObjectIterator02_ES6.ts, 2, 7)) result.push(arg + arg); ->result.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>result.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >result : Symbol(result, Decl(argumentsObjectIterator02_ES6.ts, 4, 7)) ->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12)) >arg : Symbol(arg, Decl(argumentsObjectIterator02_ES6.ts, 5, 12)) } diff --git a/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols b/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols index 1c3b54ef427..813f9e2f424 100644 --- a/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols +++ b/tests/baselines/reference/argumentsUsedInObjectLiteralProperty.symbols @@ -10,9 +10,9 @@ class A { return { selectedValue: arguments.length >selectedValue : Symbol(selectedValue, Decl(argumentsUsedInObjectLiteralProperty.ts, 2, 16)) ->arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, 272, 25)) +>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) ->length : Symbol(IArguments.length, Decl(lib.d.ts, 272, 25)) +>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) }; } diff --git a/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt b/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt index d13e0a265f7..d60f0b7d03c 100644 --- a/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt +++ b/tests/baselines/reference/arityAndOrderCompatibility01.errors.txt @@ -34,6 +34,8 @@ tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(25,5): error tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(26,5): error TS2322: Type 'StrNum' is not assignable to type '[string]'. Types of property 'pop' are incompatible. Type '() => string | number' is not assignable to type '() => string'. + Type 'string | number' is not assignable to type 'string'. + Type 'number' is not assignable to type 'string'. tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(27,5): error TS2322: Type '{ 0: string; 1: number; }' is not assignable to type '[string]'. Property 'length' is missing in type '{ 0: string; 1: number; }'. tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(28,5): error TS2322: Type '[string, number]' is not assignable to type '[number, string]'. @@ -125,6 +127,8 @@ tests/cases/conformance/types/tuple/arityAndOrderCompatibility01.ts(30,5): error !!! error TS2322: Type 'StrNum' is not assignable to type '[string]'. !!! error TS2322: Types of property 'pop' are incompatible. !!! error TS2322: Type '() => string | number' is not assignable to type '() => string'. +!!! error TS2322: Type 'string | number' is not assignable to type 'string'. +!!! error TS2322: Type 'number' is not assignable to type 'string'. var m3: [string] = z; ~~ !!! error TS2322: Type '{ 0: string; 1: number; }' is not assignable to type '[string]'. diff --git a/tests/baselines/reference/arrayAugment.symbols b/tests/baselines/reference/arrayAugment.symbols index 8310729032f..90a506077ad 100644 --- a/tests/baselines/reference/arrayAugment.symbols +++ b/tests/baselines/reference/arrayAugment.symbols @@ -1,12 +1,12 @@ === tests/cases/compiler/arrayAugment.ts === interface Array { ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(arrayAugment.ts, 0, 0)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(arrayAugment.ts, 0, 16)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(arrayAugment.ts, 0, 0)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(arrayAugment.ts, 0, 16)) split: (parts: number) => T[][]; >split : Symbol(split, Decl(arrayAugment.ts, 0, 20)) >parts : Symbol(parts, Decl(arrayAugment.ts, 1, 12)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(arrayAugment.ts, 0, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(arrayAugment.ts, 0, 16)) } var x = ['']; diff --git a/tests/baselines/reference/arrayBestCommonTypes.types b/tests/baselines/reference/arrayBestCommonTypes.types index 20f36e5c459..fca66793f40 100644 --- a/tests/baselines/reference/arrayBestCommonTypes.types +++ b/tests/baselines/reference/arrayBestCommonTypes.types @@ -51,7 +51,7 @@ module EmptyTypes { >(this.voidIfAny([4, 2][0])) : number >this.voidIfAny([4, 2][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[4, 2][0] : number >[4, 2] : number[] @@ -64,7 +64,7 @@ module EmptyTypes { >(this.voidIfAny([4, 2, undefined][0])) : number >this.voidIfAny([4, 2, undefined][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[4, 2, undefined][0] : number >[4, 2, undefined] : number[] @@ -78,7 +78,7 @@ module EmptyTypes { >(this.voidIfAny([undefined, 2, 4][0])) : number >this.voidIfAny([undefined, 2, 4][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[undefined, 2, 4][0] : number >[undefined, 2, 4] : number[] @@ -92,7 +92,7 @@ module EmptyTypes { >(this.voidIfAny([null, 2, 4][0])) : number >this.voidIfAny([null, 2, 4][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[null, 2, 4][0] : number >[null, 2, 4] : number[] @@ -106,7 +106,7 @@ module EmptyTypes { >(this.voidIfAny([2, 4, null][0])) : number >this.voidIfAny([2, 4, null][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[2, 4, null][0] : number >[2, 4, null] : number[] @@ -120,7 +120,7 @@ module EmptyTypes { >(this.voidIfAny([undefined, 4, null][0])) : number >this.voidIfAny([undefined, 4, null][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[undefined, 4, null][0] : number >[undefined, 4, null] : number[] @@ -134,7 +134,7 @@ module EmptyTypes { >(this.voidIfAny(['', "q"][0])) : number >this.voidIfAny(['', "q"][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >['', "q"][0] : string >['', "q"] : string[] @@ -147,7 +147,7 @@ module EmptyTypes { >(this.voidIfAny(['', "q", undefined][0])) : number >this.voidIfAny(['', "q", undefined][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >['', "q", undefined][0] : string >['', "q", undefined] : string[] @@ -161,7 +161,7 @@ module EmptyTypes { >(this.voidIfAny([undefined, "q", ''][0])) : number >this.voidIfAny([undefined, "q", ''][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[undefined, "q", ''][0] : string >[undefined, "q", ''] : string[] @@ -175,7 +175,7 @@ module EmptyTypes { >(this.voidIfAny([null, "q", ''][0])) : number >this.voidIfAny([null, "q", ''][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[null, "q", ''][0] : string >[null, "q", ''] : string[] @@ -189,7 +189,7 @@ module EmptyTypes { >(this.voidIfAny(["q", '', null][0])) : number >this.voidIfAny(["q", '', null][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >["q", '', null][0] : string >["q", '', null] : string[] @@ -203,7 +203,7 @@ module EmptyTypes { >(this.voidIfAny([undefined, '', null][0])) : number >this.voidIfAny([undefined, '', null][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[undefined, '', null][0] : string >[undefined, '', null] : string[] @@ -217,7 +217,7 @@ module EmptyTypes { >(this.voidIfAny([[3, 4], [null]][0][0])) : number >this.voidIfAny([[3, 4], [null]][0][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[[3, 4], [null]][0][0] : number >[[3, 4], [null]][0] : number[] @@ -454,7 +454,7 @@ module NonEmptyTypes { >(this.voidIfAny([4, 2][0])) : number >this.voidIfAny([4, 2][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[4, 2][0] : number >[4, 2] : number[] @@ -467,7 +467,7 @@ module NonEmptyTypes { >(this.voidIfAny([4, 2, undefined][0])) : number >this.voidIfAny([4, 2, undefined][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[4, 2, undefined][0] : number >[4, 2, undefined] : number[] @@ -481,7 +481,7 @@ module NonEmptyTypes { >(this.voidIfAny([undefined, 2, 4][0])) : number >this.voidIfAny([undefined, 2, 4][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[undefined, 2, 4][0] : number >[undefined, 2, 4] : number[] @@ -495,7 +495,7 @@ module NonEmptyTypes { >(this.voidIfAny([null, 2, 4][0])) : number >this.voidIfAny([null, 2, 4][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[null, 2, 4][0] : number >[null, 2, 4] : number[] @@ -509,7 +509,7 @@ module NonEmptyTypes { >(this.voidIfAny([2, 4, null][0])) : number >this.voidIfAny([2, 4, null][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[2, 4, null][0] : number >[2, 4, null] : number[] @@ -523,7 +523,7 @@ module NonEmptyTypes { >(this.voidIfAny([undefined, 4, null][0])) : number >this.voidIfAny([undefined, 4, null][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[undefined, 4, null][0] : number >[undefined, 4, null] : number[] @@ -537,7 +537,7 @@ module NonEmptyTypes { >(this.voidIfAny(['', "q"][0])) : number >this.voidIfAny(['', "q"][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >['', "q"][0] : string >['', "q"] : string[] @@ -550,7 +550,7 @@ module NonEmptyTypes { >(this.voidIfAny(['', "q", undefined][0])) : number >this.voidIfAny(['', "q", undefined][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >['', "q", undefined][0] : string >['', "q", undefined] : string[] @@ -564,7 +564,7 @@ module NonEmptyTypes { >(this.voidIfAny([undefined, "q", ''][0])) : number >this.voidIfAny([undefined, "q", ''][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[undefined, "q", ''][0] : string >[undefined, "q", ''] : string[] @@ -578,7 +578,7 @@ module NonEmptyTypes { >(this.voidIfAny([null, "q", ''][0])) : number >this.voidIfAny([null, "q", ''][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[null, "q", ''][0] : string >[null, "q", ''] : string[] @@ -592,7 +592,7 @@ module NonEmptyTypes { >(this.voidIfAny(["q", '', null][0])) : number >this.voidIfAny(["q", '', null][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >["q", '', null][0] : string >["q", '', null] : string[] @@ -606,7 +606,7 @@ module NonEmptyTypes { >(this.voidIfAny([undefined, '', null][0])) : number >this.voidIfAny([undefined, '', null][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[undefined, '', null][0] : string >[undefined, '', null] : string[] @@ -620,7 +620,7 @@ module NonEmptyTypes { >(this.voidIfAny([[3, 4], [null]][0][0])) : number >this.voidIfAny([[3, 4], [null]][0][0]) : number >this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } ->this : f +>this : this >voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; } >[[3, 4], [null]][0][0] : number >[[3, 4], [null]][0] : number[] diff --git a/tests/baselines/reference/arrayConcat2.symbols b/tests/baselines/reference/arrayConcat2.symbols index 8c0af7be702..daedee6e9c8 100644 --- a/tests/baselines/reference/arrayConcat2.symbols +++ b/tests/baselines/reference/arrayConcat2.symbols @@ -3,21 +3,21 @@ var a: string[] = []; >a : Symbol(a, Decl(arrayConcat2.ts, 0, 3)) a.concat("hello", 'world'); ->a.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>a.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(arrayConcat2.ts, 0, 3)) ->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) a.concat('Hello'); ->a.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>a.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(arrayConcat2.ts, 0, 3)) ->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var b = new Array(); >b : Symbol(b, Decl(arrayConcat2.ts, 5, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) b.concat('hello'); ->b.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>b.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(arrayConcat2.ts, 5, 3)) ->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/arrayConcatMap.symbols b/tests/baselines/reference/arrayConcatMap.symbols index 1ff4bc3bff5..5ef9d811723 100644 --- a/tests/baselines/reference/arrayConcatMap.symbols +++ b/tests/baselines/reference/arrayConcatMap.symbols @@ -1,14 +1,14 @@ === tests/cases/compiler/arrayConcatMap.ts === var x = [].concat([{ a: 1 }], [{ a: 2 }]) >x : Symbol(x, Decl(arrayConcatMap.ts, 0, 3)) ->[].concat([{ a: 1 }], [{ a: 2 }]) .map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) ->[].concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) ->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>[].concat([{ a: 1 }], [{ a: 2 }]) .map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>[].concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 20)) >a : Symbol(a, Decl(arrayConcatMap.ts, 0, 32)) .map(b => b.a); ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15)) >b : Symbol(b, Decl(arrayConcatMap.ts, 1, 15)) diff --git a/tests/baselines/reference/arrayConstructors1.symbols b/tests/baselines/reference/arrayConstructors1.symbols index cab2b0dc68a..1c69de79e00 100644 --- a/tests/baselines/reference/arrayConstructors1.symbols +++ b/tests/baselines/reference/arrayConstructors1.symbols @@ -4,28 +4,28 @@ var x: string[]; x = new Array(1); >x : Symbol(x, Decl(arrayConstructors1.ts, 0, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) x = new Array('hi', 'bye'); >x : Symbol(x, Decl(arrayConstructors1.ts, 0, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) x = new Array('hi', 'bye'); >x : Symbol(x, Decl(arrayConstructors1.ts, 0, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var y: number[]; >y : Symbol(y, Decl(arrayConstructors1.ts, 5, 3)) y = new Array(1); >y : Symbol(y, Decl(arrayConstructors1.ts, 5, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) y = new Array(1,2); >y : Symbol(y, Decl(arrayConstructors1.ts, 5, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) y = new Array(1, 2); >y : Symbol(y, Decl(arrayConstructors1.ts, 5, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/arrayLiteral.symbols b/tests/baselines/reference/arrayLiteral.symbols index 77673863b64..17c8ed019b5 100644 --- a/tests/baselines/reference/arrayLiteral.symbols +++ b/tests/baselines/reference/arrayLiteral.symbols @@ -6,7 +6,7 @@ var x = []; var x = new Array(1); >x : Symbol(x, Decl(arrayLiteral.ts, 2, 3), Decl(arrayLiteral.ts, 3, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var y = [1]; >y : Symbol(y, Decl(arrayLiteral.ts, 5, 3), Decl(arrayLiteral.ts, 6, 3), Decl(arrayLiteral.ts, 7, 3)) @@ -16,14 +16,14 @@ var y = [1, 2]; var y = new Array(); >y : Symbol(y, Decl(arrayLiteral.ts, 5, 3), Decl(arrayLiteral.ts, 6, 3), Decl(arrayLiteral.ts, 7, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var x2: number[] = []; >x2 : Symbol(x2, Decl(arrayLiteral.ts, 9, 3), Decl(arrayLiteral.ts, 10, 3)) var x2: number[] = new Array(1); >x2 : Symbol(x2, Decl(arrayLiteral.ts, 9, 3), Decl(arrayLiteral.ts, 10, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var y2: number[] = [1]; >y2 : Symbol(y2, Decl(arrayLiteral.ts, 12, 3), Decl(arrayLiteral.ts, 13, 3), Decl(arrayLiteral.ts, 14, 3)) @@ -33,5 +33,5 @@ var y2: number[] = [1, 2]; var y2: number[] = new Array(); >y2 : Symbol(y2, Decl(arrayLiteral.ts, 12, 3), Decl(arrayLiteral.ts, 13, 3), Decl(arrayLiteral.ts, 14, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols index 071596c9af1..1d47bf26493 100644 --- a/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols +++ b/tests/baselines/reference/arrayLiteralWithMultipleBestCommonTypes.symbols @@ -35,14 +35,14 @@ var cs = [a, b, c]; // { x: number; y?: number };[] var ds = [(x: Object) => 1, (x: string) => 2]; // { (x:Object) => number }[] >ds : Symbol(ds, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 3)) >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 11)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 10, 29)) var es = [(x: string) => 2, (x: Object) => 1]; // { (x:string) => number }[] >es : Symbol(es, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 3)) >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 11)) >x : Symbol(x, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 11, 29)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var fs = [(a: { x: number; y?: number }) => 1, (b: { x: number; z?: number }) => 2]; // (a: { x: number; y?: number }) => number[] >fs : Symbol(fs, Decl(arrayLiteralWithMultipleBestCommonTypes.ts, 12, 3)) diff --git a/tests/baselines/reference/arrayLiterals2ES5.symbols b/tests/baselines/reference/arrayLiterals2ES5.symbols index c69b79de272..4db8372a601 100644 --- a/tests/baselines/reference/arrayLiterals2ES5.symbols +++ b/tests/baselines/reference/arrayLiterals2ES5.symbols @@ -80,14 +80,14 @@ var temp4 = []; interface myArray extends Array { } >myArray : Symbol(myArray, Decl(arrayLiterals2ES5.ts, 42, 15)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) interface myArray2 extends Array { } >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES5.ts, 44, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var d0 = [1, true, ...temp,]; // has type (string|number|boolean)[] >d0 : Symbol(d0, Decl(arrayLiterals2ES5.ts, 46, 3)) diff --git a/tests/baselines/reference/arrayLiterals2ES6.symbols b/tests/baselines/reference/arrayLiterals2ES6.symbols index 75202d69690..0c7dc1495df 100644 --- a/tests/baselines/reference/arrayLiterals2ES6.symbols +++ b/tests/baselines/reference/arrayLiterals2ES6.symbols @@ -72,14 +72,14 @@ var temp2: [number[], string[]] = [[1, 2, 3], ["hello", "string"]]; interface myArray extends Array { } >myArray : Symbol(myArray, Decl(arrayLiterals2ES6.ts, 40, 67)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) interface myArray2 extends Array { } >myArray2 : Symbol(myArray2, Decl(arrayLiterals2ES6.ts, 42, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var d0 = [1, true, ...temp, ]; // has type (string|number|boolean)[] >d0 : Symbol(d0, Decl(arrayLiterals2ES6.ts, 44, 3)) diff --git a/tests/baselines/reference/arrayOfExportedClass.types b/tests/baselines/reference/arrayOfExportedClass.types index 1e41e82e448..8447ed2841f 100644 --- a/tests/baselines/reference/arrayOfExportedClass.types +++ b/tests/baselines/reference/arrayOfExportedClass.types @@ -18,7 +18,7 @@ class Road { this.cars = cars; >this.cars = cars : Car[] >this.cars : Car[] ->this : Road +>this : this >cars : Car[] >cars : Car[] } diff --git a/tests/baselines/reference/arrayconcat.symbols b/tests/baselines/reference/arrayconcat.symbols index 64e63d7c2ec..4fee1860be6 100644 --- a/tests/baselines/reference/arrayconcat.symbols +++ b/tests/baselines/reference/arrayconcat.symbols @@ -39,29 +39,29 @@ class parser { >this.options : Symbol(options, Decl(arrayconcat.ts, 10, 14)) >this : Symbol(parser, Decl(arrayconcat.ts, 8, 1)) >options : Symbol(options, Decl(arrayconcat.ts, 10, 14)) ->this.options.sort : Symbol(Array.sort, Decl(lib.d.ts, 1054, 45)) +>this.options.sort : Symbol(Array.sort, Decl(lib.d.ts, --, --)) >this.options : Symbol(options, Decl(arrayconcat.ts, 10, 14)) >this : Symbol(parser, Decl(arrayconcat.ts, 8, 1)) >options : Symbol(options, Decl(arrayconcat.ts, 10, 14)) ->sort : Symbol(Array.sort, Decl(lib.d.ts, 1054, 45)) +>sort : Symbol(Array.sort, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(arrayconcat.ts, 14, 44)) >b : Symbol(b, Decl(arrayconcat.ts, 14, 46)) var aName = a.name.toLowerCase(); >aName : Symbol(aName, Decl(arrayconcat.ts, 15, 15)) ->a.name.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>a.name.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >a.name : Symbol(IOptions.name, Decl(arrayconcat.ts, 0, 20)) >a : Symbol(a, Decl(arrayconcat.ts, 14, 44)) >name : Symbol(IOptions.name, Decl(arrayconcat.ts, 0, 20)) ->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) var bName = b.name.toLowerCase(); >bName : Symbol(bName, Decl(arrayconcat.ts, 16, 15)) ->b.name.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>b.name.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >b.name : Symbol(IOptions.name, Decl(arrayconcat.ts, 0, 20)) >b : Symbol(b, Decl(arrayconcat.ts, 14, 46)) >name : Symbol(IOptions.name, Decl(arrayconcat.ts, 0, 20)) ->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) if (aName > bName) { >aName : Symbol(aName, Decl(arrayconcat.ts, 15, 15)) diff --git a/tests/baselines/reference/arrayconcat.types b/tests/baselines/reference/arrayconcat.types index 3560272a363..45615cd63b8 100644 --- a/tests/baselines/reference/arrayconcat.types +++ b/tests/baselines/reference/arrayconcat.types @@ -38,12 +38,12 @@ class parser { this.options = this.options.sort(function(a, b) { >this.options = this.options.sort(function(a, b) { var aName = a.name.toLowerCase(); var bName = b.name.toLowerCase(); if (aName > bName) { return 1; } else if (aName < bName) { return -1; } else { return 0; } }) : IOptions[] >this.options : IOptions[] ->this : parser +>this : this >options : IOptions[] >this.options.sort(function(a, b) { var aName = a.name.toLowerCase(); var bName = b.name.toLowerCase(); if (aName > bName) { return 1; } else if (aName < bName) { return -1; } else { return 0; } }) : IOptions[] >this.options.sort : (compareFn?: (a: IOptions, b: IOptions) => number) => IOptions[] >this.options : IOptions[] ->this : parser +>this : this >options : IOptions[] >sort : (compareFn?: (a: IOptions, b: IOptions) => number) => IOptions[] >function(a, b) { var aName = a.name.toLowerCase(); var bName = b.name.toLowerCase(); if (aName > bName) { return 1; } else if (aName < bName) { return -1; } else { return 0; } } : (a: IOptions, b: IOptions) => number diff --git a/tests/baselines/reference/arrowFunctionExpressions.symbols b/tests/baselines/reference/arrowFunctionExpressions.symbols index 61c575933da..853c5074580 100644 --- a/tests/baselines/reference/arrowFunctionExpressions.symbols +++ b/tests/baselines/reference/arrowFunctionExpressions.symbols @@ -3,16 +3,16 @@ var a = (p: string) => p.length; >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 1, 3), Decl(arrowFunctionExpressions.ts, 2, 3)) >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 1, 9)) ->p.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>p.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 1, 9)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) var a = (p: string) => { return p.length; } >a : Symbol(a, Decl(arrowFunctionExpressions.ts, 1, 3), Decl(arrowFunctionExpressions.ts, 2, 3)) >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 2, 9)) ->p.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>p.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >p : Symbol(p, Decl(arrowFunctionExpressions.ts, 2, 9)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // Identifier => Block is equivalent to(Identifier) => Block var b = j => { return 0; } @@ -147,9 +147,9 @@ function someFn() { >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 45, 15)) arr(3)(4).toExponential(); ->arr(3)(4).toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>arr(3)(4).toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) >arr : Symbol(arr, Decl(arrowFunctionExpressions.ts, 45, 7)) ->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) } // Arrow function used in function @@ -162,9 +162,9 @@ function someOtherFn() { >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 51, 15)) arr(4).charAt(0); ->arr(4).charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>arr(4).charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >arr : Symbol(arr, Decl(arrowFunctionExpressions.ts, 51, 7)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) } // Arrow function used in nested function in function @@ -222,9 +222,9 @@ function someOuterFn() { >innerFn : Symbol(innerFn, Decl(arrowFunctionExpressions.ts, 77, 30)) return () => n.length; ->n.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>n.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(arrowFunctionExpressions.ts, 77, 15)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } return innerFn; >innerFn : Symbol(innerFn, Decl(arrowFunctionExpressions.ts, 77, 30)) @@ -237,9 +237,9 @@ var h = someOuterFn()('')()(); >someOuterFn : Symbol(someOuterFn, Decl(arrowFunctionExpressions.ts, 72, 14)) h.toExponential(); ->h.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>h.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) >h : Symbol(h, Decl(arrowFunctionExpressions.ts, 85, 3)) ->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) // Arrow function used in try/catch/finally in function function tryCatchFn() { diff --git a/tests/baselines/reference/arrowFunctionExpressions.types b/tests/baselines/reference/arrowFunctionExpressions.types index 6ac405e6d7e..eedd20944fe 100644 --- a/tests/baselines/reference/arrowFunctionExpressions.types +++ b/tests/baselines/reference/arrowFunctionExpressions.types @@ -129,12 +129,12 @@ class MyClass { >1 : number p = (n) => n && this; ->p : (n: any) => MyClass ->(n) => n && this : (n: any) => MyClass +>p : (n: any) => this +>(n) => n && this : (n: any) => this >n : any ->n && this : MyClass +>n && this : this >n : any ->this : MyClass +>this : this fn() { >fn : () => void @@ -148,12 +148,12 @@ class MyClass { >1 : number var p = (n) => n && this; ->p : (n: any) => MyClass ->(n) => n && this : (n: any) => MyClass +>p : (n: any) => this +>(n) => n && this : (n: any) => this >n : any ->n && this : MyClass +>n && this : this >n : any ->this : MyClass +>this : this } } diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols index c1d1cf40d90..aa2f19c1f60 100644 --- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols +++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody5.symbols @@ -1,13 +1,13 @@ === tests/cases/compiler/arrowFunctionWithObjectLiteralBody5.ts === var a = () => { name: "foo", message: "bar" }; >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 3)) ->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 22)) >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 0, 35)) var b = () => ({ name: "foo", message: "bar" }); >b : Symbol(b, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 3)) ->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 23)) >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 2, 36)) @@ -18,7 +18,7 @@ var c = () => ({ name: "foo", message: "bar" }); var d = () => ((({ name: "foo", message: "bar" }))); >d : Symbol(d, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 3)) ->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 25)) >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody5.ts, 6, 38)) diff --git a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols index 80530cde016..141b0d49880 100644 --- a/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols +++ b/tests/baselines/reference/arrowFunctionWithObjectLiteralBody6.symbols @@ -1,13 +1,13 @@ === tests/cases/compiler/arrowFunctionWithObjectLiteralBody6.ts === var a = () => { name: "foo", message: "bar" }; >a : Symbol(a, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 3)) ->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 22)) >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 0, 35)) var b = () => ({ name: "foo", message: "bar" }); >b : Symbol(b, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 3)) ->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 23)) >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 2, 36)) @@ -18,7 +18,7 @@ var c = () => ({ name: "foo", message: "bar" }); var d = () => ((({ name: "foo", message: "bar" }))); >d : Symbol(d, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 3)) ->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >name : Symbol(name, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 25)) >message : Symbol(message, Decl(arrowFunctionWithObjectLiteralBody6.ts, 6, 38)) diff --git a/tests/baselines/reference/asOperator1.symbols b/tests/baselines/reference/asOperator1.symbols index 27353ec7b30..343d3422b5c 100644 --- a/tests/baselines/reference/asOperator1.symbols +++ b/tests/baselines/reference/asOperator1.symbols @@ -8,12 +8,12 @@ var x = undefined as number; var y = (null as string).length; >y : Symbol(y, Decl(asOperator1.ts, 2, 3)) ->(null as string).length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>(null as string).length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) var z = Date as any as string; >z : Symbol(z, Decl(asOperator1.ts, 3, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) // Should parse as a union type, not a bitwise 'or' of (32 as number) and 'string' var j = 32 as number|string; diff --git a/tests/baselines/reference/asOperator4.js b/tests/baselines/reference/asOperator4.js new file mode 100644 index 00000000000..906b807fe73 --- /dev/null +++ b/tests/baselines/reference/asOperator4.js @@ -0,0 +1,22 @@ +//// [tests/cases/conformance/expressions/asOperator/asOperator4.ts] //// + +//// [foo.ts] + +export function foo() { } + +//// [bar.ts] +import { foo } from './foo'; + +// These should emit identically +foo; +(foo as any); + + +//// [foo.js] +function foo() { } +exports.foo = foo; +//// [bar.js] +var foo_1 = require('./foo'); +// These should emit identically +foo_1.foo; +foo_1.foo; diff --git a/tests/baselines/reference/asOperator4.symbols b/tests/baselines/reference/asOperator4.symbols new file mode 100644 index 00000000000..4ee5f6fe83f --- /dev/null +++ b/tests/baselines/reference/asOperator4.symbols @@ -0,0 +1,16 @@ +=== tests/cases/conformance/expressions/asOperator/foo.ts === + +export function foo() { } +>foo : Symbol(foo, Decl(foo.ts, 0, 0)) + +=== tests/cases/conformance/expressions/asOperator/bar.ts === +import { foo } from './foo'; +>foo : Symbol(foo, Decl(bar.ts, 0, 8)) + +// These should emit identically +foo; +>foo : Symbol(foo, Decl(bar.ts, 0, 8)) + +(foo as any); +>foo : Symbol(foo, Decl(bar.ts, 0, 8)) + diff --git a/tests/baselines/reference/asOperator4.types b/tests/baselines/reference/asOperator4.types new file mode 100644 index 00000000000..0dc6be46a2c --- /dev/null +++ b/tests/baselines/reference/asOperator4.types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/expressions/asOperator/foo.ts === + +export function foo() { } +>foo : () => void + +=== tests/cases/conformance/expressions/asOperator/bar.ts === +import { foo } from './foo'; +>foo : () => void + +// These should emit identically +foo; +>foo : any +>foo : () => void + +(foo as any); +>(foo as any) : any +>foo as any : any +>foo : () => void + diff --git a/tests/baselines/reference/asiAbstract.errors.txt b/tests/baselines/reference/asiAbstract.errors.txt new file mode 100644 index 00000000000..3cc8999a2f2 --- /dev/null +++ b/tests/baselines/reference/asiAbstract.errors.txt @@ -0,0 +1,24 @@ +tests/cases/compiler/asiAbstract.ts(1,1): error TS2304: Cannot find name 'abstract'. +tests/cases/compiler/asiAbstract.ts(3,3): error TS1244: Abstract methods can only appear within an abstract class. + + +==== tests/cases/compiler/asiAbstract.ts (2 errors) ==== + abstract + ~~~~~~~~ +!!! error TS2304: Cannot find name 'abstract'. + class NonAbstractClass { + abstract s(); + ~~~~~~~~ +!!! error TS1244: Abstract methods can only appear within an abstract class. + } + + class C2 { + abstract + nonAbstractFunction() { + } + } + + class C3 { + abstract + } + \ No newline at end of file diff --git a/tests/baselines/reference/asiAbstract.js b/tests/baselines/reference/asiAbstract.js new file mode 100644 index 00000000000..8d5b412d022 --- /dev/null +++ b/tests/baselines/reference/asiAbstract.js @@ -0,0 +1,36 @@ +//// [asiAbstract.ts] +abstract +class NonAbstractClass { + abstract s(); +} + +class C2 { + abstract + nonAbstractFunction() { + } +} + +class C3 { + abstract +} + + +//// [asiAbstract.js] +abstract; +var NonAbstractClass = (function () { + function NonAbstractClass() { + } + return NonAbstractClass; +})(); +var C2 = (function () { + function C2() { + } + C2.prototype.nonAbstractFunction = function () { + }; + return C2; +})(); +var C3 = (function () { + function C3() { + } + return C3; +})(); diff --git a/tests/baselines/reference/asiPublicPrivateProtected.errors.txt b/tests/baselines/reference/asiPublicPrivateProtected.errors.txt new file mode 100644 index 00000000000..96d243536fb --- /dev/null +++ b/tests/baselines/reference/asiPublicPrivateProtected.errors.txt @@ -0,0 +1,52 @@ +tests/cases/compiler/asiPublicPrivateProtected.ts(1,1): error TS2304: Cannot find name 'public'. +tests/cases/compiler/asiPublicPrivateProtected.ts(12,1): error TS2304: Cannot find name 'private'. +tests/cases/compiler/asiPublicPrivateProtected.ts(23,1): error TS2304: Cannot find name 'protected'. + + +==== tests/cases/compiler/asiPublicPrivateProtected.ts (3 errors) ==== + public + ~~~~~~ +!!! error TS2304: Cannot find name 'public'. + class NonPublicClass { + public s() { + } + } + + class NonPublicClass2 { + public + private nonPublicFunction() { + } + } + private + ~~~~~~~ +!!! error TS2304: Cannot find name 'private'. + class NonPrivateClass { + private s() { + } + } + + class NonPrivateClass2 { + private + public nonPrivateFunction() { + } + } + protected + ~~~~~~~~~ +!!! error TS2304: Cannot find name 'protected'. + class NonProtectedClass { + protected s() { + } + } + + class NonProtectedClass2 { + protected + public nonProtectedFunction() { + } + } + + class ClassWithThreeMembers { + public + private + protected + } + \ No newline at end of file diff --git a/tests/baselines/reference/asiPublicPrivateProtected.js b/tests/baselines/reference/asiPublicPrivateProtected.js new file mode 100644 index 00000000000..a17bcb7509a --- /dev/null +++ b/tests/baselines/reference/asiPublicPrivateProtected.js @@ -0,0 +1,93 @@ +//// [asiPublicPrivateProtected.ts] +public +class NonPublicClass { + public s() { + } +} + +class NonPublicClass2 { + public + private nonPublicFunction() { + } +} +private +class NonPrivateClass { + private s() { + } +} + +class NonPrivateClass2 { + private + public nonPrivateFunction() { + } +} +protected +class NonProtectedClass { + protected s() { + } +} + +class NonProtectedClass2 { + protected + public nonProtectedFunction() { + } +} + +class ClassWithThreeMembers { + public + private + protected +} + + +//// [asiPublicPrivateProtected.js] +public; +var NonPublicClass = (function () { + function NonPublicClass() { + } + NonPublicClass.prototype.s = function () { + }; + return NonPublicClass; +})(); +var NonPublicClass2 = (function () { + function NonPublicClass2() { + } + NonPublicClass2.prototype.nonPublicFunction = function () { + }; + return NonPublicClass2; +})(); +private; +var NonPrivateClass = (function () { + function NonPrivateClass() { + } + NonPrivateClass.prototype.s = function () { + }; + return NonPrivateClass; +})(); +var NonPrivateClass2 = (function () { + function NonPrivateClass2() { + } + NonPrivateClass2.prototype.nonPrivateFunction = function () { + }; + return NonPrivateClass2; +})(); +protected; +var NonProtectedClass = (function () { + function NonProtectedClass() { + } + NonProtectedClass.prototype.s = function () { + }; + return NonProtectedClass; +})(); +var NonProtectedClass2 = (function () { + function NonProtectedClass2() { + } + NonProtectedClass2.prototype.nonProtectedFunction = function () { + }; + return NonProtectedClass2; +})(); +var ClassWithThreeMembers = (function () { + function ClassWithThreeMembers() { + } + return ClassWithThreeMembers; +})(); diff --git a/tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols b/tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols index 8218de9be79..ea9440cf1a9 100644 --- a/tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols +++ b/tests/baselines/reference/assignmentCompatWithCallSignatures3.symbols @@ -106,23 +106,23 @@ var a11: (x: { foo: string }, y: { foo: string; bar: string }) => Base; var a12: (x: Array, y: Array) => Array; >a12 : Symbol(a12, Decl(assignmentCompatWithCallSignatures3.ts, 18, 3)) >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 18, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0)) >y : Symbol(y, Decl(assignmentCompatWithCallSignatures3.ts, 18, 25)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(assignmentCompatWithCallSignatures3.ts, 3, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27)) var a13: (x: Array, y: Array) => Array; >a13 : Symbol(a13, Decl(assignmentCompatWithCallSignatures3.ts, 19, 3)) >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 19, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0)) >y : Symbol(y, Decl(assignmentCompatWithCallSignatures3.ts, 19, 25)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27)) var a14: (x: { a: string; b: number }) => Object; @@ -130,7 +130,7 @@ var a14: (x: { a: string; b: number }) => Object; >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 20, 10)) >a : Symbol(a, Decl(assignmentCompatWithCallSignatures3.ts, 20, 14)) >b : Symbol(b, Decl(assignmentCompatWithCallSignatures3.ts, 20, 25)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a15: { >a15 : Symbol(a15, Decl(assignmentCompatWithCallSignatures3.ts, 21, 3)) @@ -189,8 +189,8 @@ var a18: { (a: Date): Date; >a : Symbol(a, Decl(assignmentCompatWithCallSignatures3.ts, 40, 9)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) }): any[]; } @@ -407,14 +407,14 @@ b11 = a11; // ok var b12: >(x: Array, y: T) => Array; >b12 : Symbol(b12, Decl(assignmentCompatWithCallSignatures3.ts, 77, 3)) >T : Symbol(T, Decl(assignmentCompatWithCallSignatures3.ts, 77, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0)) >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 77, 33)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0)) >y : Symbol(y, Decl(assignmentCompatWithCallSignatures3.ts, 77, 48)) >T : Symbol(T, Decl(assignmentCompatWithCallSignatures3.ts, 77, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27)) a12 = b12; // ok @@ -428,10 +428,10 @@ b12 = a12; // ok var b13: >(x: Array, y: T) => T; >b13 : Symbol(b13, Decl(assignmentCompatWithCallSignatures3.ts, 80, 3)) >T : Symbol(T, Decl(assignmentCompatWithCallSignatures3.ts, 80, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(assignmentCompatWithCallSignatures3.ts, 2, 27)) >x : Symbol(x, Decl(assignmentCompatWithCallSignatures3.ts, 80, 36)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(assignmentCompatWithCallSignatures3.ts, 0, 0)) >y : Symbol(y, Decl(assignmentCompatWithCallSignatures3.ts, 80, 51)) >T : Symbol(T, Decl(assignmentCompatWithCallSignatures3.ts, 80, 10)) diff --git a/tests/baselines/reference/assignmentCompatWithConstructSignatures3.symbols b/tests/baselines/reference/assignmentCompatWithConstructSignatures3.symbols index ef02b7a08d3..4ef01deaea8 100644 --- a/tests/baselines/reference/assignmentCompatWithConstructSignatures3.symbols +++ b/tests/baselines/reference/assignmentCompatWithConstructSignatures3.symbols @@ -106,23 +106,23 @@ var a11: new (x: { foo: string }, y: { foo: string; bar: string }) => Base; var a12: new (x: Array, y: Array) => Array; >a12 : Symbol(a12, Decl(assignmentCompatWithConstructSignatures3.ts, 18, 3)) >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures3.ts, 18, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0)) >y : Symbol(y, Decl(assignmentCompatWithConstructSignatures3.ts, 18, 29)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(assignmentCompatWithConstructSignatures3.ts, 3, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 27)) var a13: new (x: Array, y: Array) => Array; >a13 : Symbol(a13, Decl(assignmentCompatWithConstructSignatures3.ts, 19, 3)) >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures3.ts, 19, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0)) >y : Symbol(y, Decl(assignmentCompatWithConstructSignatures3.ts, 19, 29)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 27)) var a14: new (x: { a: string; b: number }) => Object; @@ -130,7 +130,7 @@ var a14: new (x: { a: string; b: number }) => Object; >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures3.ts, 20, 14)) >a : Symbol(a, Decl(assignmentCompatWithConstructSignatures3.ts, 20, 18)) >b : Symbol(b, Decl(assignmentCompatWithConstructSignatures3.ts, 20, 29)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a15: { >a15 : Symbol(a15, Decl(assignmentCompatWithConstructSignatures3.ts, 21, 3)) @@ -189,8 +189,8 @@ var a18: { new (a: Date): Date; >a : Symbol(a, Decl(assignmentCompatWithConstructSignatures3.ts, 40, 13)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) }): any[]; } @@ -407,14 +407,14 @@ b11 = a11; // ok var b12: new >(x: Array, y: T) => Array; >b12 : Symbol(b12, Decl(assignmentCompatWithConstructSignatures3.ts, 77, 3)) >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures3.ts, 77, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0)) >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures3.ts, 77, 37)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0)) >y : Symbol(y, Decl(assignmentCompatWithConstructSignatures3.ts, 77, 52)) >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures3.ts, 77, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 27)) a12 = b12; // ok @@ -428,10 +428,10 @@ b12 = a12; // ok var b13: new >(x: Array, y: T) => T; >b13 : Symbol(b13, Decl(assignmentCompatWithConstructSignatures3.ts, 80, 3)) >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures3.ts, 80, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(assignmentCompatWithConstructSignatures3.ts, 2, 27)) >x : Symbol(x, Decl(assignmentCompatWithConstructSignatures3.ts, 80, 40)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(assignmentCompatWithConstructSignatures3.ts, 0, 0)) >y : Symbol(y, Decl(assignmentCompatWithConstructSignatures3.ts, 80, 55)) >T : Symbol(T, Decl(assignmentCompatWithConstructSignatures3.ts, 80, 14)) diff --git a/tests/baselines/reference/asyncArrowFunction1_es6.symbols b/tests/baselines/reference/asyncArrowFunction1_es6.symbols index 349a51c43ba..a8a5aef325a 100644 --- a/tests/baselines/reference/asyncArrowFunction1_es6.symbols +++ b/tests/baselines/reference/asyncArrowFunction1_es6.symbols @@ -2,6 +2,6 @@ var foo = async (): Promise => { >foo : Symbol(foo, Decl(asyncArrowFunction1_es6.ts, 1, 3)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) }; diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols index 5f820eec862..2f516d7d758 100644 --- a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols +++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.symbols @@ -10,9 +10,9 @@ class C { var fn = async () => await other.apply(this, arguments); >fn : Symbol(fn, Decl(asyncArrowFunctionCapturesArguments_es6.ts, 3, 9)) ->other.apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20)) +>other.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) >other : Symbol(other, Decl(asyncArrowFunctionCapturesArguments_es6.ts, 1, 13)) ->apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20)) +>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) >this : Symbol(C, Decl(asyncArrowFunctionCapturesArguments_es6.ts, 0, 0)) >arguments : Symbol(arguments) } diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.types b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.types index b3f6f18cde8..76853858c5c 100644 --- a/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.types +++ b/tests/baselines/reference/asyncArrowFunctionCapturesArguments_es6.types @@ -11,11 +11,12 @@ class C { var fn = async () => await other.apply(this, arguments); >fn : () => Promise >async () => await other.apply(this, arguments) : () => Promise +>await other.apply(this, arguments) : any >other.apply(this, arguments) : any >other.apply : (thisArg: any, argArray?: any) => any >other : () => void >apply : (thisArg: any, argArray?: any) => any ->this : C +>this : this >arguments : IArguments } } diff --git a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types index f3cd0f2d2de..5386a956ada 100644 --- a/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types +++ b/tests/baselines/reference/asyncArrowFunctionCapturesThis_es6.types @@ -6,9 +6,10 @@ class C { >method : () => void var fn = async () => await this; ->fn : () => Promise ->async () => await this : () => Promise ->this : C +>fn : () => Promise +>async () => await this : () => Promise +>await this : this +>this : this } } diff --git a/tests/baselines/reference/asyncAwait_es6.symbols b/tests/baselines/reference/asyncAwait_es6.symbols index 2eb28e12211..3c668b15b36 100644 --- a/tests/baselines/reference/asyncAwait_es6.symbols +++ b/tests/baselines/reference/asyncAwait_es6.symbols @@ -2,16 +2,16 @@ type MyPromise = Promise; >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11)) >T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(asyncAwait_es6.ts, 0, 15)) declare var MyPromise: typeof Promise; >MyPromise : Symbol(MyPromise, Decl(asyncAwait_es6.ts, 0, 0), Decl(asyncAwait_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare var p: Promise; >p : Symbol(p, Decl(asyncAwait_es6.ts, 2, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare var mp: MyPromise; >mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11)) @@ -22,7 +22,7 @@ async function f0() { } async function f1(): Promise { } >f1 : Symbol(f1, Decl(asyncAwait_es6.ts, 5, 23)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) async function f3(): MyPromise { } >f3 : Symbol(f3, Decl(asyncAwait_es6.ts, 6, 38)) @@ -33,7 +33,7 @@ let f4 = async function() { } let f5 = async function(): Promise { } >f5 : Symbol(f5, Decl(asyncAwait_es6.ts, 10, 3)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) let f6 = async function(): MyPromise { } >f6 : Symbol(f6, Decl(asyncAwait_es6.ts, 11, 3)) @@ -44,7 +44,7 @@ let f7 = async () => { }; let f8 = async (): Promise => { }; >f8 : Symbol(f8, Decl(asyncAwait_es6.ts, 14, 3)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) let f9 = async (): MyPromise => { }; >f9 : Symbol(f9, Decl(asyncAwait_es6.ts, 15, 3)) @@ -60,7 +60,7 @@ let f11 = async () => mp; let f12 = async (): Promise => mp; >f12 : Symbol(f12, Decl(asyncAwait_es6.ts, 18, 3)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >mp : Symbol(mp, Decl(asyncAwait_es6.ts, 3, 11)) let f13 = async (): MyPromise => p; @@ -76,7 +76,7 @@ let o = { async m2(): Promise { }, >m2 : Symbol(m2, Decl(asyncAwait_es6.ts, 22, 16)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) async m3(): MyPromise { } >m3 : Symbol(m3, Decl(asyncAwait_es6.ts, 23, 31)) @@ -92,7 +92,7 @@ class C { async m2(): Promise { } >m2 : Symbol(m2, Decl(asyncAwait_es6.ts, 28, 15)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) async m3(): MyPromise { } >m3 : Symbol(m3, Decl(asyncAwait_es6.ts, 29, 30)) @@ -103,7 +103,7 @@ class C { static async m5(): Promise { } >m5 : Symbol(C.m5, Decl(asyncAwait_es6.ts, 31, 22)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) static async m6(): MyPromise { } >m6 : Symbol(C.m6, Decl(asyncAwait_es6.ts, 32, 37)) diff --git a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols index b970dbbf888..f1946aa712f 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration11_es6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration11_es6.ts === async function await(): Promise { >await : Symbol(await, Decl(asyncFunctionDeclaration11_es6.ts, 0, 0)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols index d17f4bf899e..34623ded262 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration14_es6.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration14_es6.ts === async function foo(): Promise { >foo : Symbol(foo, Decl(asyncFunctionDeclaration14_es6.ts, 0, 0)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) return; } diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt new file mode 100644 index 00000000000..8c029eaaaf4 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration15_es6.errors.txt @@ -0,0 +1,56 @@ +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(6,16): error TS1055: Type '{}' is not a valid async function return type. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(7,16): error TS1055: Type 'any' is not a valid async function return type. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(8,16): error TS1055: Type 'number' is not a valid async function return type. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(9,16): error TS1055: Type 'PromiseLike' is not a valid async function return type. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(10,16): error TS1055: Type 'typeof Thenable' is not a valid async function return type. + Type 'Thenable' is not assignable to type 'PromiseLike'. + Types of property 'then' are incompatible. + Type '() => void' is not assignable to type '{ (onfulfilled?: (value: any) => TResult | PromiseLike, onrejected?: (reason: any) => TResult | PromiseLike): PromiseLike; (onfulfilled?: (value: any) => TResult | PromiseLike, onrejected?: (reason: any) => void): PromiseLike; }'. + Type 'void' is not assignable to type 'PromiseLike'. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(17,16): error TS1059: Return expression in async function does not have a valid callable 'then' member. +tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts(23,25): error TS1058: Operand for 'await' does not have a valid callable 'then' member. + + +==== tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts (7 errors) ==== + declare class Thenable { then(): void; } + declare let a: any; + declare let obj: { then: string; }; + declare let thenable: Thenable; + async function fn1() { } // valid: Promise + async function fn2(): { } { } // error + ~~~ +!!! error TS1055: Type '{}' is not a valid async function return type. + async function fn3(): any { } // error + ~~~ +!!! error TS1055: Type 'any' is not a valid async function return type. + async function fn4(): number { } // error + ~~~ +!!! error TS1055: Type 'number' is not a valid async function return type. + async function fn5(): PromiseLike { } // error + ~~~ +!!! error TS1055: Type 'PromiseLike' is not a valid async function return type. + async function fn6(): Thenable { } // error + ~~~ +!!! error TS1055: Type 'typeof Thenable' is not a valid async function return type. +!!! error TS1055: Type 'Thenable' is not assignable to type 'PromiseLike'. +!!! error TS1055: Types of property 'then' are incompatible. +!!! error TS1055: Type '() => void' is not assignable to type '{ (onfulfilled?: (value: any) => TResult | PromiseLike, onrejected?: (reason: any) => TResult | PromiseLike): PromiseLike; (onfulfilled?: (value: any) => TResult | PromiseLike, onrejected?: (reason: any) => void): PromiseLike; }'. +!!! error TS1055: Type 'void' is not assignable to type 'PromiseLike'. + async function fn7() { return; } // valid: Promise + async function fn8() { return 1; } // valid: Promise + async function fn9() { return null; } // valid: Promise + async function fn10() { return undefined; } // valid: Promise + async function fn11() { return a; } // valid: Promise + async function fn12() { return obj; } // valid: Promise<{ then: string; }> + async function fn13() { return thenable; } // error + ~~~~ +!!! error TS1059: Return expression in async function does not have a valid callable 'then' member. + async function fn14() { await 1; } // valid: Promise + async function fn15() { await null; } // valid: Promise + async function fn16() { await undefined; } // valid: Promise + async function fn17() { await a; } // valid: Promise + async function fn18() { await obj; } // valid: Promise + async function fn19() { await thenable; } // error + ~~~~~~~~~~~~~~ +!!! error TS1058: Operand for 'await' does not have a valid callable 'then' member. + \ No newline at end of file diff --git a/tests/baselines/reference/asyncFunctionDeclaration15_es6.js b/tests/baselines/reference/asyncFunctionDeclaration15_es6.js new file mode 100644 index 00000000000..c72062e24b2 --- /dev/null +++ b/tests/baselines/reference/asyncFunctionDeclaration15_es6.js @@ -0,0 +1,84 @@ +//// [asyncFunctionDeclaration15_es6.ts] +declare class Thenable { then(): void; } +declare let a: any; +declare let obj: { then: string; }; +declare let thenable: Thenable; +async function fn1() { } // valid: Promise +async function fn2(): { } { } // error +async function fn3(): any { } // error +async function fn4(): number { } // error +async function fn5(): PromiseLike { } // error +async function fn6(): Thenable { } // error +async function fn7() { return; } // valid: Promise +async function fn8() { return 1; } // valid: Promise +async function fn9() { return null; } // valid: Promise +async function fn10() { return undefined; } // valid: Promise +async function fn11() { return a; } // valid: Promise +async function fn12() { return obj; } // valid: Promise<{ then: string; }> +async function fn13() { return thenable; } // error +async function fn14() { await 1; } // valid: Promise +async function fn15() { await null; } // valid: Promise +async function fn16() { await undefined; } // valid: Promise +async function fn17() { await a; } // valid: Promise +async function fn18() { await obj; } // valid: Promise +async function fn19() { await thenable; } // error + + +//// [asyncFunctionDeclaration15_es6.js] +function fn1() { + return __awaiter(this, void 0, Promise, function* () { }); +} // valid: Promise +function fn2() { + return __awaiter(this, void 0, Promise, function* () { }); +} // error +function fn3() { + return __awaiter(this, void 0, Promise, function* () { }); +} // error +function fn4() { + return __awaiter(this, void 0, Promise, function* () { }); +} // error +function fn5() { + return __awaiter(this, void 0, PromiseLike, function* () { }); +} // error +function fn6() { + return __awaiter(this, void 0, Thenable, function* () { }); +} // error +function fn7() { + return __awaiter(this, void 0, Promise, function* () { return; }); +} // valid: Promise +function fn8() { + return __awaiter(this, void 0, Promise, function* () { return 1; }); +} // valid: Promise +function fn9() { + return __awaiter(this, void 0, Promise, function* () { return null; }); +} // valid: Promise +function fn10() { + return __awaiter(this, void 0, Promise, function* () { return undefined; }); +} // valid: Promise +function fn11() { + return __awaiter(this, void 0, Promise, function* () { return a; }); +} // valid: Promise +function fn12() { + return __awaiter(this, void 0, Promise, function* () { return obj; }); +} // valid: Promise<{ then: string; }> +function fn13() { + return __awaiter(this, void 0, Promise, function* () { return thenable; }); +} // error +function fn14() { + return __awaiter(this, void 0, Promise, function* () { yield 1; }); +} // valid: Promise +function fn15() { + return __awaiter(this, void 0, Promise, function* () { yield null; }); +} // valid: Promise +function fn16() { + return __awaiter(this, void 0, Promise, function* () { yield undefined; }); +} // valid: Promise +function fn17() { + return __awaiter(this, void 0, Promise, function* () { yield a; }); +} // valid: Promise +function fn18() { + return __awaiter(this, void 0, Promise, function* () { yield obj; }); +} // valid: Promise +function fn19() { + return __awaiter(this, void 0, Promise, function* () { yield thenable; }); +} // error diff --git a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols index c99ae35266b..b1721789f5c 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols +++ b/tests/baselines/reference/asyncFunctionDeclaration1_es6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1_es6.ts === async function foo(): Promise { >foo : Symbol(foo, Decl(asyncFunctionDeclaration1_es6.ts, 0, 0)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/augmentArray.symbols b/tests/baselines/reference/augmentArray.symbols index 8c52363d601..ae0caddb1c6 100644 --- a/tests/baselines/reference/augmentArray.symbols +++ b/tests/baselines/reference/augmentArray.symbols @@ -1,7 +1,7 @@ === tests/cases/compiler/augmentArray.ts === interface Array { ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(augmentArray.ts, 0, 0)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(augmentArray.ts, 0, 16)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(augmentArray.ts, 0, 0)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(augmentArray.ts, 0, 16)) (): any[]; } diff --git a/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols b/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols index 81c8b13d207..c3dfe5996b9 100644 --- a/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols +++ b/tests/baselines/reference/augmentedTypeBracketAccessIndexSignature.symbols @@ -8,7 +8,7 @@ interface Bar { b } >b : Symbol(b, Decl(augmentedTypeBracketAccessIndexSignature.ts, 1, 15)) interface Object { ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11), Decl(augmentedTypeBracketAccessIndexSignature.ts, 1, 19)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(augmentedTypeBracketAccessIndexSignature.ts, 1, 19)) [n: number]: Foo; >n : Symbol(n, Decl(augmentedTypeBracketAccessIndexSignature.ts, 4, 5)) @@ -16,7 +16,7 @@ interface Object { } interface Function { ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(augmentedTypeBracketAccessIndexSignature.ts, 5, 1)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(augmentedTypeBracketAccessIndexSignature.ts, 5, 1)) [n: number]: Bar; >n : Symbol(n, Decl(augmentedTypeBracketAccessIndexSignature.ts, 8, 5)) diff --git a/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols b/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols index cc9c2ba62ef..d12e8e13793 100644 --- a/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols +++ b/tests/baselines/reference/augmentedTypeBracketNamedPropertyAccess.symbols @@ -1,12 +1,12 @@ === tests/cases/compiler/augmentedTypeBracketNamedPropertyAccess.ts === interface Object { ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11), Decl(augmentedTypeBracketNamedPropertyAccess.ts, 0, 0)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(augmentedTypeBracketNamedPropertyAccess.ts, 0, 0)) data: number; >data : Symbol(data, Decl(augmentedTypeBracketNamedPropertyAccess.ts, 0, 18)) } interface Function { ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(augmentedTypeBracketNamedPropertyAccess.ts, 2, 1)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(augmentedTypeBracketNamedPropertyAccess.ts, 2, 1)) functionData: string; >functionData : Symbol(functionData, Decl(augmentedTypeBracketNamedPropertyAccess.ts, 3, 20)) diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols index 5203e666db9..fd532aeca74 100644 --- a/tests/baselines/reference/awaitBinaryExpression1_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression1_es6.symbols @@ -4,15 +4,16 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression1_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var b = await p || a; >b : Symbol(b, Decl(awaitBinaryExpression1_es6.ts, 4, 7)) +>p : Symbol(p, Decl(awaitBinaryExpression1_es6.ts, 1, 11)) >a : Symbol(a, Decl(awaitBinaryExpression1_es6.ts, 0, 11)) "after"; diff --git a/tests/baselines/reference/awaitBinaryExpression1_es6.types b/tests/baselines/reference/awaitBinaryExpression1_es6.types index 59370dda14b..4718f5f8fe9 100644 --- a/tests/baselines/reference/awaitBinaryExpression1_es6.types +++ b/tests/baselines/reference/awaitBinaryExpression1_es6.types @@ -16,7 +16,8 @@ async function func(): Promise { var b = await p || a; >b : boolean >await p || a : boolean ->p : any +>await p : boolean +>p : Promise >a : boolean "after"; diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols index da1efd0fda4..3117f62da17 100644 --- a/tests/baselines/reference/awaitBinaryExpression2_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression2_es6.symbols @@ -4,15 +4,16 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression2_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var b = await p && a; >b : Symbol(b, Decl(awaitBinaryExpression2_es6.ts, 4, 7)) +>p : Symbol(p, Decl(awaitBinaryExpression2_es6.ts, 1, 11)) >a : Symbol(a, Decl(awaitBinaryExpression2_es6.ts, 0, 11)) "after"; diff --git a/tests/baselines/reference/awaitBinaryExpression2_es6.types b/tests/baselines/reference/awaitBinaryExpression2_es6.types index c3f33bca2fa..6154377a6f1 100644 --- a/tests/baselines/reference/awaitBinaryExpression2_es6.types +++ b/tests/baselines/reference/awaitBinaryExpression2_es6.types @@ -16,7 +16,8 @@ async function func(): Promise { var b = await p && a; >b : boolean >await p && a : boolean ->p : any +>await p : boolean +>p : Promise >a : boolean "after"; diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols index e35d1663486..e50f194bbee 100644 --- a/tests/baselines/reference/awaitBinaryExpression3_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression3_es6.symbols @@ -4,15 +4,16 @@ declare var a: number; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression3_es6.ts, 1, 31)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var b = await p + a; >b : Symbol(b, Decl(awaitBinaryExpression3_es6.ts, 4, 7)) +>p : Symbol(p, Decl(awaitBinaryExpression3_es6.ts, 1, 11)) >a : Symbol(a, Decl(awaitBinaryExpression3_es6.ts, 0, 11)) "after"; diff --git a/tests/baselines/reference/awaitBinaryExpression3_es6.types b/tests/baselines/reference/awaitBinaryExpression3_es6.types index 786eabadae4..2d5b087d6e3 100644 --- a/tests/baselines/reference/awaitBinaryExpression3_es6.types +++ b/tests/baselines/reference/awaitBinaryExpression3_es6.types @@ -16,7 +16,8 @@ async function func(): Promise { var b = await p + a; >b : number >await p + a : number ->p : any +>await p : number +>p : Promise >a : number "after"; diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols index 19dd741e2db..02e05faeab0 100644 --- a/tests/baselines/reference/awaitBinaryExpression4_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression4_es6.symbols @@ -4,15 +4,16 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression4_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var b = await p, a; >b : Symbol(b, Decl(awaitBinaryExpression4_es6.ts, 4, 7)) +>p : Symbol(p, Decl(awaitBinaryExpression4_es6.ts, 1, 11)) >a : Symbol(a, Decl(awaitBinaryExpression4_es6.ts, 4, 20)) "after"; diff --git a/tests/baselines/reference/awaitBinaryExpression4_es6.types b/tests/baselines/reference/awaitBinaryExpression4_es6.types index 73126b7797d..80135203a82 100644 --- a/tests/baselines/reference/awaitBinaryExpression4_es6.types +++ b/tests/baselines/reference/awaitBinaryExpression4_es6.types @@ -15,7 +15,8 @@ async function func(): Promise { var b = await p, a; >b : boolean ->p : any +>await p : boolean +>p : Promise >a : any "after"; diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols index 4cc5914692b..061364240f8 100644 --- a/tests/baselines/reference/awaitBinaryExpression5_es6.symbols +++ b/tests/baselines/reference/awaitBinaryExpression5_es6.symbols @@ -4,11 +4,11 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) async function func(): Promise { >func : Symbol(func, Decl(awaitBinaryExpression5_es6.ts, 1, 32)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var o: { a: boolean; }; @@ -19,6 +19,7 @@ async function func(): Promise { >o.a : Symbol(a, Decl(awaitBinaryExpression5_es6.ts, 4, 12)) >o : Symbol(o, Decl(awaitBinaryExpression5_es6.ts, 4, 7)) >a : Symbol(a, Decl(awaitBinaryExpression5_es6.ts, 4, 12)) +>p : Symbol(p, Decl(awaitBinaryExpression5_es6.ts, 1, 11)) "after"; } diff --git a/tests/baselines/reference/awaitBinaryExpression5_es6.types b/tests/baselines/reference/awaitBinaryExpression5_es6.types index 922e5887a77..8b76b6f8b88 100644 --- a/tests/baselines/reference/awaitBinaryExpression5_es6.types +++ b/tests/baselines/reference/awaitBinaryExpression5_es6.types @@ -22,7 +22,8 @@ async function func(): Promise { >o.a : boolean >o : { a: boolean; } >a : boolean ->p : any +>await p : boolean +>p : Promise "after"; >"after" : string diff --git a/tests/baselines/reference/awaitCallExpression1_es6.symbols b/tests/baselines/reference/awaitCallExpression1_es6.symbols index d70728a5b2d..debe9180bcc 100644 --- a/tests/baselines/reference/awaitCallExpression1_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression1_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression1_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression1_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression1_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression1_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >fn : Symbol(fn, Decl(awaitCallExpression1_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression1_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression1_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression1_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var b = fn(a, a, a); diff --git a/tests/baselines/reference/awaitCallExpression2_es6.symbols b/tests/baselines/reference/awaitCallExpression2_es6.symbols index 1ce953f5367..be9a11410c2 100644 --- a/tests/baselines/reference/awaitCallExpression2_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression2_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression2_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression2_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression2_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression2_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression2_es6.ts, 5, 43)) @@ -36,12 +36,13 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression2_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var b = fn(await p, a, a); >b : Symbol(b, Decl(awaitCallExpression2_es6.ts, 8, 7)) >fn : Symbol(fn, Decl(awaitCallExpression2_es6.ts, 1, 32)) +>p : Symbol(p, Decl(awaitCallExpression2_es6.ts, 1, 11)) >a : Symbol(a, Decl(awaitCallExpression2_es6.ts, 0, 11)) >a : Symbol(a, Decl(awaitCallExpression2_es6.ts, 0, 11)) diff --git a/tests/baselines/reference/awaitCallExpression2_es6.types b/tests/baselines/reference/awaitCallExpression2_es6.types index 6c7f02a578a..1617f4a14ff 100644 --- a/tests/baselines/reference/awaitCallExpression2_es6.types +++ b/tests/baselines/reference/awaitCallExpression2_es6.types @@ -45,7 +45,8 @@ async function func(): Promise { >b : void >fn(await p, a, a) : void >fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void ->p : any +>await p : boolean +>p : Promise >a : boolean >a : boolean diff --git a/tests/baselines/reference/awaitCallExpression3_es6.symbols b/tests/baselines/reference/awaitCallExpression3_es6.symbols index ea9c6934502..612e33c456c 100644 --- a/tests/baselines/reference/awaitCallExpression3_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression3_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression3_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression3_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression3_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression3_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression3_es6.ts, 5, 43)) @@ -36,13 +36,14 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression3_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var b = fn(a, await p, a); >b : Symbol(b, Decl(awaitCallExpression3_es6.ts, 8, 7)) >fn : Symbol(fn, Decl(awaitCallExpression3_es6.ts, 1, 32)) >a : Symbol(a, Decl(awaitCallExpression3_es6.ts, 0, 11)) +>p : Symbol(p, Decl(awaitCallExpression3_es6.ts, 1, 11)) >a : Symbol(a, Decl(awaitCallExpression3_es6.ts, 0, 11)) "after"; diff --git a/tests/baselines/reference/awaitCallExpression3_es6.types b/tests/baselines/reference/awaitCallExpression3_es6.types index 24d22db3c8c..6304a803f64 100644 --- a/tests/baselines/reference/awaitCallExpression3_es6.types +++ b/tests/baselines/reference/awaitCallExpression3_es6.types @@ -46,7 +46,8 @@ async function func(): Promise { >fn(a, await p, a) : void >fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void >a : boolean ->p : any +>await p : boolean +>p : Promise >a : boolean "after"; diff --git a/tests/baselines/reference/awaitCallExpression4_es6.symbols b/tests/baselines/reference/awaitCallExpression4_es6.symbols index f35e690bc6e..6925e5a44ea 100644 --- a/tests/baselines/reference/awaitCallExpression4_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression4_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression4_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression4_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression4_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression4_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >fn : Symbol(fn, Decl(awaitCallExpression4_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression4_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression4_es6.ts, 5, 43)) @@ -36,11 +36,12 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression4_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var b = (await pfn)(a, a, a); >b : Symbol(b, Decl(awaitCallExpression4_es6.ts, 8, 7)) +>pfn : Symbol(pfn, Decl(awaitCallExpression4_es6.ts, 4, 11)) >a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11)) >a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11)) >a : Symbol(a, Decl(awaitCallExpression4_es6.ts, 0, 11)) diff --git a/tests/baselines/reference/awaitCallExpression4_es6.types b/tests/baselines/reference/awaitCallExpression4_es6.types index 04115466427..ff5d8f4012b 100644 --- a/tests/baselines/reference/awaitCallExpression4_es6.types +++ b/tests/baselines/reference/awaitCallExpression4_es6.types @@ -45,7 +45,8 @@ async function func(): Promise { >b : void >(await pfn)(a, a, a) : void >(await pfn) : (arg0: boolean, arg1: boolean, arg2: boolean) => void ->pfn : any +>await pfn : (arg0: boolean, arg1: boolean, arg2: boolean) => void +>pfn : Promise<(arg0: boolean, arg1: boolean, arg2: boolean) => void> >a : boolean >a : boolean >a : boolean diff --git a/tests/baselines/reference/awaitCallExpression5_es6.symbols b/tests/baselines/reference/awaitCallExpression5_es6.symbols index 4c75a6fec6d..8bdce5cd12c 100644 --- a/tests/baselines/reference/awaitCallExpression5_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression5_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression5_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression5_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression5_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression5_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >fn : Symbol(fn, Decl(awaitCallExpression5_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression5_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression5_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression5_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var b = o.fn(a, a, a); diff --git a/tests/baselines/reference/awaitCallExpression6_es6.symbols b/tests/baselines/reference/awaitCallExpression6_es6.symbols index 0a053d172a0..ad79f75ab49 100644 --- a/tests/baselines/reference/awaitCallExpression6_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression6_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression6_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression6_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression6_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression6_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression6_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression6_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var b = o.fn(await p, a, a); @@ -44,6 +44,7 @@ async function func(): Promise { >o.fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 3, 16)) >o : Symbol(o, Decl(awaitCallExpression6_es6.ts, 3, 11)) >fn : Symbol(fn, Decl(awaitCallExpression6_es6.ts, 3, 16)) +>p : Symbol(p, Decl(awaitCallExpression6_es6.ts, 1, 11)) >a : Symbol(a, Decl(awaitCallExpression6_es6.ts, 0, 11)) >a : Symbol(a, Decl(awaitCallExpression6_es6.ts, 0, 11)) diff --git a/tests/baselines/reference/awaitCallExpression6_es6.types b/tests/baselines/reference/awaitCallExpression6_es6.types index d18377cebbb..3266733fab0 100644 --- a/tests/baselines/reference/awaitCallExpression6_es6.types +++ b/tests/baselines/reference/awaitCallExpression6_es6.types @@ -47,7 +47,8 @@ async function func(): Promise { >o.fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void >o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } >fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void ->p : any +>await p : boolean +>p : Promise >a : boolean >a : boolean diff --git a/tests/baselines/reference/awaitCallExpression7_es6.symbols b/tests/baselines/reference/awaitCallExpression7_es6.symbols index 41dd8bcaff9..0da1dd16016 100644 --- a/tests/baselines/reference/awaitCallExpression7_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression7_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression7_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression7_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression7_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression7_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression7_es6.ts, 5, 43)) @@ -36,7 +36,7 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression7_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var b = o.fn(a, await p, a); @@ -45,6 +45,7 @@ async function func(): Promise { >o : Symbol(o, Decl(awaitCallExpression7_es6.ts, 3, 11)) >fn : Symbol(fn, Decl(awaitCallExpression7_es6.ts, 3, 16)) >a : Symbol(a, Decl(awaitCallExpression7_es6.ts, 0, 11)) +>p : Symbol(p, Decl(awaitCallExpression7_es6.ts, 1, 11)) >a : Symbol(a, Decl(awaitCallExpression7_es6.ts, 0, 11)) "after"; diff --git a/tests/baselines/reference/awaitCallExpression7_es6.types b/tests/baselines/reference/awaitCallExpression7_es6.types index b213a75dcd6..b1b382f7325 100644 --- a/tests/baselines/reference/awaitCallExpression7_es6.types +++ b/tests/baselines/reference/awaitCallExpression7_es6.types @@ -48,7 +48,8 @@ async function func(): Promise { >o : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } >fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void >a : boolean ->p : any +>await p : boolean +>p : Promise >a : boolean "after"; diff --git a/tests/baselines/reference/awaitCallExpression8_es6.symbols b/tests/baselines/reference/awaitCallExpression8_es6.symbols index caaf10d4dba..d2d4fa2264d 100644 --- a/tests/baselines/reference/awaitCallExpression8_es6.symbols +++ b/tests/baselines/reference/awaitCallExpression8_es6.symbols @@ -4,7 +4,7 @@ declare var a: boolean; declare var p: Promise; >p : Symbol(p, Decl(awaitCallExpression8_es6.ts, 1, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function fn(arg0: boolean, arg1: boolean, arg2: boolean): void; >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 1, 32)) @@ -21,14 +21,14 @@ declare var o: { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }; declare var pfn: Promise<{ (arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >pfn : Symbol(pfn, Decl(awaitCallExpression8_es6.ts, 4, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 4, 28)) >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 4, 42)) >arg2 : Symbol(arg2, Decl(awaitCallExpression8_es6.ts, 4, 57)) declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }>; >po : Symbol(po, Decl(awaitCallExpression8_es6.ts, 5, 11)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25)) >arg0 : Symbol(arg0, Decl(awaitCallExpression8_es6.ts, 5, 29)) >arg1 : Symbol(arg1, Decl(awaitCallExpression8_es6.ts, 5, 43)) @@ -36,12 +36,13 @@ declare var po: Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; async function func(): Promise { >func : Symbol(func, Decl(awaitCallExpression8_es6.ts, 5, 84)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "before"; var b = (await po).fn(a, a, a); >b : Symbol(b, Decl(awaitCallExpression8_es6.ts, 8, 7)) >(await po).fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25)) +>po : Symbol(po, Decl(awaitCallExpression8_es6.ts, 5, 11)) >fn : Symbol(fn, Decl(awaitCallExpression8_es6.ts, 5, 25)) >a : Symbol(a, Decl(awaitCallExpression8_es6.ts, 0, 11)) >a : Symbol(a, Decl(awaitCallExpression8_es6.ts, 0, 11)) diff --git a/tests/baselines/reference/awaitCallExpression8_es6.types b/tests/baselines/reference/awaitCallExpression8_es6.types index 37511a7e3d7..76719c09c85 100644 --- a/tests/baselines/reference/awaitCallExpression8_es6.types +++ b/tests/baselines/reference/awaitCallExpression8_es6.types @@ -46,7 +46,8 @@ async function func(): Promise { >(await po).fn(a, a, a) : void >(await po).fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void >(await po) : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } ->po : any +>await po : { fn(arg0: boolean, arg1: boolean, arg2: boolean): void; } +>po : Promise<{ fn(arg0: boolean, arg1: boolean, arg2: boolean): void; }> >fn : (arg0: boolean, arg1: boolean, arg2: boolean) => void >a : boolean >a : boolean diff --git a/tests/baselines/reference/awaitUnion_es6.symbols b/tests/baselines/reference/awaitUnion_es6.symbols index ca0b9afaf92..48524c4526d 100644 --- a/tests/baselines/reference/awaitUnion_es6.symbols +++ b/tests/baselines/reference/awaitUnion_es6.symbols @@ -4,36 +4,41 @@ declare let a: number | string; declare let b: PromiseLike | PromiseLike; >b : Symbol(b, Decl(awaitUnion_es6.ts, 1, 11)) ->PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163)) ->PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, --, --)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, --, --)) declare let c: PromiseLike; >c : Symbol(c, Decl(awaitUnion_es6.ts, 2, 11)) ->PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, --, --)) declare let d: number | PromiseLike; >d : Symbol(d, Decl(awaitUnion_es6.ts, 3, 11)) ->PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, --, --)) declare let e: number | PromiseLike; >e : Symbol(e, Decl(awaitUnion_es6.ts, 4, 11)) ->PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, 1187, 163)) +>PromiseLike : Symbol(PromiseLike, Decl(lib.d.ts, --, --)) async function f() { >f : Symbol(f, Decl(awaitUnion_es6.ts, 4, 53)) let await_a = await a; >await_a : Symbol(await_a, Decl(awaitUnion_es6.ts, 6, 4)) +>a : Symbol(a, Decl(awaitUnion_es6.ts, 0, 11)) let await_b = await b; >await_b : Symbol(await_b, Decl(awaitUnion_es6.ts, 7, 4)) +>b : Symbol(b, Decl(awaitUnion_es6.ts, 1, 11)) let await_c = await c; >await_c : Symbol(await_c, Decl(awaitUnion_es6.ts, 8, 4)) +>c : Symbol(c, Decl(awaitUnion_es6.ts, 2, 11)) let await_d = await d; >await_d : Symbol(await_d, Decl(awaitUnion_es6.ts, 9, 4)) +>d : Symbol(d, Decl(awaitUnion_es6.ts, 3, 11)) let await_e = await e; >await_e : Symbol(await_e, Decl(awaitUnion_es6.ts, 10, 4)) +>e : Symbol(e, Decl(awaitUnion_es6.ts, 4, 11)) } diff --git a/tests/baselines/reference/awaitUnion_es6.types b/tests/baselines/reference/awaitUnion_es6.types index d0b5b6ccfd0..97d4bd2fc57 100644 --- a/tests/baselines/reference/awaitUnion_es6.types +++ b/tests/baselines/reference/awaitUnion_es6.types @@ -24,21 +24,26 @@ async function f() { let await_a = await a; >await_a : number | string ->a : any +>await a : number | string +>a : number | string let await_b = await b; >await_b : number | string ->b : any +>await b : number | string +>b : PromiseLike | PromiseLike let await_c = await c; >await_c : number | string ->c : any +>await c : number | string +>c : PromiseLike let await_d = await d; >await_d : number | string ->d : any +>await d : number | string +>d : number | PromiseLike let await_e = await e; >await_e : number | string ->e : any +>await e : number | string +>e : number | PromiseLike } diff --git a/tests/baselines/reference/badThisBinding.types b/tests/baselines/reference/badThisBinding.types index a6b1c478d53..201f3e70288 100644 --- a/tests/baselines/reference/badThisBinding.types +++ b/tests/baselines/reference/badThisBinding.types @@ -22,8 +22,8 @@ class Greeter { >() => { var x = this; } : () => void var x = this; ->x : Greeter ->this : Greeter +>x : this +>this : this }); }); diff --git a/tests/baselines/reference/baseTypeWrappingInstantiationChain.types b/tests/baselines/reference/baseTypeWrappingInstantiationChain.types index 747b672dd0d..ba702171de9 100644 --- a/tests/baselines/reference/baseTypeWrappingInstantiationChain.types +++ b/tests/baselines/reference/baseTypeWrappingInstantiationChain.types @@ -13,7 +13,7 @@ class C extends CBase { >CBaseBase : typeof CBaseBase >Wrapper : Wrapper >T1 : T1 ->this : C +>this : this } public alsoWorks() { >alsoWorks : () => void @@ -22,7 +22,7 @@ class C extends CBase { >new CBase(this) : CBase >CBase : typeof CBase >T1 : T1 ->this : C +>this : this } public method(t: Wrapper) { } diff --git a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols index e6b6def0944..626777523ab 100644 --- a/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols +++ b/tests/baselines/reference/bestCommonTypeOfConditionalExpressions.symbols @@ -58,20 +58,20 @@ var r6 = true ? (x: number) => { } : (x: Object) => { }; // returns number => vo >r6 : Symbol(r6, Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 3)) >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 17)) >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 17, 38)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r7: (x: Object) => void = true ? (x: number) => { } : (x: Object) => { }; >r7 : Symbol(r7, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 3)) >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 9)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 38)) >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 18, 59)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r8 = true ? (x: Object) => { } : (x: number) => { }; // returns Object => void >r8 : Symbol(r8, Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 3)) >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 17)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(bestCommonTypeOfConditionalExpressions.ts, 19, 38)) var r10: Base = true ? derived : derived2; // no error since we use the contextual type in BCT @@ -93,7 +93,7 @@ function foo5(t: T, u: U): Object { >T : Symbol(T, Decl(bestCommonTypeOfConditionalExpressions.ts, 23, 14)) >u : Symbol(u, Decl(bestCommonTypeOfConditionalExpressions.ts, 23, 25)) >U : Symbol(U, Decl(bestCommonTypeOfConditionalExpressions.ts, 23, 16)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) return true ? t : u; // BCT is Object >t : Symbol(t, Decl(bestCommonTypeOfConditionalExpressions.ts, 23, 20)) diff --git a/tests/baselines/reference/binopAssignmentShouldHaveType.symbols b/tests/baselines/reference/binopAssignmentShouldHaveType.symbols index d984647149e..98f4ffee743 100644 --- a/tests/baselines/reference/binopAssignmentShouldHaveType.symbols +++ b/tests/baselines/reference/binopAssignmentShouldHaveType.symbols @@ -21,12 +21,12 @@ module Test { >name : Symbol(name, Decl(binopAssignmentShouldHaveType.ts, 8, 6)) if ((name= this.getName()).length > 0) { ->(name= this.getName()).length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>(name= this.getName()).length : Symbol(String.length, Decl(lib.d.ts, --, --)) >name : Symbol(name, Decl(binopAssignmentShouldHaveType.ts, 8, 6)) >this.getName : Symbol(getName, Decl(binopAssignmentShouldHaveType.ts, 3, 19)) >this : Symbol(Bug, Decl(binopAssignmentShouldHaveType.ts, 2, 13)) >getName : Symbol(getName, Decl(binopAssignmentShouldHaveType.ts, 3, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) console.log(name); >console : Symbol(console, Decl(binopAssignmentShouldHaveType.ts, 0, 11)) diff --git a/tests/baselines/reference/binopAssignmentShouldHaveType.types b/tests/baselines/reference/binopAssignmentShouldHaveType.types index fdef2fbcabd..d09138bbb88 100644 --- a/tests/baselines/reference/binopAssignmentShouldHaveType.types +++ b/tests/baselines/reference/binopAssignmentShouldHaveType.types @@ -32,7 +32,7 @@ module Test { >name : string >this.getName() : string >this.getName : () => string ->this : Bug +>this : this >getName : () => string >length : number >0 : number diff --git a/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols b/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols index 1e2d28f51c2..39c16a701b6 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols +++ b/tests/baselines/reference/bitwiseNotOperatorWithStringType.symbols @@ -88,9 +88,9 @@ var ResultIsNumber11 = ~(STRING + STRING); var ResultIsNumber12 = ~STRING.charAt(0); >ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(bitwiseNotOperatorWithStringType.ts, 32, 3)) ->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(bitwiseNotOperatorWithStringType.ts, 1, 3)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) // multiple ~ operators var ResultIsNumber13 = ~~STRING; diff --git a/tests/baselines/reference/booleanPropertyAccess.symbols b/tests/baselines/reference/booleanPropertyAccess.symbols index c552f268d01..f69c3f6a789 100644 --- a/tests/baselines/reference/booleanPropertyAccess.symbols +++ b/tests/baselines/reference/booleanPropertyAccess.symbols @@ -4,12 +4,12 @@ var x = true; var a = x.toString(); >a : Symbol(a, Decl(booleanPropertyAccess.ts, 2, 3)) ->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(booleanPropertyAccess.ts, 0, 3)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) var b = x['toString'](); >b : Symbol(b, Decl(booleanPropertyAccess.ts, 3, 3)) >x : Symbol(x, Decl(booleanPropertyAccess.ts, 0, 3)) ->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/callSignatureAssignabilityInInheritance2.symbols b/tests/baselines/reference/callSignatureAssignabilityInInheritance2.symbols index d0fe78cb178..12bc165575b 100644 --- a/tests/baselines/reference/callSignatureAssignabilityInInheritance2.symbols +++ b/tests/baselines/reference/callSignatureAssignabilityInInheritance2.symbols @@ -110,23 +110,23 @@ interface A { // T a12: (x: Array, y: Array) => Array; >a12 : Symbol(a12, Decl(callSignatureAssignabilityInInheritance2.ts, 19, 71)) >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance2.ts, 20, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance2.ts, 0, 0)) >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance2.ts, 20, 25)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(callSignatureAssignabilityInInheritance2.ts, 3, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance2.ts, 2, 27)) a13: (x: Array, y: Array) => Array; >a13 : Symbol(a13, Decl(callSignatureAssignabilityInInheritance2.ts, 20, 64)) >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance2.ts, 21, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance2.ts, 0, 0)) >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance2.ts, 21, 25)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance2.ts, 2, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance2.ts, 2, 27)) a14: (x: { a: string; b: number }) => Object; @@ -134,7 +134,7 @@ interface A { // T >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance2.ts, 22, 10)) >a : Symbol(a, Decl(callSignatureAssignabilityInInheritance2.ts, 22, 14)) >b : Symbol(b, Decl(callSignatureAssignabilityInInheritance2.ts, 22, 25)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) a15: { >a15 : Symbol(a15, Decl(callSignatureAssignabilityInInheritance2.ts, 22, 49)) @@ -195,8 +195,8 @@ interface A { // T (a: Date): Date; >a : Symbol(a, Decl(callSignatureAssignabilityInInheritance2.ts, 42, 13)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) }): any[]; }; @@ -332,23 +332,23 @@ interface I extends A { a12: >(x: Array, y: T) => Array; // ok, less specific parameter type >a12 : Symbol(a12, Decl(callSignatureAssignabilityInInheritance2.ts, 60, 43)) >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance2.ts, 61, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance2.ts, 0, 0)) >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance2.ts, 61, 33)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance2.ts, 0, 0)) >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance2.ts, 61, 48)) >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance2.ts, 61, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance2.ts, 2, 27)) a13: >(x: Array, y: T) => T; // ok, T = Array, satisfies constraint, contextual signature instantiation succeeds >a13 : Symbol(a13, Decl(callSignatureAssignabilityInInheritance2.ts, 61, 73)) >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance2.ts, 62, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance2.ts, 2, 27)) >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance2.ts, 62, 36)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance2.ts, 0, 0)) >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance2.ts, 62, 51)) >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance2.ts, 62, 10)) diff --git a/tests/baselines/reference/callSignatureAssignabilityInInheritance5.symbols b/tests/baselines/reference/callSignatureAssignabilityInInheritance5.symbols index d5a68430887..89797dceb70 100644 --- a/tests/baselines/reference/callSignatureAssignabilityInInheritance5.symbols +++ b/tests/baselines/reference/callSignatureAssignabilityInInheritance5.symbols @@ -111,23 +111,23 @@ interface A { // T a12: (x: Array, y: Array) => Array; >a12 : Symbol(a12, Decl(callSignatureAssignabilityInInheritance5.ts, 20, 71)) >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance5.ts, 21, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance5.ts, 0, 0)) >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance5.ts, 21, 25)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(callSignatureAssignabilityInInheritance5.ts, 4, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance5.ts, 3, 27)) a13: (x: Array, y: Array) => Array; >a13 : Symbol(a13, Decl(callSignatureAssignabilityInInheritance5.ts, 21, 64)) >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance5.ts, 22, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance5.ts, 0, 0)) >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance5.ts, 22, 25)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance5.ts, 3, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance5.ts, 3, 27)) a14: (x: { a: string; b: number }) => Object; @@ -135,7 +135,7 @@ interface A { // T >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance5.ts, 23, 10)) >a : Symbol(a, Decl(callSignatureAssignabilityInInheritance5.ts, 23, 14)) >b : Symbol(b, Decl(callSignatureAssignabilityInInheritance5.ts, 23, 25)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface B extends A { @@ -280,23 +280,23 @@ interface I extends B { a12: >(x: Array, y: T) => Array; // ok, less specific parameter type >a12 : Symbol(a12, Decl(callSignatureAssignabilityInInheritance5.ts, 43, 43)) >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance5.ts, 44, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance5.ts, 0, 0)) >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance5.ts, 44, 33)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance5.ts, 0, 0)) >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance5.ts, 44, 48)) >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance5.ts, 44, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance5.ts, 3, 27)) a13: >(x: Array, y: T) => T; // ok, T = Array, satisfies constraint, contextual signature instantiation succeeds >a13 : Symbol(a13, Decl(callSignatureAssignabilityInInheritance5.ts, 44, 73)) >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance5.ts, 45, 10)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(callSignatureAssignabilityInInheritance5.ts, 3, 27)) >x : Symbol(x, Decl(callSignatureAssignabilityInInheritance5.ts, 45, 36)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(callSignatureAssignabilityInInheritance5.ts, 0, 0)) >y : Symbol(y, Decl(callSignatureAssignabilityInInheritance5.ts, 45, 51)) >T : Symbol(T, Decl(callSignatureAssignabilityInInheritance5.ts, 45, 10)) diff --git a/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType.symbols b/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType.symbols index f2b9de48425..414d9138f3c 100644 --- a/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType.symbols +++ b/tests/baselines/reference/callSignaturesThatDifferOnlyByReturnType.symbols @@ -54,7 +54,7 @@ var a: { (x, y): Object; >x : Symbol(x, Decl(callSignaturesThatDifferOnlyByReturnType.ts, 20, 5)) >y : Symbol(y, Decl(callSignaturesThatDifferOnlyByReturnType.ts, 20, 7)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) (x, y): any; // error >x : Symbol(x, Decl(callSignaturesThatDifferOnlyByReturnType.ts, 21, 5)) diff --git a/tests/baselines/reference/callWithSpread.symbols b/tests/baselines/reference/callWithSpread.symbols index c5ac7fe66b2..bc1dd7468c9 100644 --- a/tests/baselines/reference/callWithSpread.symbols +++ b/tests/baselines/reference/callWithSpread.symbols @@ -93,7 +93,7 @@ xa[1].foo(1, 2, ...a, "abc"); >a : Symbol(a, Decl(callWithSpread.ts, 7, 3)) (xa[1].foo)(...[1, 2, "abc"]); ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >xa[1].foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13)) >xa : Symbol(xa, Decl(callWithSpread.ts, 10, 3)) >foo : Symbol(X.foo, Decl(callWithSpread.ts, 0, 13)) diff --git a/tests/baselines/reference/callWithSpread.types b/tests/baselines/reference/callWithSpread.types index 8964708c05e..eae92c471e9 100644 --- a/tests/baselines/reference/callWithSpread.types +++ b/tests/baselines/reference/callWithSpread.types @@ -180,7 +180,7 @@ class C { this.foo(x, y); >this.foo(x, y) : void >this.foo : (x: number, y: number, ...z: string[]) => void ->this : C +>this : this >foo : (x: number, y: number, ...z: string[]) => void >x : number >y : number @@ -188,7 +188,7 @@ class C { this.foo(x, y, ...z); >this.foo(x, y, ...z) : void >this.foo : (x: number, y: number, ...z: string[]) => void ->this : C +>this : this >foo : (x: number, y: number, ...z: string[]) => void >x : number >y : number diff --git a/tests/baselines/reference/callWithSpreadES6.symbols b/tests/baselines/reference/callWithSpreadES6.symbols index d8604d8358a..26dd9b548d5 100644 --- a/tests/baselines/reference/callWithSpreadES6.symbols +++ b/tests/baselines/reference/callWithSpreadES6.symbols @@ -94,7 +94,7 @@ xa[1].foo(1, 2, ...a, "abc"); >a : Symbol(a, Decl(callWithSpreadES6.ts, 8, 3)) (xa[1].foo)(...[1, 2, "abc"]); ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(lib.d.ts, 4036, 1)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.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)) diff --git a/tests/baselines/reference/callWithSpreadES6.types b/tests/baselines/reference/callWithSpreadES6.types index 9c9e795ce24..b0c118855fe 100644 --- a/tests/baselines/reference/callWithSpreadES6.types +++ b/tests/baselines/reference/callWithSpreadES6.types @@ -181,7 +181,7 @@ class C { this.foo(x, y); >this.foo(x, y) : void >this.foo : (x: number, y: number, ...z: string[]) => void ->this : C +>this : this >foo : (x: number, y: number, ...z: string[]) => void >x : number >y : number @@ -189,7 +189,7 @@ class C { this.foo(x, y, ...z); >this.foo(x, y, ...z) : void >this.foo : (x: number, y: number, ...z: string[]) => void ->this : C +>this : this >foo : (x: number, y: number, ...z: string[]) => void >x : number >y : number diff --git a/tests/baselines/reference/callbacksDontShareTypes.symbols b/tests/baselines/reference/callbacksDontShareTypes.symbols index 80a5f234d38..1d7583cec2d 100644 --- a/tests/baselines/reference/callbacksDontShareTypes.symbols +++ b/tests/baselines/reference/callbacksDontShareTypes.symbols @@ -56,9 +56,9 @@ var c2: Collection; var rf1 = (x: number) => { return x.toFixed() }; >rf1 : Symbol(rf1, Decl(callbacksDontShareTypes.ts, 13, 3)) >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 13, 11)) ->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 13, 11)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) var r1a = _.map(c2, (x) => { return x.toFixed() }); >r1a : Symbol(r1a, Decl(callbacksDontShareTypes.ts, 14, 3)) @@ -67,9 +67,9 @@ var r1a = _.map(c2, (x) => { return x.toFixed() }); >map : Symbol(Combinators.map, Decl(callbacksDontShareTypes.ts, 5, 23), Decl(callbacksDontShareTypes.ts, 6, 63)) >c2 : Symbol(c2, Decl(callbacksDontShareTypes.ts, 11, 3)) >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 14, 21)) ->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 14, 21)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) var r1b = _.map(c2, rf1); // this line should not cause the following 2 to have errors >r1b : Symbol(r1b, Decl(callbacksDontShareTypes.ts, 15, 3)) @@ -86,9 +86,9 @@ var r5a = _.map(c2, (x) => { return x.toFixed() }); >map : Symbol(Combinators.map, Decl(callbacksDontShareTypes.ts, 5, 23), Decl(callbacksDontShareTypes.ts, 6, 63)) >c2 : Symbol(c2, Decl(callbacksDontShareTypes.ts, 11, 3)) >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 16, 37)) ->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(callbacksDontShareTypes.ts, 16, 37)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) var r5b = _.map(c2, rf1); >r5b : Symbol(r5b, Decl(callbacksDontShareTypes.ts, 17, 3)) diff --git a/tests/baselines/reference/captureThisInSuperCall.types b/tests/baselines/reference/captureThisInSuperCall.types index faa7d2ad97e..4a0902e9f1e 100644 --- a/tests/baselines/reference/captureThisInSuperCall.types +++ b/tests/baselines/reference/captureThisInSuperCall.types @@ -18,7 +18,7 @@ class B extends A { >() => this.someMethod() : () => void >this.someMethod() : void >this.someMethod : () => void ->this : B +>this : this >someMethod : () => void someMethod() {} diff --git a/tests/baselines/reference/castNewObjectBug.symbols b/tests/baselines/reference/castNewObjectBug.symbols index 3db7f7e065a..f9423710f4f 100644 --- a/tests/baselines/reference/castNewObjectBug.symbols +++ b/tests/baselines/reference/castNewObjectBug.symbols @@ -5,5 +5,5 @@ interface Foo { } var xx = new Object(); >xx : Symbol(xx, Decl(castNewObjectBug.ts, 1, 3)) >Foo : Symbol(Foo, Decl(castNewObjectBug.ts, 0, 0)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/chainedAssignment2.symbols b/tests/baselines/reference/chainedAssignment2.symbols index 84eb8428a64..3335c3cbb43 100644 --- a/tests/baselines/reference/chainedAssignment2.symbols +++ b/tests/baselines/reference/chainedAssignment2.symbols @@ -10,11 +10,11 @@ var c: boolean; var d: Date; >d : Symbol(d, Decl(chainedAssignment2.ts, 3, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var e: RegExp; >e : Symbol(e, Decl(chainedAssignment2.ts, 4, 3)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) a = b = c = d = e = null; >a : Symbol(a, Decl(chainedAssignment2.ts, 0, 3)) diff --git a/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols b/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols index 5eb563d3ef6..8232c44a620 100644 --- a/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols +++ b/tests/baselines/reference/chainedSpecializationToObjectTypeLiteral.symbols @@ -51,9 +51,9 @@ var s2 = s.groupBy(s => s.length); >s : Symbol(s, Decl(chainedSpecializationToObjectTypeLiteral.ts, 7, 3)) >groupBy : Symbol(Sequence.groupBy, Decl(chainedSpecializationToObjectTypeLiteral.ts, 3, 57)) >s : Symbol(s, Decl(chainedSpecializationToObjectTypeLiteral.ts, 8, 19)) ->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>s.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(chainedSpecializationToObjectTypeLiteral.ts, 8, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) var s3 = s2.each(x => { x.key /* Type is K, should be number */ }); >s3 : Symbol(s3, Decl(chainedSpecializationToObjectTypeLiteral.ts, 9, 3)) diff --git a/tests/baselines/reference/checkForObjectTooStrict.symbols b/tests/baselines/reference/checkForObjectTooStrict.symbols index 48e04392c3b..e47aa47c9d1 100644 --- a/tests/baselines/reference/checkForObjectTooStrict.symbols +++ b/tests/baselines/reference/checkForObjectTooStrict.symbols @@ -29,12 +29,12 @@ class Bar extends Foo.Object { // should work class Baz extends Object { >Baz : Symbol(Baz, Decl(checkForObjectTooStrict.ts, 18, 1)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) constructor () { // ERROR, as expected super(); ->super : Symbol(ObjectConstructor, Decl(lib.d.ts, 124, 1)) +>super : Symbol(ObjectConstructor, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/classAbstractDeclarations.d.errors.txt b/tests/baselines/reference/classAbstractDeclarations.d.errors.txt index 20d5ca46933..a1c0e55152c 100644 --- a/tests/baselines/reference/classAbstractDeclarations.d.errors.txt +++ b/tests/baselines/reference/classAbstractDeclarations.d.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,5): error TS1242: 'abstract' modifier can only appear on a class or method declaration. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,28): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(2,28): error TS1183: An implementation cannot be declared in ambient contexts. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(11,15): error TS2515: Non-abstract class 'CC' does not implement inherited abstract member 'foo' from class 'AA'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(13,15): error TS2515: Non-abstract class 'DD' does not implement inherited abstract member 'foo' from class 'BB'. tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractDeclarations.d.ts(17,15): error TS2515: Non-abstract class 'FF' does not implement inherited abstract member 'foo' from class 'CC'. @@ -11,7 +11,7 @@ tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbst ~~~~~~~~ !!! error TS1242: 'abstract' modifier can only appear on a class or method declaration. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } declare abstract class AA { diff --git a/tests/baselines/reference/classAbstractMultiLineDecl.errors.txt b/tests/baselines/reference/classAbstractMultiLineDecl.errors.txt deleted file mode 100644 index 5af440ed4df..00000000000 --- a/tests/baselines/reference/classAbstractMultiLineDecl.errors.txt +++ /dev/null @@ -1,24 +0,0 @@ -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts(10,1): error TS2511: Cannot create an instance of the abstract class 'A'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts(11,1): error TS2511: Cannot create an instance of the abstract class 'B'. -tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts(12,1): error TS2511: Cannot create an instance of the abstract class 'C'. - - -==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts (3 errors) ==== - abstract class A {} - - abstract - class B {} - - abstract - - class C {} - - new A; - ~~~~~ -!!! error TS2511: Cannot create an instance of the abstract class 'A'. - new B; - ~~~~~ -!!! error TS2511: Cannot create an instance of the abstract class 'B'. - new C; - ~~~~~ -!!! error TS2511: Cannot create an instance of the abstract class 'C'. \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractSingleLineDecl.errors.txt b/tests/baselines/reference/classAbstractSingleLineDecl.errors.txt new file mode 100644 index 00000000000..0670ea108ea --- /dev/null +++ b/tests/baselines/reference/classAbstractSingleLineDecl.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSingleLineDecl.ts(3,1): error TS2304: Cannot find name 'abstract'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSingleLineDecl.ts(6,1): error TS2304: Cannot find name 'abstract'. +tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSingleLineDecl.ts(10,1): error TS2511: Cannot create an instance of the abstract class 'A'. + + +==== tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSingleLineDecl.ts (3 errors) ==== + abstract class A {} + + abstract + ~~~~~~~~ +!!! error TS2304: Cannot find name 'abstract'. + class B {} + + abstract + ~~~~~~~~ +!!! error TS2304: Cannot find name 'abstract'. + + class C {} + + new A; + ~~~~~ +!!! error TS2511: Cannot create an instance of the abstract class 'A'. + new B; + new C; \ No newline at end of file diff --git a/tests/baselines/reference/classAbstractMultiLineDecl.js b/tests/baselines/reference/classAbstractSingleLineDecl.js similarity index 72% rename from tests/baselines/reference/classAbstractMultiLineDecl.js rename to tests/baselines/reference/classAbstractSingleLineDecl.js index 3a92e2aa1e5..772ed564a66 100644 --- a/tests/baselines/reference/classAbstractMultiLineDecl.js +++ b/tests/baselines/reference/classAbstractSingleLineDecl.js @@ -1,4 +1,4 @@ -//// [classAbstractMultiLineDecl.ts] +//// [classAbstractSingleLineDecl.ts] abstract class A {} abstract @@ -12,17 +12,19 @@ new A; new B; new C; -//// [classAbstractMultiLineDecl.js] +//// [classAbstractSingleLineDecl.js] var A = (function () { function A() { } return A; })(); +abstract; var B = (function () { function B() { } return B; })(); +abstract; var C = (function () { function C() { } diff --git a/tests/baselines/reference/classAppearsToHaveMembersOfObject.symbols b/tests/baselines/reference/classAppearsToHaveMembersOfObject.symbols index c035b17bcc6..28c31e639a7 100644 --- a/tests/baselines/reference/classAppearsToHaveMembersOfObject.symbols +++ b/tests/baselines/reference/classAppearsToHaveMembersOfObject.symbols @@ -9,19 +9,19 @@ var c: C; var r = c.toString(); >r : Symbol(r, Decl(classAppearsToHaveMembersOfObject.ts, 3, 3)) ->c.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>c.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >c : Symbol(c, Decl(classAppearsToHaveMembersOfObject.ts, 2, 3)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) var r2 = c.hasOwnProperty(''); >r2 : Symbol(r2, Decl(classAppearsToHaveMembersOfObject.ts, 4, 3)) ->c.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>c.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) >c : Symbol(c, Decl(classAppearsToHaveMembersOfObject.ts, 2, 3)) ->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) var o: Object = c; >o : Symbol(o, Decl(classAppearsToHaveMembersOfObject.ts, 5, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >c : Symbol(c, Decl(classAppearsToHaveMembersOfObject.ts, 2, 3)) var o2: {} = c; diff --git a/tests/baselines/reference/classConstructorParametersAccessibility3.types b/tests/baselines/reference/classConstructorParametersAccessibility3.types index 3372044569c..d664aaf3172 100644 --- a/tests/baselines/reference/classConstructorParametersAccessibility3.types +++ b/tests/baselines/reference/classConstructorParametersAccessibility3.types @@ -20,7 +20,7 @@ class Derived extends Base { this.p; // OK >this.p : number ->this : Derived +>this : this >p : number } } diff --git a/tests/baselines/reference/classExpressionES63.js b/tests/baselines/reference/classExpressionES63.js index 6d357af7c5a..6b3a06cf7c3 100644 --- a/tests/baselines/reference/classExpressionES63.js +++ b/tests/baselines/reference/classExpressionES63.js @@ -7,7 +7,7 @@ c.c; //// [classExpressionES63.js] -let C = class class_1 extends class class_2 extends class class_3 { +let C = class extends class extends class { constructor() { this.a = 1; } diff --git a/tests/baselines/reference/classExpressionWithDecorator1.js b/tests/baselines/reference/classExpressionWithDecorator1.js index 4b1700df7af..8494ec32cda 100644 --- a/tests/baselines/reference/classExpressionWithDecorator1.js +++ b/tests/baselines/reference/classExpressionWithDecorator1.js @@ -3,12 +3,10 @@ var v = @decorate class C { static p = 1 }; //// [classExpressionWithDecorator1.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var v = ; var C = (function () { diff --git a/tests/baselines/reference/classExtendingBuiltinType.symbols b/tests/baselines/reference/classExtendingBuiltinType.symbols index 08e85be570e..78f2195c8db 100644 --- a/tests/baselines/reference/classExtendingBuiltinType.symbols +++ b/tests/baselines/reference/classExtendingBuiltinType.symbols @@ -1,41 +1,41 @@ === tests/cases/conformance/classes/classDeclarations/classExtendingBuiltinType.ts === class C1 extends Object { } >C1 : Symbol(C1, Decl(classExtendingBuiltinType.ts, 0, 0)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) class C2 extends Function { } >C2 : Symbol(C2, Decl(classExtendingBuiltinType.ts, 0, 27)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) class C3 extends String { } >C3 : Symbol(C3, Decl(classExtendingBuiltinType.ts, 1, 29)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) class C4 extends Boolean { } >C4 : Symbol(C4, Decl(classExtendingBuiltinType.ts, 2, 27)) ->Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11)) +>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) class C5 extends Number { } >C5 : Symbol(C5, Decl(classExtendingBuiltinType.ts, 3, 28)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) class C6 extends Date { } >C6 : Symbol(C6, Decl(classExtendingBuiltinType.ts, 4, 27)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) class C7 extends RegExp { } >C7 : Symbol(C7, Decl(classExtendingBuiltinType.ts, 5, 25)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) class C8 extends Error { } >C8 : Symbol(C8, Decl(classExtendingBuiltinType.ts, 6, 27)) ->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) class C9 extends Array { } >C9 : Symbol(C9, Decl(classExtendingBuiltinType.ts, 7, 26)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) class C10 extends Array { } >C10 : Symbol(C10, Decl(classExtendingBuiltinType.ts, 8, 26)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/classOrder2.types b/tests/baselines/reference/classOrder2.types index 07bd6ba45a5..ac65da2ec9d 100644 --- a/tests/baselines/reference/classOrder2.types +++ b/tests/baselines/reference/classOrder2.types @@ -8,7 +8,7 @@ class A extends B { >foo : () => void >this.bar() : void >this.bar : () => void ->this : A +>this : this >bar : () => void } diff --git a/tests/baselines/reference/classOrderBug.types b/tests/baselines/reference/classOrderBug.types index 979b65b8008..703a87adc4f 100644 --- a/tests/baselines/reference/classOrderBug.types +++ b/tests/baselines/reference/classOrderBug.types @@ -11,7 +11,7 @@ class bar { this.baz = new foo(); >this.baz = new foo() : foo >this.baz : foo ->this : bar +>this : this >baz : foo >new foo() : foo >foo : typeof foo diff --git a/tests/baselines/reference/classSideInheritance2.types b/tests/baselines/reference/classSideInheritance2.types index 9c2d632ebbb..7a3ee630266 100644 --- a/tests/baselines/reference/classSideInheritance2.types +++ b/tests/baselines/reference/classSideInheritance2.types @@ -41,7 +41,7 @@ class TextBase implements IText { return new SubText(this, span); >new SubText(this, span) : SubText >SubText : typeof SubText ->this : TextBase +>this : this >span : TextSpan } } diff --git a/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface.symbols b/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface.symbols index 7239eac77e6..e30810f5cf9 100644 --- a/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface.symbols +++ b/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface.symbols @@ -20,11 +20,11 @@ class C { [x: string]: Object; >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface.ts, 7, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [x: number]: Object; >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface.ts, 8, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) 0: number; } @@ -44,11 +44,11 @@ interface I { [x: string]: Object; >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface.ts, 16, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [x: number]: Object; >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface.ts, 17, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) 0: number; } diff --git a/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface2.symbols b/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface2.symbols index 48bcbfa5149..13a716f9e8c 100644 --- a/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface2.symbols +++ b/tests/baselines/reference/classWithOnlyPublicMembersEquivalentToInterface2.symbols @@ -20,11 +20,11 @@ class C { [x: string]: Object; >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface2.ts, 7, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [x: number]: Object; >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface2.ts, 8, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) 0: number; @@ -47,11 +47,11 @@ interface I { [x: string]: Object; >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface2.ts, 18, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [x: number]: Object; >x : Symbol(x, Decl(classWithOnlyPublicMembersEquivalentToInterface2.ts, 19, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) 0: number; } diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols index 4b7f24a9048..ba9618a5ecf 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandAnyType.symbols @@ -13,7 +13,7 @@ var STRING: string; var OBJECT: Object; >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandAnyType.ts, 4, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //The second operand type is any ANY, ANY; @@ -75,8 +75,8 @@ var x: any; "string", [null, 1]; "string".charAt(0), [null, 1]; ->"string".charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>"string".charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) true, x("any"); >x : Symbol(x, Decl(commaOperatorWithSecondOperandAnyType.ts, 21, 3)) @@ -99,8 +99,8 @@ var resultIsAny8 = ("string", null); var resultIsAny9 = ("string".charAt(0), undefined); >resultIsAny9 : Symbol(resultIsAny9, Decl(commaOperatorWithSecondOperandAnyType.ts, 33, 3)) ->"string".charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>"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")); diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols index bd520c1876d..9be885bf41c 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandBooleanType.symbols @@ -13,7 +13,7 @@ var STRING: string; var OBJECT: Object; >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandBooleanType.ts, 4, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //The second operand type is boolean ANY, BOOLEAN; diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols index 3da456eaa5f..bf5ff9437a3 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandNumberType.symbols @@ -13,7 +13,7 @@ var STRING: string; var OBJECT: Object; >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandNumberType.ts, 4, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //The second operand type is number ANY, NUMBER; @@ -79,9 +79,9 @@ BOOLEAN = false, 1; >NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) STRING.trim(), NUMBER = 1; ->STRING.trim : Symbol(String.trim, Decl(lib.d.ts, 411, 32)) +>STRING.trim : Symbol(String.trim, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) ->trim : Symbol(String.trim, Decl(lib.d.ts, 411, 32)) +>trim : Symbol(String.trim, Decl(lib.d.ts, --, --)) >NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) var resultIsNumber6 = (null, NUMBER); @@ -107,8 +107,8 @@ var resultIsNumber10 = ("", NUMBER = 1); var resultIsNumber11 = (STRING.trim(), NUMBER = 1); >resultIsNumber11 : Symbol(resultIsNumber11, Decl(commaOperatorWithSecondOperandNumberType.ts, 33, 3)) ->STRING.trim : Symbol(String.trim, Decl(lib.d.ts, 411, 32)) +>STRING.trim : Symbol(String.trim, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandNumberType.ts, 3, 3)) ->trim : Symbol(String.trim, Decl(lib.d.ts, 411, 32)) +>trim : Symbol(String.trim, Decl(lib.d.ts, --, --)) >NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandNumberType.ts, 2, 3)) diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols index 42f24f77d50..3b8473318c0 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandObjectType.symbols @@ -13,7 +13,7 @@ var STRING: string; var OBJECT: Object; >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) class CLASS { >CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 19)) @@ -82,12 +82,12 @@ true, {} >BOOLEAN : Symbol(BOOLEAN, Decl(commaOperatorWithSecondOperandObjectType.ts, 1, 3)) "string", new Date() ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) STRING.toLowerCase(), new CLASS() ->STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) ->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 19)) var resultIsObject6 = (null, OBJECT); @@ -110,12 +110,12 @@ var resultIsObject9 = (!BOOLEAN, { a: 1, b: "s" }); var resultIsObject10 = ("string", new Date()); >resultIsObject10 : Symbol(resultIsObject10, Decl(commaOperatorWithSecondOperandObjectType.ts, 36, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var resultIsObject11 = (STRING.toLowerCase(), new CLASS()); >resultIsObject11 : Symbol(resultIsObject11, Decl(commaOperatorWithSecondOperandObjectType.ts, 37, 3)) ->STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>STRING.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandObjectType.ts, 3, 3)) ->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >CLASS : Symbol(CLASS, Decl(commaOperatorWithSecondOperandObjectType.ts, 4, 19)) diff --git a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols index d0c800858f7..3c674237a21 100644 --- a/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols +++ b/tests/baselines/reference/commaOperatorWithSecondOperandStringType.symbols @@ -13,7 +13,7 @@ var STRING: string; var OBJECT: Object; >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var resultIsString: string; >resultIsString : Symbol(resultIsString, Decl(commaOperatorWithSecondOperandStringType.ts, 6, 3)) @@ -71,7 +71,7 @@ null, STRING; ANY = new Date(), STRING; >ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) true, ""; @@ -80,13 +80,13 @@ BOOLEAN == undefined, ""; >undefined : Symbol(undefined) ["a", "b"], NUMBER.toString(); ->NUMBER.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>NUMBER.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) OBJECT = new Object, STRING + "string"; >OBJECT : Symbol(OBJECT, Decl(commaOperatorWithSecondOperandStringType.ts, 4, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString6 = (null, STRING); @@ -96,7 +96,7 @@ var resultIsString6 = (null, STRING); var resultIsString7 = (ANY = new Date(), STRING); >resultIsString7 : Symbol(resultIsString7, Decl(commaOperatorWithSecondOperandStringType.ts, 31, 3)) >ANY : Symbol(ANY, Decl(commaOperatorWithSecondOperandStringType.ts, 0, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) var resultIsString8 = (true, ""); @@ -109,12 +109,12 @@ var resultIsString9 = (BOOLEAN == undefined, ""); var resultIsString10 = (["a", "b"], NUMBER.toString()); >resultIsString10 : Symbol(resultIsString10, Decl(commaOperatorWithSecondOperandStringType.ts, 34, 3)) ->NUMBER.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>NUMBER.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >NUMBER : Symbol(NUMBER, Decl(commaOperatorWithSecondOperandStringType.ts, 2, 3)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) var resultIsString11 = (new Object, STRING + "string"); >resultIsString11 : Symbol(resultIsString11, Decl(commaOperatorWithSecondOperandStringType.ts, 35, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(commaOperatorWithSecondOperandStringType.ts, 3, 3)) diff --git a/tests/baselines/reference/commaOperatorsMultipleOperators.symbols b/tests/baselines/reference/commaOperatorsMultipleOperators.symbols index bd39a21519f..3a580bc49e9 100644 --- a/tests/baselines/reference/commaOperatorsMultipleOperators.symbols +++ b/tests/baselines/reference/commaOperatorsMultipleOperators.symbols @@ -13,7 +13,7 @@ var STRING: string; var OBJECT: Object; >OBJECT : Symbol(OBJECT, Decl(commaOperatorsMultipleOperators.ts, 4, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //Expected: work well ANY, BOOLEAN, NUMBER; @@ -76,10 +76,10 @@ var resultIsObject1 = (NUMBER, STRING, OBJECT); null, true, 1; ++NUMBER, STRING.charAt(0), new Object(); >NUMBER : Symbol(NUMBER, Decl(commaOperatorsMultipleOperators.ts, 2, 3)) ->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>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, 24, 3)) @@ -87,8 +87,8 @@ var resultIsNumber2 = (null, true, 1); var resultIsObject2 = (++NUMBER, STRING.charAt(0), new Object()); >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, 279, 23)) +>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(commaOperatorsMultipleOperators.ts, 3, 3)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>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/commentInMethodCall.symbols b/tests/baselines/reference/commentInMethodCall.symbols index ff286983e23..9db0719cf89 100644 --- a/tests/baselines/reference/commentInMethodCall.symbols +++ b/tests/baselines/reference/commentInMethodCall.symbols @@ -4,9 +4,9 @@ var s: string[]; >s : Symbol(s, Decl(commentInMethodCall.ts, 1, 3)) s.map(// do something ->s.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>s.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(commentInMethodCall.ts, 1, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) function () { }); diff --git a/tests/baselines/reference/commentsClassMembers.types b/tests/baselines/reference/commentsClassMembers.types index fbd514bf77b..b599edc0463 100644 --- a/tests/baselines/reference/commentsClassMembers.types +++ b/tests/baselines/reference/commentsClassMembers.types @@ -16,7 +16,7 @@ class c1 { return this.p1 + b; >this.p1 + b : number >this.p1 : number ->this : c1 +>this : this >p1 : number >b : number @@ -28,10 +28,10 @@ class c1 { return this.p2(this.p1); >this.p2(this.p1) : number >this.p2 : (b: number) => number ->this : c1 +>this : this >p2 : (b: number) => number >this.p1 : number ->this : c1 +>this : this >p1 : number }// trailing comment Getter @@ -43,11 +43,11 @@ class c1 { this.p1 = this.p2(value); >this.p1 = this.p2(value) : number >this.p1 : number ->this : c1 +>this : this >p1 : number >this.p2(value) : number >this.p2 : (b: number) => number ->this : c1 +>this : this >p2 : (b: number) => number >value : number @@ -64,7 +64,7 @@ class c1 { return this.p1 + b; >this.p1 + b : number >this.p1 : number ->this : c1 +>this : this >p1 : number >b : number @@ -76,10 +76,10 @@ class c1 { return this.pp2(this.pp1); >this.pp2(this.pp1) : number >this.pp2 : (b: number) => number ->this : c1 +>this : this >pp2 : (b: number) => number >this.pp1 : number ->this : c1 +>this : this >pp1 : number } /** setter property*/ @@ -90,11 +90,11 @@ class c1 { this.pp1 = this.pp2(value); >this.pp1 = this.pp2(value) : number >this.pp1 : number ->this : c1 +>this : this >pp1 : number >this.pp2(value) : number >this.pp2 : (b: number) => number ->this : c1 +>this : this >pp2 : (b: number) => number >value : number } @@ -158,7 +158,7 @@ class c1 { return this.nc_p1 + b; >this.nc_p1 + b : number >this.nc_p1 : number ->this : c1 +>this : this >nc_p1 : number >b : number } @@ -168,10 +168,10 @@ class c1 { return this.nc_p2(this.nc_p1); >this.nc_p2(this.nc_p1) : number >this.nc_p2 : (b: number) => number ->this : c1 +>this : this >nc_p2 : (b: number) => number >this.nc_p1 : number ->this : c1 +>this : this >nc_p1 : number } public set nc_p3(value: number) { @@ -181,11 +181,11 @@ class c1 { this.nc_p1 = this.nc_p2(value); >this.nc_p1 = this.nc_p2(value) : number >this.nc_p1 : number ->this : c1 +>this : this >nc_p1 : number >this.nc_p2(value) : number >this.nc_p2 : (b: number) => number ->this : c1 +>this : this >nc_p2 : (b: number) => number >value : number } @@ -199,7 +199,7 @@ class c1 { return this.nc_pp1 + b; >this.nc_pp1 + b : number >this.nc_pp1 : number ->this : c1 +>this : this >nc_pp1 : number >b : number } @@ -209,10 +209,10 @@ class c1 { return this.nc_pp2(this.nc_pp1); >this.nc_pp2(this.nc_pp1) : number >this.nc_pp2 : (b: number) => number ->this : c1 +>this : this >nc_pp2 : (b: number) => number >this.nc_pp1 : number ->this : c1 +>this : this >nc_pp1 : number } private set nc_pp3(value: number) { @@ -222,11 +222,11 @@ class c1 { this.nc_pp1 = this.nc_pp2(value); >this.nc_pp1 = this.nc_pp2(value) : number >this.nc_pp1 : number ->this : c1 +>this : this >nc_pp1 : number >this.nc_pp2(value) : number >this.nc_pp2 : (b: number) => number ->this : c1 +>this : this >nc_pp2 : (b: number) => number >value : number } @@ -284,7 +284,7 @@ class c1 { return this.a_p1 + b; >this.a_p1 + b : number >this.a_p1 : number ->this : c1 +>this : this >a_p1 : number >b : number } @@ -295,10 +295,10 @@ class c1 { return this.a_p2(this.a_p1); >this.a_p2(this.a_p1) : number >this.a_p2 : (b: number) => number ->this : c1 +>this : this >a_p2 : (b: number) => number >this.a_p1 : number ->this : c1 +>this : this >a_p1 : number } // setter property @@ -309,11 +309,11 @@ class c1 { this.a_p1 = this.a_p2(value); >this.a_p1 = this.a_p2(value) : number >this.a_p1 : number ->this : c1 +>this : this >a_p1 : number >this.a_p2(value) : number >this.a_p2 : (b: number) => number ->this : c1 +>this : this >a_p2 : (b: number) => number >value : number } @@ -329,7 +329,7 @@ class c1 { return this.a_p1 + b; >this.a_p1 + b : number >this.a_p1 : number ->this : c1 +>this : this >a_p1 : number >b : number } @@ -340,10 +340,10 @@ class c1 { return this.a_pp2(this.a_pp1); >this.a_pp2(this.a_pp1) : number >this.a_pp2 : (b: number) => number ->this : c1 +>this : this >a_pp2 : (b: number) => number >this.a_pp1 : number ->this : c1 +>this : this >a_pp1 : number } // setter property @@ -354,11 +354,11 @@ class c1 { this.a_pp1 = this.a_pp2(value); >this.a_pp1 = this.a_pp2(value) : number >this.a_pp1 : number ->this : c1 +>this : this >a_pp1 : number >this.a_pp2(value) : number >this.a_pp2 : (b: number) => number ->this : c1 +>this : this >a_pp2 : (b: number) => number >value : number } @@ -422,7 +422,7 @@ class c1 { return this.b_p1 + b; >this.b_p1 + b : number >this.b_p1 : number ->this : c1 +>this : this >b_p1 : number >b : number } @@ -433,10 +433,10 @@ class c1 { return this.b_p2(this.b_p1); >this.b_p2(this.b_p1) : number >this.b_p2 : (b: number) => number ->this : c1 +>this : this >b_p2 : (b: number) => number >this.b_p1 : number ->this : c1 +>this : this >b_p1 : number } /** setter property */ @@ -447,11 +447,11 @@ class c1 { this.b_p1 = this.b_p2(value); >this.b_p1 = this.b_p2(value) : number >this.b_p1 : number ->this : c1 +>this : this >b_p1 : number >this.b_p2(value) : number >this.b_p2 : (b: number) => number ->this : c1 +>this : this >b_p2 : (b: number) => number >value : number } @@ -467,7 +467,7 @@ class c1 { return this.b_p1 + b; >this.b_p1 + b : number >this.b_p1 : number ->this : c1 +>this : this >b_p1 : number >b : number } @@ -478,10 +478,10 @@ class c1 { return this.b_pp2(this.b_pp1); >this.b_pp2(this.b_pp1) : number >this.b_pp2 : (b: number) => number ->this : c1 +>this : this >b_pp2 : (b: number) => number >this.b_pp1 : number ->this : c1 +>this : this >b_pp1 : number } /** setter property */ @@ -492,11 +492,11 @@ class c1 { this.b_pp1 = this.b_pp2(value); >this.b_pp1 = this.b_pp2(value) : number >this.b_pp1 : number ->this : c1 +>this : this >b_pp1 : number >this.b_pp2(value) : number >this.b_pp2 : (b: number) => number ->this : c1 +>this : this >b_pp2 : (b: number) => number >value : number } @@ -704,7 +704,7 @@ class cProperties { return this.val; >this.val : number ->this : cProperties +>this : this >val : number } // trailing comment of only getter @@ -713,7 +713,7 @@ class cProperties { return this.val; >this.val : number ->this : cProperties +>this : this >val : number } /**setter only property*/ @@ -724,7 +724,7 @@ class cProperties { this.val = value; >this.val = value : number >this.val : number ->this : cProperties +>this : this >val : number >value : number } @@ -735,7 +735,7 @@ class cProperties { this.val = value; >this.val = value : number >this.val : number ->this : cProperties +>this : this >val : number >value : number diff --git a/tests/baselines/reference/commentsInheritance.types b/tests/baselines/reference/commentsInheritance.types index 1c25f13937b..21dcde99dbf 100644 --- a/tests/baselines/reference/commentsInheritance.types +++ b/tests/baselines/reference/commentsInheritance.types @@ -170,7 +170,7 @@ class c2 { this.c2_p1 = a; >this.c2_p1 = a : number >this.c2_p1 : number ->this : c2 +>this : this >c2_p1 : number >a : number } diff --git a/tests/baselines/reference/commentsdoNotEmitComments.types b/tests/baselines/reference/commentsdoNotEmitComments.types index 024f1c2a21f..067275f2151 100644 --- a/tests/baselines/reference/commentsdoNotEmitComments.types +++ b/tests/baselines/reference/commentsdoNotEmitComments.types @@ -43,7 +43,7 @@ class c { return this.b; >this.b : number ->this : c +>this : this >b : number } @@ -53,7 +53,7 @@ class c { return this.b; >this.b : number ->this : c +>this : this >b : number } @@ -65,7 +65,7 @@ class c { this.b = val; >this.b = val : number >this.b : number ->this : c +>this : this >b : number >val : number } diff --git a/tests/baselines/reference/commentsemitComments.types b/tests/baselines/reference/commentsemitComments.types index 2311ca09dd0..2594fb53fe9 100644 --- a/tests/baselines/reference/commentsemitComments.types +++ b/tests/baselines/reference/commentsemitComments.types @@ -43,7 +43,7 @@ class c { return this.b; >this.b : number ->this : c +>this : this >b : number } @@ -53,7 +53,7 @@ class c { return this.b; >this.b : number ->this : c +>this : this >b : number } @@ -65,7 +65,7 @@ class c { this.b = val; >this.b = val : number >this.b : number ->this : c +>this : this >b : number >val : number } diff --git a/tests/baselines/reference/comparisonOperatorWithIdenticalObjects.symbols b/tests/baselines/reference/comparisonOperatorWithIdenticalObjects.symbols index c6586cc3068..a5acf69be2f 100644 --- a/tests/baselines/reference/comparisonOperatorWithIdenticalObjects.symbols +++ b/tests/baselines/reference/comparisonOperatorWithIdenticalObjects.symbols @@ -16,7 +16,7 @@ class A1 { public e: Object; >e : Symbol(e, Decl(comparisonOperatorWithIdenticalObjects.ts, 4, 18)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) public fn(a: string): string { >fn : Symbol(fn, Decl(comparisonOperatorWithIdenticalObjects.ts, 5, 21)) @@ -42,7 +42,7 @@ class B1 { public e: Object; >e : Symbol(e, Decl(comparisonOperatorWithIdenticalObjects.ts, 14, 18)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) public fn(b: string): string { >fn : Symbol(fn, Decl(comparisonOperatorWithIdenticalObjects.ts, 15, 21)) diff --git a/tests/baselines/reference/complexClassRelationships.types b/tests/baselines/reference/complexClassRelationships.types index 43d0232e30a..525baf5168a 100644 --- a/tests/baselines/reference/complexClassRelationships.types +++ b/tests/baselines/reference/complexClassRelationships.types @@ -79,14 +79,14 @@ class Foo { return new GenericType(this); >new GenericType(this) : GenericType >GenericType : typeof GenericType ->this : Foo +>this : this } public populate() { >populate : () => void this.prop2; >this.prop2 : BaseCollection ->this : Foo +>this : this >prop2 : BaseCollection } public get prop2(): BaseCollection { diff --git a/tests/baselines/reference/computedPropertyNames22_ES5.types b/tests/baselines/reference/computedPropertyNames22_ES5.types index d3008669b4d..ca59250825c 100644 --- a/tests/baselines/reference/computedPropertyNames22_ES5.types +++ b/tests/baselines/reference/computedPropertyNames22_ES5.types @@ -12,7 +12,7 @@ class C { [this.bar()]() { } >this.bar() : number >this.bar : () => number ->this : C +>this : this >bar : () => number }; diff --git a/tests/baselines/reference/computedPropertyNames22_ES6.types b/tests/baselines/reference/computedPropertyNames22_ES6.types index 0936eab29ab..d5fbce29f7d 100644 --- a/tests/baselines/reference/computedPropertyNames22_ES6.types +++ b/tests/baselines/reference/computedPropertyNames22_ES6.types @@ -12,7 +12,7 @@ class C { [this.bar()]() { } >this.bar() : number >this.bar : () => number ->this : C +>this : this >bar : () => number }; diff --git a/tests/baselines/reference/computedPropertyNames29_ES5.types b/tests/baselines/reference/computedPropertyNames29_ES5.types index 674343b3a1a..f3448f10857 100644 --- a/tests/baselines/reference/computedPropertyNames29_ES5.types +++ b/tests/baselines/reference/computedPropertyNames29_ES5.types @@ -15,7 +15,7 @@ class C { [this.bar()]() { } // needs capture >this.bar() : number >this.bar : () => number ->this : C +>this : this >bar : () => number }; diff --git a/tests/baselines/reference/computedPropertyNames29_ES6.types b/tests/baselines/reference/computedPropertyNames29_ES6.types index 52f06bb9d88..cd01d37556a 100644 --- a/tests/baselines/reference/computedPropertyNames29_ES6.types +++ b/tests/baselines/reference/computedPropertyNames29_ES6.types @@ -15,7 +15,7 @@ class C { [this.bar()]() { } // needs capture >this.bar() : number >this.bar : () => number ->this : C +>this : this >bar : () => number }; diff --git a/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols index a99a3899725..3fd0843a727 100644 --- a/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols +++ b/tests/baselines/reference/computedPropertyNamesContextualType1_ES5.symbols @@ -17,13 +17,13 @@ var o: I = { ["" + 0](y) { return y.length; }, >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 6, 13)) ->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>y.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 6, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) ["" + 1]: y => y.length >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 7, 13)) ->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>y.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES5.ts, 7, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols index e386b8e9efa..56da1f91a5e 100644 --- a/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols +++ b/tests/baselines/reference/computedPropertyNamesContextualType1_ES6.symbols @@ -17,13 +17,13 @@ var o: I = { ["" + 0](y) { return y.length; }, >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 6, 13)) ->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>y.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 6, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) ["" + 1]: y => y.length >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 7, 13)) ->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>y.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(computedPropertyNamesContextualType1_ES6.ts, 7, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols index fcd89e032e6..20b344adfd6 100644 --- a/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols +++ b/tests/baselines/reference/computedPropertyNamesContextualType2_ES5.symbols @@ -17,13 +17,13 @@ var o: I = { [+"foo"](y) { return y.length; }, >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 6, 13)) ->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>y.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 6, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) [+"bar"]: y => y.length >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 7, 13)) ->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>y.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES5.ts, 7, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols index ce6be5194c0..9412a9c8c34 100644 --- a/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols +++ b/tests/baselines/reference/computedPropertyNamesContextualType2_ES6.symbols @@ -17,13 +17,13 @@ var o: I = { [+"foo"](y) { return y.length; }, >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 6, 13)) ->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>y.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 6, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) [+"bar"]: y => y.length >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 7, 13)) ->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>y.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(computedPropertyNamesContextualType2_ES6.ts, 7, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols b/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols index d73c9c186d4..acc3b848ce4 100644 --- a/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols +++ b/tests/baselines/reference/computedPropertyNamesContextualType3_ES5.symbols @@ -13,13 +13,13 @@ var o: I = { [+"foo"](y) { return y.length; }, >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 5, 13)) ->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>y.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 5, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) [+"bar"]: y => y.length >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 6, 13)) ->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>y.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES5.ts, 6, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols b/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols index 48e93ee62f9..0b53cf3bfe4 100644 --- a/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols +++ b/tests/baselines/reference/computedPropertyNamesContextualType3_ES6.symbols @@ -13,13 +13,13 @@ var o: I = { [+"foo"](y) { return y.length; }, >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 5, 13)) ->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>y.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 5, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) [+"bar"]: y => y.length >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 6, 13)) ->y.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>y.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(computedPropertyNamesContextualType3_ES6.ts, 6, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/concatError.symbols b/tests/baselines/reference/concatError.symbols index 6ed5ffd468f..d4f04531fc7 100644 --- a/tests/baselines/reference/concatError.symbols +++ b/tests/baselines/reference/concatError.symbols @@ -14,15 +14,15 @@ var fa: number[]; fa = fa.concat([0]); >fa : Symbol(fa, Decl(concatError.ts, 8, 3)) ->fa.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>fa.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >fa : Symbol(fa, Decl(concatError.ts, 8, 3)) ->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>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.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>fa.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >fa : Symbol(fa, Decl(concatError.ts, 8, 3)) ->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/conditionalOperatorConditionIsBooleanType.symbols b/tests/baselines/reference/conditionalOperatorConditionIsBooleanType.symbols index eade67512ad..a7124d58305 100644 --- a/tests/baselines/reference/conditionalOperatorConditionIsBooleanType.symbols +++ b/tests/baselines/reference/conditionalOperatorConditionIsBooleanType.symbols @@ -17,7 +17,7 @@ var exprString1: string; var exprIsObject1: Object; >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsBooleanType.ts, 7, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var exprAny2: any; >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsBooleanType.ts, 9, 3)) @@ -33,7 +33,7 @@ var exprString2: string; var exprIsObject2: Object; >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsBooleanType.ts, 13, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //Cond is a boolean type variable condBoolean ? exprAny1 : exprAny2; diff --git a/tests/baselines/reference/conditionalOperatorConditionIsNumberType.symbols b/tests/baselines/reference/conditionalOperatorConditionIsNumberType.symbols index 8ece5961636..f3816b6238e 100644 --- a/tests/baselines/reference/conditionalOperatorConditionIsNumberType.symbols +++ b/tests/baselines/reference/conditionalOperatorConditionIsNumberType.symbols @@ -17,7 +17,7 @@ var exprString1: string; var exprIsObject1: Object; >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsNumberType.ts, 7, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var exprAny2: any; >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsNumberType.ts, 9, 3)) @@ -33,7 +33,7 @@ var exprString2: string; var exprIsObject2: Object; >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsNumberType.ts, 13, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //Cond is a number type variable condNumber ? exprAny1 : exprAny2; @@ -107,8 +107,8 @@ var array = [1, 2, 3]; >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsNumberType.ts, 10, 3)) "string".length ? exprNumber1 : exprNumber2; ->"string".length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>"string".length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >exprNumber1 : Symbol(exprNumber1, Decl(conditionalOperatorConditionIsNumberType.ts, 5, 3)) >exprNumber2 : Symbol(exprNumber2, Decl(conditionalOperatorConditionIsNumberType.ts, 11, 3)) @@ -207,8 +207,8 @@ var resultIsBoolean3 = 1 + 1 ? exprBoolean1 : exprBoolean2; var resultIsNumber3 = "string".length ? exprNumber1 : exprNumber2; >resultIsNumber3 : Symbol(resultIsNumber3, Decl(conditionalOperatorConditionIsNumberType.ts, 59, 3)) ->"string".length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>"string".length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >exprNumber1 : Symbol(exprNumber1, Decl(conditionalOperatorConditionIsNumberType.ts, 5, 3)) >exprNumber2 : Symbol(exprNumber2, Decl(conditionalOperatorConditionIsNumberType.ts, 11, 3)) diff --git a/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols b/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols index 41f00e53b26..0867a708770 100644 --- a/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols +++ b/tests/baselines/reference/conditionalOperatorConditionIsObjectType.symbols @@ -2,7 +2,7 @@ //Cond ? Expr1 : Expr2, Cond is of object type, Expr1 and Expr2 have the same type var condObject: Object; >condObject : Symbol(condObject, Decl(conditionalOperatorConditionIsObjectType.ts, 1, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var exprAny1: any; >exprAny1 : Symbol(exprAny1, Decl(conditionalOperatorConditionIsObjectType.ts, 3, 3)) @@ -18,7 +18,7 @@ var exprString1: string; var exprIsObject1: Object; >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsObjectType.ts, 7, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var exprAny2: any; >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 9, 3)) @@ -34,7 +34,7 @@ var exprString2: string; var exprIsObject2: Object; >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsObjectType.ts, 13, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo() { }; >foo : Symbol(foo, Decl(conditionalOperatorConditionIsObjectType.ts, 13, 26)) @@ -77,17 +77,17 @@ condObject ? exprString1 : exprBoolean1; // union //Cond is an object type literal ((a: string) => a.length) ? exprAny1 : exprAny2; >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 27, 2)) ->a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>a.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 27, 2)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >exprAny1 : Symbol(exprAny1, Decl(conditionalOperatorConditionIsObjectType.ts, 3, 3)) >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 9, 3)) ((a: string) => a.length) ? exprBoolean1 : exprBoolean2; >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 28, 2)) ->a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>a.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 28, 2)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3)) >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 10, 3)) @@ -120,7 +120,7 @@ foo() ? exprAny1 : exprAny2; >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 9, 3)) new Date() ? exprBoolean1 : exprBoolean2; ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3)) >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 10, 3)) @@ -137,14 +137,14 @@ C.doIt() ? exprString1 : exprString2; >exprString2 : Symbol(exprString2, Decl(conditionalOperatorConditionIsObjectType.ts, 12, 3)) condObject.valueOf() ? exprIsObject1 : exprIsObject2; ->condObject.valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, 102, 29)) +>condObject.valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, --, --)) >condObject : Symbol(condObject, Decl(conditionalOperatorConditionIsObjectType.ts, 1, 3)) ->valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, 102, 29)) +>valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, --, --)) >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsObjectType.ts, 7, 3)) >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsObjectType.ts, 13, 3)) new Date() ? exprString1 : exprBoolean1; // union ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditionIsObjectType.ts, 6, 3)) >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3)) @@ -188,18 +188,18 @@ var resultIsStringOrBoolean1 = condObject ? exprString1 : exprBoolean1; // union var resultIsAny2 = ((a: string) => a.length) ? exprAny1 : exprAny2; >resultIsAny2 : Symbol(resultIsAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 50, 3)) >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 50, 21)) ->a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>a.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 50, 21)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >exprAny1 : Symbol(exprAny1, Decl(conditionalOperatorConditionIsObjectType.ts, 3, 3)) >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditionIsObjectType.ts, 9, 3)) var resultIsBoolean2 = ((a: string) => a.length) ? exprBoolean1 : exprBoolean2; >resultIsBoolean2 : Symbol(resultIsBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 51, 3)) >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 51, 25)) ->a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>a.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(conditionalOperatorConditionIsObjectType.ts, 51, 25)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3)) >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 10, 3)) @@ -237,7 +237,7 @@ var resultIsAny3 = foo() ? exprAny1 : exprAny2; var resultIsBoolean3 = new Date() ? exprBoolean1 : exprBoolean2; >resultIsBoolean3 : Symbol(resultIsBoolean3, Decl(conditionalOperatorConditionIsObjectType.ts, 58, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditionIsObjectType.ts, 4, 3)) >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditionIsObjectType.ts, 10, 3)) @@ -257,9 +257,9 @@ var resultIsString3 = C.doIt() ? exprString1 : exprString2; var resultIsObject3 = condObject.valueOf() ? exprIsObject1 : exprIsObject2; >resultIsObject3 : Symbol(resultIsObject3, Decl(conditionalOperatorConditionIsObjectType.ts, 61, 3)) ->condObject.valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, 102, 29)) +>condObject.valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, --, --)) >condObject : Symbol(condObject, Decl(conditionalOperatorConditionIsObjectType.ts, 1, 3)) ->valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, 102, 29)) +>valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, --, --)) >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditionIsObjectType.ts, 7, 3)) >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditionIsObjectType.ts, 13, 3)) diff --git a/tests/baselines/reference/conditionalOperatorConditoinIsAnyType.symbols b/tests/baselines/reference/conditionalOperatorConditoinIsAnyType.symbols index aaaf4124eb6..c31f367b7d4 100644 --- a/tests/baselines/reference/conditionalOperatorConditoinIsAnyType.symbols +++ b/tests/baselines/reference/conditionalOperatorConditoinIsAnyType.symbols @@ -20,7 +20,7 @@ var exprString1: string; var exprIsObject1: Object; >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditoinIsAnyType.ts, 8, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var exprAny2: any; >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditoinIsAnyType.ts, 10, 3)) @@ -36,7 +36,7 @@ var exprString2: string; var exprIsObject2: Object; >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditoinIsAnyType.ts, 14, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //Cond is an any type variable condAny ? exprAny1 : exprAny2; diff --git a/tests/baselines/reference/conditionalOperatorConditoinIsStringType.symbols b/tests/baselines/reference/conditionalOperatorConditoinIsStringType.symbols index 76845a80ce6..9de27f5a96b 100644 --- a/tests/baselines/reference/conditionalOperatorConditoinIsStringType.symbols +++ b/tests/baselines/reference/conditionalOperatorConditoinIsStringType.symbols @@ -17,7 +17,7 @@ var exprString1: string; var exprIsObject1: Object; >exprIsObject1 : Symbol(exprIsObject1, Decl(conditionalOperatorConditoinIsStringType.ts, 7, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var exprAny2: any; >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditoinIsStringType.ts, 9, 3)) @@ -33,7 +33,7 @@ var exprString2: string; var exprIsObject2: Object; >exprIsObject2 : Symbol(exprIsObject2, Decl(conditionalOperatorConditoinIsStringType.ts, 13, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) //Cond is a string type variable condString ? exprAny1 : exprAny2; @@ -104,9 +104,9 @@ typeof condString ? exprAny1 : exprAny2; >exprAny2 : Symbol(exprAny2, Decl(conditionalOperatorConditoinIsStringType.ts, 9, 3)) condString.toUpperCase ? exprBoolean1 : exprBoolean2; ->condString.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32)) +>condString.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --)) >condString : Symbol(condString, Decl(conditionalOperatorConditoinIsStringType.ts, 1, 3)) ->toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --)) >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditoinIsStringType.ts, 4, 3)) >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditoinIsStringType.ts, 10, 3)) @@ -205,9 +205,9 @@ var resultIsAny3 = typeof condString ? exprAny1 : exprAny2; var resultIsBoolean3 = condString.toUpperCase ? exprBoolean1 : exprBoolean2; >resultIsBoolean3 : Symbol(resultIsBoolean3, Decl(conditionalOperatorConditoinIsStringType.ts, 58, 3)) ->condString.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32)) +>condString.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --)) >condString : Symbol(condString, Decl(conditionalOperatorConditoinIsStringType.ts, 1, 3)) ->toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --)) >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditoinIsStringType.ts, 4, 3)) >exprBoolean2 : Symbol(exprBoolean2, Decl(conditionalOperatorConditoinIsStringType.ts, 10, 3)) @@ -237,9 +237,9 @@ var resultIsStringOrBoolean3 = typeof condString ? exprString1 : exprBoolean1; / var resultIsStringOrBoolean4 = condString.toUpperCase ? exprString1 : exprBoolean1; // union >resultIsStringOrBoolean4 : Symbol(resultIsStringOrBoolean4, Decl(conditionalOperatorConditoinIsStringType.ts, 63, 3)) ->condString.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32)) +>condString.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --)) >condString : Symbol(condString, Decl(conditionalOperatorConditoinIsStringType.ts, 1, 3)) ->toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --)) >exprString1 : Symbol(exprString1, Decl(conditionalOperatorConditoinIsStringType.ts, 6, 3)) >exprBoolean1 : Symbol(exprBoolean1, Decl(conditionalOperatorConditoinIsStringType.ts, 4, 3)) diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.symbols b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.symbols index 99e11e12967..cca4cb6e12c 100644 --- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.symbols +++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.symbols @@ -5,8 +5,8 @@ class Rule { public regex: RegExp = new RegExp(''); >regex : Symbol(regex, Decl(constDeclarationShadowedByVarDeclaration3.ts, 1, 12)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) public name: string = ''; >name : Symbol(name, Decl(constDeclarationShadowedByVarDeclaration3.ts, 2, 42)) diff --git a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.types b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.types index c5b9ec9a6f2..1271d4ef869 100644 --- a/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.types +++ b/tests/baselines/reference/constDeclarationShadowedByVarDeclaration3.types @@ -20,7 +20,7 @@ class Rule { this.name = name; >this.name = name : string >this.name : string ->this : Rule +>this : this >name : string >name : string } diff --git a/tests/baselines/reference/constDeclarations-access5.errors.txt b/tests/baselines/reference/constDeclarations-access5.errors.txt index d58abfe6bd4..23200e50ee4 100644 --- a/tests/baselines/reference/constDeclarations-access5.errors.txt +++ b/tests/baselines/reference/constDeclarations-access5.errors.txt @@ -1,5 +1,3 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -tests/cases/compiler/constDeclarations_access_2.ts(2,1): error TS1202: Import assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'import * as ns from "mod"', 'import {a} from "mod"' or 'import d from "mod"' instead. tests/cases/compiler/constDeclarations_access_2.ts(4,1): error TS2450: Left-hand side of assignment expression cannot be a constant. tests/cases/compiler/constDeclarations_access_2.ts(5,1): error TS2450: Left-hand side of assignment expression cannot be a constant. tests/cases/compiler/constDeclarations_access_2.ts(6,1): error TS2450: Left-hand side of assignment expression cannot be a constant. @@ -20,12 +18,9 @@ tests/cases/compiler/constDeclarations_access_2.ts(22,3): error TS2449: The oper tests/cases/compiler/constDeclarations_access_2.ts(24,1): error TS2450: Left-hand side of assignment expression cannot be a constant. -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/constDeclarations_access_2.ts (19 errors) ==== +==== tests/cases/compiler/constDeclarations_access_2.ts (18 errors) ==== /// import m = require('constDeclarations_access_1'); - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS1202: Import assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'import * as ns from "mod"', 'import {a} from "mod"' or 'import d from "mod"' instead. // Errors m.x = 1; ~~~ diff --git a/tests/baselines/reference/constDeclarations-access5.js b/tests/baselines/reference/constDeclarations-access5.js index 7735e37d2b0..71b8c99ae58 100644 --- a/tests/baselines/reference/constDeclarations-access5.js +++ b/tests/baselines/reference/constDeclarations-access5.js @@ -49,35 +49,39 @@ m.x.toString(); //// [constDeclarations_access_1.js] -export const x = 0; +define(["require", "exports"], function (require, exports) { + exports.x = 0; +}); //// [constDeclarations_access_2.js] -// Errors -m.x = 1; -m.x += 2; -m.x -= 3; -m.x *= 4; -m.x /= 5; -m.x %= 6; -m.x <<= 7; -m.x >>= 8; -m.x >>>= 9; -m.x &= 10; -m.x |= 11; -m.x ^= 12; -m; -m.x++; -m.x--; -++m.x; ---m.x; -++((m.x)); -m["x"] = 0; -// OK -var a = m.x + 1; -function f(v) { } -f(m.x); -if (m.x) { } -m.x; -(m.x); --m.x; -+m.x; -m.x.toString(); +define(["require", "exports", 'constDeclarations_access_1'], function (require, exports, m) { + // Errors + m.x = 1; + m.x += 2; + m.x -= 3; + m.x *= 4; + m.x /= 5; + m.x %= 6; + m.x <<= 7; + m.x >>= 8; + m.x >>>= 9; + m.x &= 10; + m.x |= 11; + m.x ^= 12; + m; + m.x++; + m.x--; + ++m.x; + --m.x; + ++((m.x)); + m["x"] = 0; + // OK + var a = m.x + 1; + function f(v) { } + f(m.x); + if (m.x) { } + m.x; + (m.x); + -m.x; + +m.x; + m.x.toString(); +}); diff --git a/tests/baselines/reference/constEnumToStringNoComments.symbols b/tests/baselines/reference/constEnumToStringNoComments.symbols index 0206e6a5d90..3f48b060f35 100644 --- a/tests/baselines/reference/constEnumToStringNoComments.symbols +++ b/tests/baselines/reference/constEnumToStringNoComments.symbols @@ -23,91 +23,91 @@ const enum Foo { let x0 = Foo.X.toString(); >x0 : Symbol(x0, Decl(constEnumToStringNoComments.ts, 9, 3)) ->Foo.X.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo.X.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo.X : Symbol(Foo.X, Decl(constEnumToStringNoComments.ts, 0, 16)) >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0)) >X : Symbol(Foo.X, Decl(constEnumToStringNoComments.ts, 0, 16)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let x1 = Foo["X"].toString(); >x1 : Symbol(x1, Decl(constEnumToStringNoComments.ts, 10, 3)) ->Foo["X"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo["X"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0)) >"X" : Symbol(Foo.X, Decl(constEnumToStringNoComments.ts, 0, 16)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let y0 = Foo.Y.toString(); >y0 : Symbol(y0, Decl(constEnumToStringNoComments.ts, 11, 3)) ->Foo.Y.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo.Y.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo.Y : Symbol(Foo.Y, Decl(constEnumToStringNoComments.ts, 1, 12)) >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0)) >Y : Symbol(Foo.Y, Decl(constEnumToStringNoComments.ts, 1, 12)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let y1 = Foo["Y"].toString(); >y1 : Symbol(y1, Decl(constEnumToStringNoComments.ts, 12, 3)) ->Foo["Y"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo["Y"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0)) >"Y" : Symbol(Foo.Y, Decl(constEnumToStringNoComments.ts, 1, 12)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let z0 = Foo.Z.toString(); >z0 : Symbol(z0, Decl(constEnumToStringNoComments.ts, 13, 3)) ->Foo.Z.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo.Z.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo.Z : Symbol(Foo.Z, Decl(constEnumToStringNoComments.ts, 2, 12)) >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0)) >Z : Symbol(Foo.Z, Decl(constEnumToStringNoComments.ts, 2, 12)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let z1 = Foo["Z"].toString(); >z1 : Symbol(z1, Decl(constEnumToStringNoComments.ts, 14, 3)) ->Foo["Z"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo["Z"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0)) >"Z" : Symbol(Foo.Z, Decl(constEnumToStringNoComments.ts, 2, 12)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let a0 = Foo.A.toString(); >a0 : Symbol(a0, Decl(constEnumToStringNoComments.ts, 15, 3)) ->Foo.A.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo.A.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo.A : Symbol(Foo.A, Decl(constEnumToStringNoComments.ts, 3, 11)) >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0)) >A : Symbol(Foo.A, Decl(constEnumToStringNoComments.ts, 3, 11)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let a1 = Foo["A"].toString(); >a1 : Symbol(a1, Decl(constEnumToStringNoComments.ts, 16, 3)) ->Foo["A"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo["A"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0)) >"A" : Symbol(Foo.A, Decl(constEnumToStringNoComments.ts, 3, 11)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let b0 = Foo.B.toString(); >b0 : Symbol(b0, Decl(constEnumToStringNoComments.ts, 17, 3)) ->Foo.B.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo.B.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo.B : Symbol(Foo.B, Decl(constEnumToStringNoComments.ts, 4, 11)) >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0)) >B : Symbol(Foo.B, Decl(constEnumToStringNoComments.ts, 4, 11)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let b1 = Foo["B"].toString(); >b1 : Symbol(b1, Decl(constEnumToStringNoComments.ts, 18, 3)) ->Foo["B"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo["B"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0)) >"B" : Symbol(Foo.B, Decl(constEnumToStringNoComments.ts, 4, 11)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let c0 = Foo.C.toString(); >c0 : Symbol(c0, Decl(constEnumToStringNoComments.ts, 19, 3)) ->Foo.C.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo.C.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo.C : Symbol(Foo.C, Decl(constEnumToStringNoComments.ts, 5, 13)) >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0)) >C : Symbol(Foo.C, Decl(constEnumToStringNoComments.ts, 5, 13)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let c1 = Foo["C"].toString(); >c1 : Symbol(c1, Decl(constEnumToStringNoComments.ts, 20, 3)) ->Foo["C"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo["C"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(constEnumToStringNoComments.ts, 0, 0)) >"C" : Symbol(Foo.C, Decl(constEnumToStringNoComments.ts, 5, 13)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/constEnumToStringWithComments.symbols b/tests/baselines/reference/constEnumToStringWithComments.symbols index fafb7ab4611..028731a4540 100644 --- a/tests/baselines/reference/constEnumToStringWithComments.symbols +++ b/tests/baselines/reference/constEnumToStringWithComments.symbols @@ -23,91 +23,91 @@ const enum Foo { let x0 = Foo.X.toString(); >x0 : Symbol(x0, Decl(constEnumToStringWithComments.ts, 9, 3)) ->Foo.X.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo.X.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo.X : Symbol(Foo.X, Decl(constEnumToStringWithComments.ts, 0, 16)) >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0)) >X : Symbol(Foo.X, Decl(constEnumToStringWithComments.ts, 0, 16)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let x1 = Foo["X"].toString(); >x1 : Symbol(x1, Decl(constEnumToStringWithComments.ts, 10, 3)) ->Foo["X"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo["X"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0)) >"X" : Symbol(Foo.X, Decl(constEnumToStringWithComments.ts, 0, 16)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let y0 = Foo.Y.toString(); >y0 : Symbol(y0, Decl(constEnumToStringWithComments.ts, 11, 3)) ->Foo.Y.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo.Y.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo.Y : Symbol(Foo.Y, Decl(constEnumToStringWithComments.ts, 1, 12)) >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0)) >Y : Symbol(Foo.Y, Decl(constEnumToStringWithComments.ts, 1, 12)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let y1 = Foo["Y"].toString(); >y1 : Symbol(y1, Decl(constEnumToStringWithComments.ts, 12, 3)) ->Foo["Y"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo["Y"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0)) >"Y" : Symbol(Foo.Y, Decl(constEnumToStringWithComments.ts, 1, 12)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let z0 = Foo.Z.toString(); >z0 : Symbol(z0, Decl(constEnumToStringWithComments.ts, 13, 3)) ->Foo.Z.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo.Z.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo.Z : Symbol(Foo.Z, Decl(constEnumToStringWithComments.ts, 2, 12)) >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0)) >Z : Symbol(Foo.Z, Decl(constEnumToStringWithComments.ts, 2, 12)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let z1 = Foo["Z"].toString(); >z1 : Symbol(z1, Decl(constEnumToStringWithComments.ts, 14, 3)) ->Foo["Z"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo["Z"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0)) >"Z" : Symbol(Foo.Z, Decl(constEnumToStringWithComments.ts, 2, 12)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let a0 = Foo.A.toString(); >a0 : Symbol(a0, Decl(constEnumToStringWithComments.ts, 15, 3)) ->Foo.A.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo.A.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo.A : Symbol(Foo.A, Decl(constEnumToStringWithComments.ts, 3, 11)) >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0)) >A : Symbol(Foo.A, Decl(constEnumToStringWithComments.ts, 3, 11)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let a1 = Foo["A"].toString(); >a1 : Symbol(a1, Decl(constEnumToStringWithComments.ts, 16, 3)) ->Foo["A"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo["A"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0)) >"A" : Symbol(Foo.A, Decl(constEnumToStringWithComments.ts, 3, 11)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let b0 = Foo.B.toString(); >b0 : Symbol(b0, Decl(constEnumToStringWithComments.ts, 17, 3)) ->Foo.B.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo.B.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo.B : Symbol(Foo.B, Decl(constEnumToStringWithComments.ts, 4, 11)) >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0)) >B : Symbol(Foo.B, Decl(constEnumToStringWithComments.ts, 4, 11)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let b1 = Foo["B"].toString(); >b1 : Symbol(b1, Decl(constEnumToStringWithComments.ts, 18, 3)) ->Foo["B"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo["B"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0)) >"B" : Symbol(Foo.B, Decl(constEnumToStringWithComments.ts, 4, 11)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let c0 = Foo.C.toString(); >c0 : Symbol(c0, Decl(constEnumToStringWithComments.ts, 19, 3)) ->Foo.C.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo.C.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo.C : Symbol(Foo.C, Decl(constEnumToStringWithComments.ts, 5, 13)) >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0)) >C : Symbol(Foo.C, Decl(constEnumToStringWithComments.ts, 5, 13)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) let c1 = Foo["C"].toString(); >c1 : Symbol(c1, Decl(constEnumToStringWithComments.ts, 20, 3)) ->Foo["C"].toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>Foo["C"].toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(constEnumToStringWithComments.ts, 0, 0)) >"C" : Symbol(Foo.C, Decl(constEnumToStringWithComments.ts, 5, 13)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/constIndexedAccess.js b/tests/baselines/reference/constIndexedAccess.js new file mode 100644 index 00000000000..db80441bd33 --- /dev/null +++ b/tests/baselines/reference/constIndexedAccess.js @@ -0,0 +1,47 @@ +//// [constIndexedAccess.ts] + +const enum numbers { + zero, + one +} + +interface indexAccess { + 0: string; + 1: number; +} + +let test: indexAccess; + +let s = test[0]; +let n = test[1]; + +let s1 = test[numbers.zero]; +let n1 = test[numbers.one]; + +let s2 = test[numbers["zero"]]; +let n2 = test[numbers["one"]]; + +enum numbersNotConst { + zero, + one +} + +let s3 = test[numbersNotConst.zero]; +let n3 = test[numbersNotConst.one]; + + +//// [constIndexedAccess.js] +var test; +var s = test[0]; +var n = test[1]; +var s1 = test[0 /* zero */]; +var n1 = test[1 /* one */]; +var s2 = test[0 /* "zero" */]; +var n2 = test[1 /* "one" */]; +var numbersNotConst; +(function (numbersNotConst) { + numbersNotConst[numbersNotConst["zero"] = 0] = "zero"; + numbersNotConst[numbersNotConst["one"] = 1] = "one"; +})(numbersNotConst || (numbersNotConst = {})); +var s3 = test[numbersNotConst.zero]; +var n3 = test[numbersNotConst.one]; diff --git a/tests/baselines/reference/constIndexedAccess.symbols b/tests/baselines/reference/constIndexedAccess.symbols new file mode 100644 index 00000000000..2ccb7f11686 --- /dev/null +++ b/tests/baselines/reference/constIndexedAccess.symbols @@ -0,0 +1,83 @@ +=== 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)) + + one +>one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9)) +} + +interface indexAccess { +>indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 4, 1)) + + 0: string; + 1: number; +} + +let test: indexAccess; +>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) +>indexAccess : Symbol(indexAccess, Decl(constIndexedAccess.ts, 4, 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)) + +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)) + +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)) +>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) +>zero : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 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)) +>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) +>one : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9)) + +let s2 = test[numbers["zero"]]; +>s2 : Symbol(s2, Decl(constIndexedAccess.ts, 19, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) +>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) +>"zero" : Symbol(numbers.zero, Decl(constIndexedAccess.ts, 1, 20)) + +let n2 = test[numbers["one"]]; +>n2 : Symbol(n2, Decl(constIndexedAccess.ts, 20, 3)) +>test : Symbol(test, Decl(constIndexedAccess.ts, 11, 3)) +>numbers : Symbol(numbers, Decl(constIndexedAccess.ts, 0, 0)) +>"one" : Symbol(numbers.one, Decl(constIndexedAccess.ts, 2, 9)) + +enum numbersNotConst { +>numbersNotConst : Symbol(numbersNotConst, Decl(constIndexedAccess.ts, 20, 30)) + + zero, +>zero : Symbol(numbersNotConst.zero, Decl(constIndexedAccess.ts, 22, 22)) + + one +>one : Symbol(numbersNotConst.one, Decl(constIndexedAccess.ts, 23, 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)) + +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)) + diff --git a/tests/baselines/reference/constIndexedAccess.types b/tests/baselines/reference/constIndexedAccess.types new file mode 100644 index 00000000000..eb02c7bde2e --- /dev/null +++ b/tests/baselines/reference/constIndexedAccess.types @@ -0,0 +1,93 @@ +=== tests/cases/compiler/constIndexedAccess.ts === + +const enum numbers { +>numbers : numbers + + zero, +>zero : numbers + + one +>one : numbers +} + +interface indexAccess { +>indexAccess : indexAccess + + 0: string; + 1: number; +} + +let test: indexAccess; +>test : indexAccess +>indexAccess : indexAccess + +let s = test[0]; +>s : string +>test[0] : string +>test : indexAccess +>0 : number + +let n = test[1]; +>n : number +>test[1] : number +>test : indexAccess +>1 : number + +let s1 = test[numbers.zero]; +>s1 : string +>test[numbers.zero] : string +>test : indexAccess +>numbers.zero : numbers +>numbers : typeof numbers +>zero : numbers + +let n1 = test[numbers.one]; +>n1 : number +>test[numbers.one] : number +>test : indexAccess +>numbers.one : numbers +>numbers : typeof numbers +>one : numbers + +let s2 = test[numbers["zero"]]; +>s2 : string +>test[numbers["zero"]] : string +>test : indexAccess +>numbers["zero"] : numbers +>numbers : typeof numbers +>"zero" : string + +let n2 = test[numbers["one"]]; +>n2 : number +>test[numbers["one"]] : number +>test : indexAccess +>numbers["one"] : numbers +>numbers : typeof numbers +>"one" : string + +enum numbersNotConst { +>numbersNotConst : numbersNotConst + + zero, +>zero : numbersNotConst + + one +>one : numbersNotConst +} + +let s3 = test[numbersNotConst.zero]; +>s3 : any +>test[numbersNotConst.zero] : any +>test : indexAccess +>numbersNotConst.zero : numbersNotConst +>numbersNotConst : typeof numbersNotConst +>zero : numbersNotConst + +let n3 = test[numbersNotConst.one]; +>n3 : any +>test[numbersNotConst.one] : any +>test : indexAccess +>numbersNotConst.one : numbersNotConst +>numbersNotConst : typeof numbersNotConst +>one : numbersNotConst + diff --git a/tests/baselines/reference/constraintSatisfactionWithAny.symbols b/tests/baselines/reference/constraintSatisfactionWithAny.symbols index fdf1bdce7e8..52cfe211cff 100644 --- a/tests/baselines/reference/constraintSatisfactionWithAny.symbols +++ b/tests/baselines/reference/constraintSatisfactionWithAny.symbols @@ -4,7 +4,7 @@ function foo(x: T): T { return null; } >foo : Symbol(foo, Decl(constraintSatisfactionWithAny.ts, 0, 0)) >T : Symbol(T, Decl(constraintSatisfactionWithAny.ts, 2, 13)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(constraintSatisfactionWithAny.ts, 2, 31)) >T : Symbol(T, Decl(constraintSatisfactionWithAny.ts, 2, 13)) >T : Symbol(T, Decl(constraintSatisfactionWithAny.ts, 2, 13)) @@ -67,7 +67,7 @@ foo4(b); class C { >C : Symbol(C, Decl(constraintSatisfactionWithAny.ts, 16, 13)) >T : Symbol(T, Decl(constraintSatisfactionWithAny.ts, 22, 8)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) constructor(public x: T) { } >x : Symbol(x, Decl(constraintSatisfactionWithAny.ts, 23, 16)) diff --git a/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols b/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols index fd5aae69b86..d53e51b6623 100644 --- a/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols +++ b/tests/baselines/reference/constraintSatisfactionWithEmptyObject.symbols @@ -5,7 +5,7 @@ function foo(x: T) { } >foo : Symbol(foo, Decl(constraintSatisfactionWithEmptyObject.ts, 0, 0)) >T : Symbol(T, Decl(constraintSatisfactionWithEmptyObject.ts, 3, 13)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(constraintSatisfactionWithEmptyObject.ts, 3, 31)) >T : Symbol(T, Decl(constraintSatisfactionWithEmptyObject.ts, 3, 13)) @@ -23,7 +23,7 @@ var r = foo({}); class C { >C : Symbol(C, Decl(constraintSatisfactionWithEmptyObject.ts, 6, 16)) >T : Symbol(T, Decl(constraintSatisfactionWithEmptyObject.ts, 8, 8)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) constructor(public x: T) { } >x : Symbol(x, Decl(constraintSatisfactionWithEmptyObject.ts, 9, 16)) @@ -37,7 +37,7 @@ var r2 = new C({}); interface I { >I : Symbol(I, Decl(constraintSatisfactionWithEmptyObject.ts, 12, 19)) >T : Symbol(T, Decl(constraintSatisfactionWithEmptyObject.ts, 14, 12)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) x: T; >x : Symbol(x, Decl(constraintSatisfactionWithEmptyObject.ts, 14, 31)) diff --git a/tests/baselines/reference/constructSignatureAssignabilityInInheritance2.symbols b/tests/baselines/reference/constructSignatureAssignabilityInInheritance2.symbols index b85ae3e90d8..8a6ec113423 100644 --- a/tests/baselines/reference/constructSignatureAssignabilityInInheritance2.symbols +++ b/tests/baselines/reference/constructSignatureAssignabilityInInheritance2.symbols @@ -110,23 +110,23 @@ interface A { // T a12: new (x: Array, y: Array) => Array; >a12 : Symbol(a12, Decl(constructSignatureAssignabilityInInheritance2.ts, 19, 75)) >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance2.ts, 20, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance2.ts, 0, 0)) >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance2.ts, 20, 29)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(constructSignatureAssignabilityInInheritance2.ts, 3, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance2.ts, 2, 27)) a13: new (x: Array, y: Array) => Array; >a13 : Symbol(a13, Decl(constructSignatureAssignabilityInInheritance2.ts, 20, 68)) >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance2.ts, 21, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance2.ts, 0, 0)) >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance2.ts, 21, 29)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance2.ts, 2, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance2.ts, 2, 27)) a14: new (x: { a: string; b: number }) => Object; @@ -134,7 +134,7 @@ interface A { // T >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance2.ts, 22, 14)) >a : Symbol(a, Decl(constructSignatureAssignabilityInInheritance2.ts, 22, 18)) >b : Symbol(b, Decl(constructSignatureAssignabilityInInheritance2.ts, 22, 29)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) a15: { >a15 : Symbol(a15, Decl(constructSignatureAssignabilityInInheritance2.ts, 22, 53)) @@ -195,8 +195,8 @@ interface A { // T new (a: Date): Date; >a : Symbol(a, Decl(constructSignatureAssignabilityInInheritance2.ts, 42, 17)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) }): any[]; }; @@ -332,23 +332,23 @@ interface I extends A { a12: new >(x: Array, y: T) => Array; // ok, less specific parameter type >a12 : Symbol(a12, Decl(constructSignatureAssignabilityInInheritance2.ts, 60, 47)) >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance2.ts, 61, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance2.ts, 0, 0)) >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance2.ts, 61, 37)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance2.ts, 0, 0)) >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance2.ts, 61, 52)) >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance2.ts, 61, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance2.ts, 2, 27)) a13: new >(x: Array, y: T) => T; // ok, T = Array, satisfies constraint, contextual signature instantiation succeeds >a13 : Symbol(a13, Decl(constructSignatureAssignabilityInInheritance2.ts, 61, 77)) >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance2.ts, 62, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance2.ts, 2, 27)) >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance2.ts, 62, 40)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance2.ts, 0, 0)) >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance2.ts, 62, 55)) >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance2.ts, 62, 14)) diff --git a/tests/baselines/reference/constructSignatureAssignabilityInInheritance5.symbols b/tests/baselines/reference/constructSignatureAssignabilityInInheritance5.symbols index 2be72546bee..1b35cd0c896 100644 --- a/tests/baselines/reference/constructSignatureAssignabilityInInheritance5.symbols +++ b/tests/baselines/reference/constructSignatureAssignabilityInInheritance5.symbols @@ -111,23 +111,23 @@ interface A { // T a12: new (x: Array, y: Array) => Array; >a12 : Symbol(a12, Decl(constructSignatureAssignabilityInInheritance5.ts, 20, 75)) >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance5.ts, 21, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance5.ts, 0, 0)) >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance5.ts, 21, 29)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(constructSignatureAssignabilityInInheritance5.ts, 4, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance5.ts, 3, 27)) a13: new (x: Array, y: Array) => Array; >a13 : Symbol(a13, Decl(constructSignatureAssignabilityInInheritance5.ts, 21, 68)) >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance5.ts, 22, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance5.ts, 0, 0)) >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance5.ts, 22, 29)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance5.ts, 3, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance5.ts, 3, 27)) a14: new (x: { a: string; b: number }) => Object; @@ -135,7 +135,7 @@ interface A { // T >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance5.ts, 23, 14)) >a : Symbol(a, Decl(constructSignatureAssignabilityInInheritance5.ts, 23, 18)) >b : Symbol(b, Decl(constructSignatureAssignabilityInInheritance5.ts, 23, 29)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface B extends A { @@ -280,23 +280,23 @@ interface I extends B { a12: new >(x: Array, y: T) => Array; // ok, less specific parameter type >a12 : Symbol(a12, Decl(constructSignatureAssignabilityInInheritance5.ts, 43, 47)) >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance5.ts, 44, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance5.ts, 0, 0)) >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance5.ts, 44, 37)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance5.ts, 0, 0)) >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance5.ts, 44, 52)) >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance5.ts, 44, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance5.ts, 3, 27)) a13: new >(x: Array, y: T) => T; // ok, T = Array, satisfies constraint, contextual signature instantiation succeeds >a13 : Symbol(a13, Decl(constructSignatureAssignabilityInInheritance5.ts, 44, 77)) >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance5.ts, 45, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(constructSignatureAssignabilityInInheritance5.ts, 3, 27)) >x : Symbol(x, Decl(constructSignatureAssignabilityInInheritance5.ts, 45, 40)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(constructSignatureAssignabilityInInheritance5.ts, 0, 0)) >y : Symbol(y, Decl(constructSignatureAssignabilityInInheritance5.ts, 45, 55)) >T : Symbol(T, Decl(constructSignatureAssignabilityInInheritance5.ts, 45, 14)) diff --git a/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType.symbols b/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType.symbols index 8ca8fb6a5d8..f0ee9f0d32e 100644 --- a/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType.symbols +++ b/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType.symbols @@ -7,7 +7,7 @@ class Base { bar: Object; >bar : Symbol(bar, Decl(constructorFunctionTypeIsAssignableToBaseType.ts, 1, 17)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType2.symbols b/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType2.symbols index e915b6e705d..39e415e8a5d 100644 --- a/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType2.symbols +++ b/tests/baselines/reference/constructorFunctionTypeIsAssignableToBaseType2.symbols @@ -9,11 +9,11 @@ class Base { bar: Object; >bar : Symbol(bar, Decl(constructorFunctionTypeIsAssignableToBaseType2.ts, 3, 17)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } constructor(x: Object) { >x : Symbol(x, Decl(constructorFunctionTypeIsAssignableToBaseType2.ts, 6, 16)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/constructorImplementationWithDefaultValues.symbols b/tests/baselines/reference/constructorImplementationWithDefaultValues.symbols index 384aa692da6..a96e053132e 100644 --- a/tests/baselines/reference/constructorImplementationWithDefaultValues.symbols +++ b/tests/baselines/reference/constructorImplementationWithDefaultValues.symbols @@ -34,7 +34,7 @@ class D { class E { >E : Symbol(E, Decl(constructorImplementationWithDefaultValues.ts, 12, 1)) >T : Symbol(T, Decl(constructorImplementationWithDefaultValues.ts, 14, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) constructor(x); >x : Symbol(x, Decl(constructorImplementationWithDefaultValues.ts, 15, 16)) diff --git a/tests/baselines/reference/constructorOverloads6.errors.txt b/tests/baselines/reference/constructorOverloads6.errors.txt index 65827007a8e..34beb264f45 100644 --- a/tests/baselines/reference/constructorOverloads6.errors.txt +++ b/tests/baselines/reference/constructorOverloads6.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/constructorOverloads6.ts(4,25): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/constructorOverloads6.ts(4,25): error TS1183: An implementation cannot be declared in ambient contexts. ==== tests/cases/compiler/constructorOverloads6.ts (1 errors) ==== @@ -7,7 +7,7 @@ tests/cases/compiler/constructorOverloads6.ts(4,25): error TS1184: An implementa constructor(n: number); constructor(x: any) { ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } bar1():void; diff --git a/tests/baselines/reference/contextualSignatureInstantiation1.symbols b/tests/baselines/reference/contextualSignatureInstantiation1.symbols index e56e997cffc..80c53b07075 100644 --- a/tests/baselines/reference/contextualSignatureInstantiation1.symbols +++ b/tests/baselines/reference/contextualSignatureInstantiation1.symbols @@ -17,9 +17,9 @@ var e = (x: string, y?: K) => x.length; >x : Symbol(x, Decl(contextualSignatureInstantiation1.ts, 1, 12)) >y : Symbol(y, Decl(contextualSignatureInstantiation1.ts, 1, 22)) >K : Symbol(K, Decl(contextualSignatureInstantiation1.ts, 1, 9)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(contextualSignatureInstantiation1.ts, 1, 12)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) var r99 = map(e); // should be {}[] for S since a generic lambda is not inferentially typed >r99 : Symbol(r99, Decl(contextualSignatureInstantiation1.ts, 2, 3)) @@ -45,9 +45,9 @@ var e2 = (x: string, y?: K) => x.length; >x : Symbol(x, Decl(contextualSignatureInstantiation1.ts, 5, 13)) >y : Symbol(y, Decl(contextualSignatureInstantiation1.ts, 5, 23)) >K : Symbol(K, Decl(contextualSignatureInstantiation1.ts, 5, 10)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(contextualSignatureInstantiation1.ts, 5, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) var r100 = map2(e2); // type arg inference should fail for S since a generic lambda is not inferentially typed. Falls back to { length: number } >r100 : Symbol(r100, Decl(contextualSignatureInstantiation1.ts, 6, 3)) diff --git a/tests/baselines/reference/contextualSignatureInstantiation3.symbols b/tests/baselines/reference/contextualSignatureInstantiation3.symbols index 7e90c6390ca..6d480a7aef4 100644 --- a/tests/baselines/reference/contextualSignatureInstantiation3.symbols +++ b/tests/baselines/reference/contextualSignatureInstantiation3.symbols @@ -12,9 +12,9 @@ function map(items: T[], f: (x: T) => U): U[]{ >U : Symbol(U, Decl(contextualSignatureInstantiation3.ts, 0, 15)) return items.map(f); ->items.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>items.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >items : Symbol(items, Decl(contextualSignatureInstantiation3.ts, 0, 19)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >f : Symbol(f, Decl(contextualSignatureInstantiation3.ts, 0, 30)) } @@ -47,9 +47,9 @@ var v1: number[]; var v1 = xs.map(identity); // Error if not number[] >v1 : Symbol(v1, Decl(contextualSignatureInstantiation3.ts, 15, 3), Decl(contextualSignatureInstantiation3.ts, 16, 3), Decl(contextualSignatureInstantiation3.ts, 17, 3)) ->xs.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>xs.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >xs : Symbol(xs, Decl(contextualSignatureInstantiation3.ts, 12, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >identity : Symbol(identity, Decl(contextualSignatureInstantiation3.ts, 2, 1)) var v1 = map(xs, identity); // Error if not number[] @@ -63,9 +63,9 @@ var v2: number[][]; var v2 = xs.map(singleton); // Error if not number[][] >v2 : Symbol(v2, Decl(contextualSignatureInstantiation3.ts, 19, 3), Decl(contextualSignatureInstantiation3.ts, 20, 3), Decl(contextualSignatureInstantiation3.ts, 21, 3)) ->xs.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>xs.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >xs : Symbol(xs, Decl(contextualSignatureInstantiation3.ts, 12, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >singleton : Symbol(singleton, Decl(contextualSignatureInstantiation3.ts, 6, 1)) var v2 = map(xs, singleton); // Error if not number[][] diff --git a/tests/baselines/reference/contextualThisType.js b/tests/baselines/reference/contextualThisType.js new file mode 100644 index 00000000000..1fce0828edc --- /dev/null +++ b/tests/baselines/reference/contextualThisType.js @@ -0,0 +1,24 @@ +//// [contextualThisType.ts] +interface X { + a: (p: this) => this; +} + +interface Y extends X { +} + +var x: Y = { + a(p) { + return p; + } +} + +var y = x.a(x); + + +//// [contextualThisType.js] +var x = { + a: function (p) { + return p; + } +}; +var y = x.a(x); diff --git a/tests/baselines/reference/contextualThisType.symbols b/tests/baselines/reference/contextualThisType.symbols new file mode 100644 index 00000000000..5030a9bbcde --- /dev/null +++ b/tests/baselines/reference/contextualThisType.symbols @@ -0,0 +1,34 @@ +=== tests/cases/conformance/types/thisType/contextualThisType.ts === +interface X { +>X : Symbol(X, Decl(contextualThisType.ts, 0, 0)) + + a: (p: this) => this; +>a : Symbol(a, Decl(contextualThisType.ts, 0, 13)) +>p : Symbol(p, Decl(contextualThisType.ts, 1, 8)) +} + +interface Y extends X { +>Y : Symbol(Y, Decl(contextualThisType.ts, 2, 1)) +>X : Symbol(X, Decl(contextualThisType.ts, 0, 0)) +} + +var x: Y = { +>x : Symbol(x, Decl(contextualThisType.ts, 7, 3)) +>Y : Symbol(Y, Decl(contextualThisType.ts, 2, 1)) + + a(p) { +>a : Symbol(a, Decl(contextualThisType.ts, 7, 12)) +>p : Symbol(p, Decl(contextualThisType.ts, 8, 6)) + + return p; +>p : Symbol(p, Decl(contextualThisType.ts, 8, 6)) + } +} + +var y = x.a(x); +>y : Symbol(y, Decl(contextualThisType.ts, 13, 3)) +>x.a : Symbol(X.a, Decl(contextualThisType.ts, 0, 13)) +>x : Symbol(x, Decl(contextualThisType.ts, 7, 3)) +>a : Symbol(X.a, Decl(contextualThisType.ts, 0, 13)) +>x : Symbol(x, Decl(contextualThisType.ts, 7, 3)) + diff --git a/tests/baselines/reference/contextualThisType.types b/tests/baselines/reference/contextualThisType.types new file mode 100644 index 00000000000..fb4588c5fb0 --- /dev/null +++ b/tests/baselines/reference/contextualThisType.types @@ -0,0 +1,36 @@ +=== tests/cases/conformance/types/thisType/contextualThisType.ts === +interface X { +>X : X + + a: (p: this) => this; +>a : (p: this) => this +>p : this +} + +interface Y extends X { +>Y : Y +>X : X +} + +var x: Y = { +>x : Y +>Y : Y +>{ a(p) { return p; }} : { a(p: Y): Y; } + + a(p) { +>a : (p: Y) => Y +>p : Y + + return p; +>p : Y + } +} + +var y = x.a(x); +>y : Y +>x.a(x) : Y +>x.a : (p: Y) => Y +>x : Y +>a : (p: Y) => Y +>x : Y + diff --git a/tests/baselines/reference/contextualTypeAppliedToVarArgs.types b/tests/baselines/reference/contextualTypeAppliedToVarArgs.types index cbd16aea35f..df6ead16095 100644 --- a/tests/baselines/reference/contextualTypeAppliedToVarArgs.types +++ b/tests/baselines/reference/contextualTypeAppliedToVarArgs.types @@ -21,7 +21,7 @@ class Foo{ delegate(this, function (source, args2) >delegate(this, function (source, args2) { var a = source.node; var b = args2.node; } ) : (...args: any[]) => any >delegate : (instance: any, method: (...args: any[]) => any, data?: any) => (...args: any[]) => any ->this : Foo +>this : this >function (source, args2) { var a = source.node; var b = args2.node; } : (source: any, args2: any) => void >source : any >args2 : any diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols index 3e23a7812f5..13f95623fd5 100644 --- a/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols +++ b/tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols @@ -47,9 +47,9 @@ var x: IWithNoCallSignatures | IWithCallSignatures = a => a.toString(); >IWithNoCallSignatures : Symbol(IWithNoCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 0, 0)) >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 25, 52)) ->a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>a.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 25, 52)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) // With call signatures with different return type var x2: IWithCallSignatures | IWithCallSignatures2 = a => a.toString(); // Like iWithCallSignatures @@ -57,9 +57,9 @@ var x2: IWithCallSignatures | IWithCallSignatures2 = a => a.toString(); // Like >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1)) >IWithCallSignatures2 : Symbol(IWithCallSignatures2, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 12, 1)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 52)) ->a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>a.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 52)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) var x2: IWithCallSignatures | IWithCallSignatures2 = a => a; // Like iWithCallSignatures2 >x2 : Symbol(x2, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 28, 3), Decl(contextualTypeWithUnionTypeCallSignatures.ts, 29, 3)) @@ -82,7 +82,7 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1)) >IWithCallSignatures4 : Symbol(IWithCallSignatures4, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 18, 1)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52)) ->a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>a.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols index c381377e523..14b595f8b33 100644 --- a/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols +++ b/tests/baselines/reference/contextualTypeWithUnionTypeIndexSignatures.symbols @@ -93,9 +93,9 @@ var x2: IWithStringIndexSignature1 | IWithStringIndexSignature2 = { z: a => a.to >IWithStringIndexSignature2 : Symbol(IWithStringIndexSignature2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 17, 1)) >z : Symbol(z, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 67)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 70)) ->a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>a.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 70)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) var x2: IWithStringIndexSignature1 | IWithStringIndexSignature2 = { z: a => a }; // a should be number >x2 : Symbol(x2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 42, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 43, 3)) @@ -133,9 +133,9 @@ var x4: IWithNumberIndexSignature1 | IWithNumberIndexSignature2 = { 1: a => a.to >IWithNumberIndexSignature1 : Symbol(IWithNumberIndexSignature1, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 20, 1)) >IWithNumberIndexSignature2 : Symbol(IWithNumberIndexSignature2, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 23, 1)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 70)) ->a.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>a.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 70)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) var x4: IWithNumberIndexSignature1 | IWithNumberIndexSignature2 = { 1: a => a }; // a should be number >x4 : Symbol(x4, Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 52, 3), Decl(contextualTypeWithUnionTypeIndexSignatures.ts, 53, 3)) diff --git a/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols b/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols index 3d7b8bf5a18..5a0891c3b88 100644 --- a/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols +++ b/tests/baselines/reference/contextualTypeWithUnionTypeMembers.symbols @@ -164,7 +164,7 @@ var i1Ori2: I1 | I2 = { // Like i1 and i2 both var arrayI1OrI2: Array | I2> = [i1, i2, { // Like i1 >arrayI1OrI2 : Symbol(arrayI1OrI2, Decl(contextualTypeWithUnionTypeMembers.ts, 51, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >I1 : Symbol(I1, Decl(contextualTypeWithUnionTypeMembers.ts, 0, 0)) >I2 : Symbol(I2, Decl(contextualTypeWithUnionTypeMembers.ts, 9, 1)) >i1 : Symbol(i1, Decl(contextualTypeWithUnionTypeMembers.ts, 21, 3)) @@ -301,9 +301,9 @@ var i11Ori21: I11 | I21 = { var z = a.charAt(b); >z : Symbol(z, Decl(contextualTypeWithUnionTypeMembers.ts, 91, 11)) ->a.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>a.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 90, 38)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 90, 40)) return z; @@ -327,9 +327,9 @@ var i11Ori21: I11 | I21 = { var z = a.charCodeAt(b); >z : Symbol(z, Decl(contextualTypeWithUnionTypeMembers.ts, 99, 11)) ->a.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, 285, 32)) +>a.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 98, 38)) ->charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, 285, 32)) +>charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 98, 40)) return z; @@ -342,7 +342,7 @@ var i11Ori21: I11 | I21 = { }; var arrayOrI11OrI21: Array = [i11, i21, i11 || i21, { >arrayOrI11OrI21 : Symbol(arrayOrI11OrI21, Decl(contextualTypeWithUnionTypeMembers.ts, 104, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >I11 : Symbol(I11, Decl(contextualTypeWithUnionTypeMembers.ts, 74, 7)) >I21 : Symbol(I21, Decl(contextualTypeWithUnionTypeMembers.ts, 79, 1)) >i11 : Symbol(i11, Decl(contextualTypeWithUnionTypeMembers.ts, 84, 3)) @@ -358,9 +358,9 @@ var arrayOrI11OrI21: Array = [i11, i21, i11 || i21, { var z = a.charAt(b); >z : Symbol(z, Decl(contextualTypeWithUnionTypeMembers.ts, 107, 15)) ->a.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>a.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 106, 42)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 106, 44)) return z; @@ -379,9 +379,9 @@ var arrayOrI11OrI21: Array = [i11, i21, i11 || i21, { var z = a.charCodeAt(b); >z : Symbol(z, Decl(contextualTypeWithUnionTypeMembers.ts, 114, 15)) ->a.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, 285, 32)) +>a.charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(contextualTypeWithUnionTypeMembers.ts, 113, 42)) ->charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, 285, 32)) +>charCodeAt : Symbol(String.charCodeAt, Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(contextualTypeWithUnionTypeMembers.ts, 113, 44)) return z; diff --git a/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols b/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols index 56c3abe0627..1f8ad9f9c68 100644 --- a/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols +++ b/tests/baselines/reference/contextualTypingOfConditionalExpression.symbols @@ -3,13 +3,13 @@ var x: (a: number) => void = true ? (a) => a.toExponential() : (b) => b.toFixed( >x : Symbol(x, Decl(contextualTypingOfConditionalExpression.ts, 0, 3)) >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 0, 8)) >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 0, 37)) ->a.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>a.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(contextualTypingOfConditionalExpression.ts, 0, 37)) ->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(contextualTypingOfConditionalExpression.ts, 0, 64)) ->b.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>b.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(contextualTypingOfConditionalExpression.ts, 0, 64)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) class A { >A : Symbol(A, Decl(contextualTypingOfConditionalExpression.ts, 0, 82)) diff --git a/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols b/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols index 810f407e1b2..e6719960b31 100644 --- a/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols +++ b/tests/baselines/reference/contextuallyTypedFunctionExpressionsAndReturnAnnotations.symbols @@ -13,9 +13,9 @@ foo((y): (y2: number) => void => { var z = y.charAt(0); // Should be string >z : Symbol(z, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 4, 7)) ->y.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>y.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 3, 5)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) return null; }); @@ -29,9 +29,9 @@ foo((y: string) => { var z = y2.toFixed(); // Should be string >z : Symbol(z, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 10, 11)) ->y2.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>y2.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >y2 : Symbol(y2, Decl(contextuallyTypedFunctionExpressionsAndReturnAnnotations.ts, 9, 10)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) return 0; }; diff --git a/tests/baselines/reference/contextuallyTypingOrOperator.symbols b/tests/baselines/reference/contextuallyTypingOrOperator.symbols index 18019aea7cb..1ceb9b76ad3 100644 --- a/tests/baselines/reference/contextuallyTypingOrOperator.symbols +++ b/tests/baselines/reference/contextuallyTypingOrOperator.symbols @@ -5,34 +5,34 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 }; >_ : Symbol(_, Decl(contextuallyTypingOrOperator.ts, 0, 13)) >a : Symbol(a, Decl(contextuallyTypingOrOperator.ts, 0, 39)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 0, 42)) ->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>s.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 0, 42)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(contextuallyTypingOrOperator.ts, 0, 63)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 0, 66)) var v2 = (s: string) => s.length || function (s) { s.length }; >v2 : Symbol(v2, Decl(contextuallyTypingOrOperator.ts, 2, 3)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 10)) ->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>s.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 10)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 46)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 2, 46)) var v3 = (s: string) => s.length || function (s: number) { return 1 }; >v3 : Symbol(v3, Decl(contextuallyTypingOrOperator.ts, 4, 3)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 4, 10)) ->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>s.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 4, 10)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 4, 46)) var v4 = (s: number) => 1 || function (s: string) { return s.length }; >v4 : Symbol(v4, Decl(contextuallyTypingOrOperator.ts, 5, 3)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 5, 10)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 5, 39)) ->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>s.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(contextuallyTypingOrOperator.ts, 5, 39)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/contextuallyTypingOrOperator2.symbols b/tests/baselines/reference/contextuallyTypingOrOperator2.symbols index 99e328fd64a..40dc6190b04 100644 --- a/tests/baselines/reference/contextuallyTypingOrOperator2.symbols +++ b/tests/baselines/reference/contextuallyTypingOrOperator2.symbols @@ -5,18 +5,18 @@ var v: { a: (_: string) => number } = { a: s => s.length } || { a: s => 1 }; >_ : Symbol(_, Decl(contextuallyTypingOrOperator2.ts, 0, 13)) >a : Symbol(a, Decl(contextuallyTypingOrOperator2.ts, 0, 39)) >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 0, 42)) ->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>s.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 0, 42)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(contextuallyTypingOrOperator2.ts, 0, 63)) >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 0, 66)) var v2 = (s: string) => s.length || function (s) { s.aaa }; >v2 : Symbol(v2, Decl(contextuallyTypingOrOperator2.ts, 2, 3)) >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 10)) ->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>s.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 10)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 46)) >s : Symbol(s, Decl(contextuallyTypingOrOperator2.ts, 2, 46)) diff --git a/tests/baselines/reference/declFileConstructors.symbols b/tests/baselines/reference/declFileConstructors.symbols index bc8f349bb82..1190c889dbf 100644 --- a/tests/baselines/reference/declFileConstructors.symbols +++ b/tests/baselines/reference/declFileConstructors.symbols @@ -33,9 +33,9 @@ export class ConstructorWithRestParamters { return a + rests.join(""); >a : Symbol(a, Decl(declFileConstructors_0.ts, 16, 16)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileConstructors_0.ts, 16, 26)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } } @@ -119,9 +119,9 @@ class GlobalConstructorWithRestParamters { return a + rests.join(""); >a : Symbol(a, Decl(declFileConstructors_1.ts, 15, 16)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileConstructors_1.ts, 15, 26)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/declFileEnums.symbols b/tests/baselines/reference/declFileEnums.symbols index 22d5ee6bb63..bea118ea967 100644 --- a/tests/baselines/reference/declFileEnums.symbols +++ b/tests/baselines/reference/declFileEnums.symbols @@ -35,9 +35,9 @@ enum e3 { b = Math.PI, >b : Symbol(e3.b, Decl(declFileEnums.ts, 14, 11)) ->Math.PI : Symbol(Math.PI, Decl(lib.d.ts, 534, 19)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->PI : Symbol(Math.PI, Decl(lib.d.ts, 534, 19)) +>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)) diff --git a/tests/baselines/reference/declFileForTypeParameters.types b/tests/baselines/reference/declFileForTypeParameters.types index 6308a0c92ba..fe69da2cd0f 100644 --- a/tests/baselines/reference/declFileForTypeParameters.types +++ b/tests/baselines/reference/declFileForTypeParameters.types @@ -16,7 +16,7 @@ class C { return this.x; >this.x : T ->this : C +>this : this >x : T } } diff --git a/tests/baselines/reference/declFileFunctions.symbols b/tests/baselines/reference/declFileFunctions.symbols index 1853da94a46..9ee1a3603bd 100644 --- a/tests/baselines/reference/declFileFunctions.symbols +++ b/tests/baselines/reference/declFileFunctions.symbols @@ -24,9 +24,9 @@ export function fooWithRestParameters(a: string, ...rests: string[]) { return a + rests.join(""); >a : Symbol(a, Decl(declFileFunctions_0.ts, 10, 38)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileFunctions_0.ts, 10, 48)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } export function fooWithOverloads(a: string): string; @@ -115,9 +115,9 @@ function nonExportedFooWithRestParameters(a: string, ...rests: string[]) { return a + rests.join(""); >a : Symbol(a, Decl(declFileFunctions_0.ts, 47, 42)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileFunctions_0.ts, 47, 52)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } function nonExportedFooWithOverloads(a: string): string; @@ -161,9 +161,9 @@ function globalfooWithRestParameters(a: string, ...rests: string[]) { return a + rests.join(""); >a : Symbol(a, Decl(declFileFunctions_1.ts, 9, 37)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileFunctions_1.ts, 9, 47)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } function globalfooWithOverloads(a: string): string; >globalfooWithOverloads : Symbol(globalfooWithOverloads, Decl(declFileFunctions_1.ts, 11, 1), Decl(declFileFunctions_1.ts, 12, 51), Decl(declFileFunctions_1.ts, 13, 51)) diff --git a/tests/baselines/reference/declFileGenericType.symbols b/tests/baselines/reference/declFileGenericType.symbols index 38460fcb143..b98e0df59ac 100644 --- a/tests/baselines/reference/declFileGenericType.symbols +++ b/tests/baselines/reference/declFileGenericType.symbols @@ -44,7 +44,7 @@ export module C { >B : Symbol(B, Decl(declFileGenericType.ts, 1, 24)) >x : Symbol(x, Decl(declFileGenericType.ts, 7, 39)) >T : Symbol(T, Decl(declFileGenericType.ts, 7, 23)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >C : Symbol(C, Decl(declFileGenericType.ts, 0, 0)) >A : Symbol(A, Decl(declFileGenericType.ts, 0, 17)) >C : Symbol(C, Decl(declFileGenericType.ts, 0, 0)) diff --git a/tests/baselines/reference/declFileGenericType2.types b/tests/baselines/reference/declFileGenericType2.types index 07bcba3e85a..c2a43db1921 100644 --- a/tests/baselines/reference/declFileGenericType2.types +++ b/tests/baselines/reference/declFileGenericType2.types @@ -142,7 +142,7 @@ module templa.dom.mvc.composite { this._controllers = []; >this._controllers = [] : undefined[] >this._controllers : templa.mvc.IController[] ->this : AbstractCompositeElementController +>this : this >_controllers : templa.mvc.IController[] >[] : undefined[] } diff --git a/tests/baselines/reference/declFileMethods.symbols b/tests/baselines/reference/declFileMethods.symbols index f0426e46026..845f3044dae 100644 --- a/tests/baselines/reference/declFileMethods.symbols +++ b/tests/baselines/reference/declFileMethods.symbols @@ -27,9 +27,9 @@ export class c1 { return a + rests.join(""); >a : Symbol(a, Decl(declFileMethods_0.ts, 11, 33)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileMethods_0.ts, 11, 43)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } public fooWithOverloads(a: string): string; @@ -73,9 +73,9 @@ export class c1 { return a + rests.join(""); >a : Symbol(a, Decl(declFileMethods_0.ts, 31, 41)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileMethods_0.ts, 31, 51)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } private privateFooWithOverloads(a: string): string; >privateFooWithOverloads : Symbol(privateFooWithOverloads, Decl(declFileMethods_0.ts, 33, 5), Decl(declFileMethods_0.ts, 34, 55), Decl(declFileMethods_0.ts, 35, 55)) @@ -118,9 +118,9 @@ export class c1 { return a + rests.join(""); >a : Symbol(a, Decl(declFileMethods_0.ts, 50, 39)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileMethods_0.ts, 50, 49)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>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)) @@ -163,9 +163,9 @@ export class c1 { return a + rests.join(""); >a : Symbol(a, Decl(declFileMethods_0.ts, 69, 54)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileMethods_0.ts, 69, 64)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>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)) @@ -242,9 +242,9 @@ class c2 { return a + rests.join(""); >a : Symbol(a, Decl(declFileMethods_1.ts, 10, 33)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileMethods_1.ts, 10, 43)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } public fooWithOverloads(a: string): string; @@ -288,9 +288,9 @@ class c2 { return a + rests.join(""); >a : Symbol(a, Decl(declFileMethods_1.ts, 30, 41)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileMethods_1.ts, 30, 51)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } private privateFooWithOverloads(a: string): string; >privateFooWithOverloads : Symbol(privateFooWithOverloads, Decl(declFileMethods_1.ts, 32, 5), Decl(declFileMethods_1.ts, 33, 55), Decl(declFileMethods_1.ts, 34, 55)) @@ -333,9 +333,9 @@ class c2 { return a + rests.join(""); >a : Symbol(a, Decl(declFileMethods_1.ts, 49, 39)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileMethods_1.ts, 49, 49)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } static staticFooWithOverloads(a: string): string; >staticFooWithOverloads : Symbol(c2.staticFooWithOverloads, Decl(declFileMethods_1.ts, 51, 5), Decl(declFileMethods_1.ts, 52, 53), Decl(declFileMethods_1.ts, 53, 53)) @@ -378,9 +378,9 @@ class c2 { return a + rests.join(""); >a : Symbol(a, Decl(declFileMethods_1.ts, 68, 54)) ->rests.join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>rests.join : Symbol(Array.join, Decl(lib.d.ts, --, --)) >rests : Symbol(rests, Decl(declFileMethods_1.ts, 68, 64)) ->join : Symbol(Array.join, Decl(lib.d.ts, 1035, 31)) +>join : Symbol(Array.join, Decl(lib.d.ts, --, --)) } private static privateStaticFooWithOverloads(a: string): string; >privateStaticFooWithOverloads : Symbol(c2.privateStaticFooWithOverloads, Decl(declFileMethods_1.ts, 70, 5), Decl(declFileMethods_1.ts, 71, 68), Decl(declFileMethods_1.ts, 72, 68)) diff --git a/tests/baselines/reference/declFilePrivateMethodOverloads.symbols b/tests/baselines/reference/declFilePrivateMethodOverloads.symbols index 4f02212d79e..becc01438c2 100644 --- a/tests/baselines/reference/declFilePrivateMethodOverloads.symbols +++ b/tests/baselines/reference/declFilePrivateMethodOverloads.symbols @@ -20,7 +20,7 @@ class c1 { private _forEachBindingContext(bindingContextArray: Array, fn: (bindingContext: IContext) => void); >_forEachBindingContext : Symbol(_forEachBindingContext, Decl(declFilePrivateMethodOverloads.ts, 4, 10), Decl(declFilePrivateMethodOverloads.ts, 5, 101), Decl(declFilePrivateMethodOverloads.ts, 6, 113)) >bindingContextArray : Symbol(bindingContextArray, Decl(declFilePrivateMethodOverloads.ts, 6, 35)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>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)) @@ -44,7 +44,7 @@ class c1 { private overloadWithArityDifference(bindingContextArray: Array, fn: (bindingContext: IContext) => void); >overloadWithArityDifference : Symbol(overloadWithArityDifference, Decl(declFilePrivateMethodOverloads.ts, 9, 5), Decl(declFilePrivateMethodOverloads.ts, 11, 66), Decl(declFilePrivateMethodOverloads.ts, 12, 118)) >bindingContextArray : Symbol(bindingContextArray, Decl(declFilePrivateMethodOverloads.ts, 12, 40)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>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)) diff --git a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols index 7250567039a..f48ced073d5 100644 --- a/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols +++ b/tests/baselines/reference/declFileTypeAnnotationStringLiteral.symbols @@ -20,9 +20,9 @@ function foo(a: string): string | number { >a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 4, 13)) return a.length; ->a.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>a.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(declFileTypeAnnotationStringLiteral.ts, 4, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } return a; diff --git a/tests/baselines/reference/declarationEmit_array-types-from-generic-array-usage.symbols b/tests/baselines/reference/declarationEmit_array-types-from-generic-array-usage.symbols index 4f79e47277b..9c9e757afb9 100644 --- a/tests/baselines/reference/declarationEmit_array-types-from-generic-array-usage.symbols +++ b/tests/baselines/reference/declarationEmit_array-types-from-generic-array-usage.symbols @@ -1,5 +1,5 @@ === tests/cases/compiler/declarationEmit_array-types-from-generic-array-usage.ts === interface A extends Array { } >A : Symbol(A, Decl(declarationEmit_array-types-from-generic-array-usage.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/declarationEmit_protectedMembers.types b/tests/baselines/reference/declarationEmit_protectedMembers.types index 89aa3f56332..d541e1d14d2 100644 --- a/tests/baselines/reference/declarationEmit_protectedMembers.types +++ b/tests/baselines/reference/declarationEmit_protectedMembers.types @@ -12,7 +12,7 @@ class C1 { return this.x; >this.x : number ->this : C1 +>this : this >x : number } @@ -60,7 +60,7 @@ class C2 extends C1 { >super : C1 >f : () => number >this.x : number ->this : C2 +>this : this >x : number } protected static sf() { diff --git a/tests/baselines/reference/declarationFiles.errors.txt b/tests/baselines/reference/declarationFiles.errors.txt new file mode 100644 index 00000000000..c55cac9000b --- /dev/null +++ b/tests/baselines/reference/declarationFiles.errors.txt @@ -0,0 +1,63 @@ +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 errors) ==== + + class C1 { + x: this; + f(x: this): this { return undefined; } + constructor(x: this) { } + } + + class C2 { + [x: string]: this; + } + + interface Foo { + x: T; + y: this; + } + + class C3 { + a: this[]; + b: [this, this]; + c: this | Date; + d: this & Date; + e: (((this))); + f: (x: this) => this; + g: new (x: this) => this; + h: Foo; + i: Foo this)>; + j: (x: any) => x is this; + } + + class C4 { + x1 = { a: this }; + ~~ +!!! error TS2527: The inferred type of 'x1' references an inaccessible 'this' type. A type annotation is necessary. + x2 = [this]; + x3 = [{ a: this }]; + ~~ +!!! error TS2527: The inferred type of 'x3' references an inaccessible 'this' type. A type annotation is necessary. + x4 = () => this; + f1() { + ~~ +!!! error TS2527: The inferred type of 'f1' references an inaccessible 'this' type. A type annotation is necessary. + return { a: this }; + } + f2() { + return [this]; + } + f3() { + ~~ +!!! error TS2527: The inferred type of 'f3' references an inaccessible 'this' type. A type annotation is necessary. + return [{ a: this }]; + } + f4() { + return () => this; + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/declarationFiles.js b/tests/baselines/reference/declarationFiles.js new file mode 100644 index 00000000000..d7ed9bde8c7 --- /dev/null +++ b/tests/baselines/reference/declarationFiles.js @@ -0,0 +1,135 @@ +//// [declarationFiles.ts] + +class C1 { + x: this; + f(x: this): this { return undefined; } + constructor(x: this) { } +} + +class C2 { + [x: string]: this; +} + +interface Foo { + x: T; + y: this; +} + +class C3 { + a: this[]; + b: [this, this]; + c: this | Date; + d: this & Date; + e: (((this))); + f: (x: this) => this; + g: new (x: this) => this; + h: Foo; + i: Foo this)>; + j: (x: any) => x is this; +} + +class C4 { + x1 = { a: this }; + x2 = [this]; + x3 = [{ a: this }]; + x4 = () => this; + f1() { + return { a: this }; + } + f2() { + return [this]; + } + f3() { + return [{ a: this }]; + } + f4() { + return () => this; + } +} + + +//// [declarationFiles.js] +var C1 = (function () { + function C1(x) { + } + C1.prototype.f = function (x) { return undefined; }; + return C1; +})(); +var C2 = (function () { + function C2() { + } + return C2; +})(); +var C3 = (function () { + function C3() { + } + return C3; +})(); +var C4 = (function () { + function C4() { + var _this = this; + this.x1 = { a: this }; + this.x2 = [this]; + this.x3 = [{ a: this }]; + this.x4 = function () { return _this; }; + } + C4.prototype.f1 = function () { + return { a: this }; + }; + C4.prototype.f2 = function () { + return [this]; + }; + C4.prototype.f3 = function () { + return [{ a: this }]; + }; + C4.prototype.f4 = function () { + var _this = this; + return function () { return _this; }; + }; + return C4; +})(); + + +//// [declarationFiles.d.ts] +declare class C1 { + x: this; + f(x: this): this; + constructor(x: this); +} +declare class C2 { + [x: string]: this; +} +interface Foo { + x: T; + y: this; +} +declare class C3 { + a: this[]; + b: [this, this]; + c: this | Date; + d: this & Date; + e: (((this))); + f: (x: this) => this; + g: new (x: this) => this; + h: Foo; + i: Foo this)>; + j: (x: any) => x is this; +} +declare class C4 { + x1: { + a: this; + }; + x2: this[]; + x3: { + a: this; + }[]; + x4: () => this; + f1(): { + a: this; + }; + f2(): this[]; + f3(): { + a: this; + }[]; + f4(): () => this; +} diff --git a/tests/baselines/reference/declareExternalModuleWithExportAssignedFundule.symbols b/tests/baselines/reference/declareExternalModuleWithExportAssignedFundule.symbols index 881728ce641..0b1b06cc99e 100644 --- a/tests/baselines/reference/declareExternalModuleWithExportAssignedFundule.symbols +++ b/tests/baselines/reference/declareExternalModuleWithExportAssignedFundule.symbols @@ -23,10 +23,10 @@ declare module "express" { post(path: RegExp, handler: (req: Function) => void ): void; >post : Symbol(post, Decl(declareExternalModuleWithExportAssignedFundule.ts, 10, 48)) >path : Symbol(path, Decl(declareExternalModuleWithExportAssignedFundule.ts, 12, 17)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >handler : Symbol(handler, Decl(declareExternalModuleWithExportAssignedFundule.ts, 12, 30)) >req : Symbol(req, Decl(declareExternalModuleWithExportAssignedFundule.ts, 12, 41)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/decoratedClassFromExternalModule.js b/tests/baselines/reference/decoratedClassFromExternalModule.js index aca1d28b952..000fe2f37d6 100644 --- a/tests/baselines/reference/decoratedClassFromExternalModule.js +++ b/tests/baselines/reference/decoratedClassFromExternalModule.js @@ -11,12 +11,10 @@ import Decorated from 'decorated'; //// [decorated.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; function decorate(target) { } let Decorated = class { diff --git a/tests/baselines/reference/decoratorChecksFunctionBodies.js b/tests/baselines/reference/decoratorChecksFunctionBodies.js index adb710efccc..a5aa63b0b31 100644 --- a/tests/baselines/reference/decoratorChecksFunctionBodies.js +++ b/tests/baselines/reference/decoratorChecksFunctionBodies.js @@ -17,12 +17,10 @@ class A { //// [decoratorChecksFunctionBodies.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; // from #2971 function func(s) { @@ -32,13 +30,12 @@ var A = (function () { } A.prototype.m = function () { }; - Object.defineProperty(A.prototype, "m", - __decorate([ - (function (x, p) { - var a = 3; - func(a); - return x; - }) - ], A.prototype, "m", Object.getOwnPropertyDescriptor(A.prototype, "m"))); + __decorate([ + (function (x, p) { + var a = 3; + func(a); + return x; + }) + ], A.prototype, "m", null); return A; })(); diff --git a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js index 08ba6e9ea7e..ee39c1746a2 100644 --- a/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js +++ b/tests/baselines/reference/decoratorInstantiateModulesInFunctionBodies.js @@ -26,12 +26,10 @@ class Wat { exports.test = 'abc'; //// [b.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var a_1 = require('./a'); function filter(handler) { @@ -45,9 +43,8 @@ var Wat = (function () { Wat.whatever = function () { // ... }; - Object.defineProperty(Wat, "whatever", - __decorate([ - filter(function () { return a_1.test == 'abc'; }) - ], Wat, "whatever", Object.getOwnPropertyDescriptor(Wat, "whatever"))); + __decorate([ + filter(function () { return a_1.test == 'abc'; }) + ], Wat, "whatever", null); return Wat; })(); diff --git a/tests/baselines/reference/decoratorMetadata.js b/tests/baselines/reference/decoratorMetadata.js index 5c2ce580507..3c4637d9dab 100644 --- a/tests/baselines/reference/decoratorMetadata.js +++ b/tests/baselines/reference/decoratorMetadata.js @@ -24,12 +24,10 @@ Object.defineProperty(exports, "__esModule", { value: true }); exports.default = Service; //// [component.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var __metadata = (this && this.__metadata) || function (k, v) { if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); diff --git a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.js b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.js index 204b1ba9a49..911a93f948d 100644 --- a/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.js +++ b/tests/baselines/reference/decoratorMetadataForMethodWithNoReturnTypeAnnotation01.js @@ -20,12 +20,11 @@ var MyClass = (function () { } MyClass.prototype.doSomething = function () { }; - Object.defineProperty(MyClass.prototype, "doSomething", - __decorate([ - decorator, - __metadata('design:type', Function), - __metadata('design:paramtypes', []), - __metadata('design:returntype', void 0) - ], MyClass.prototype, "doSomething", Object.getOwnPropertyDescriptor(MyClass.prototype, "doSomething"))); + __decorate([ + decorator, + __metadata('design:type', Function), + __metadata('design:paramtypes', []), + __metadata('design:returntype', void 0) + ], MyClass.prototype, "doSomething", null); return MyClass; })(); diff --git a/tests/baselines/reference/decoratorMetadataOnInferredType.js b/tests/baselines/reference/decoratorMetadataOnInferredType.js index 8103dbbdafa..32aeca93c1b 100644 --- a/tests/baselines/reference/decoratorMetadataOnInferredType.js +++ b/tests/baselines/reference/decoratorMetadataOnInferredType.js @@ -33,7 +33,7 @@ var B = (function () { __decorate([ decorator, __metadata('design:type', Object) - ], B.prototype, "x"); + ], B.prototype, "x", void 0); return B; })(); exports.B = B; diff --git a/tests/baselines/reference/decoratorMetadataOnInferredType.symbols b/tests/baselines/reference/decoratorMetadataOnInferredType.symbols index e1507c75e94..09530f9cecf 100644 --- a/tests/baselines/reference/decoratorMetadataOnInferredType.symbols +++ b/tests/baselines/reference/decoratorMetadataOnInferredType.symbols @@ -21,7 +21,7 @@ class A { function decorator(target: Object, propertyKey: string) { >decorator : Symbol(decorator, Decl(decoratorMetadataOnInferredType.ts, 7, 1)) >target : Symbol(target, Decl(decoratorMetadataOnInferredType.ts, 9, 19)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >propertyKey : Symbol(propertyKey, Decl(decoratorMetadataOnInferredType.ts, 9, 34)) } diff --git a/tests/baselines/reference/decoratorMetadataWithConstructorType.js b/tests/baselines/reference/decoratorMetadataWithConstructorType.js index 1523915a390..717ae5c4ce2 100644 --- a/tests/baselines/reference/decoratorMetadataWithConstructorType.js +++ b/tests/baselines/reference/decoratorMetadataWithConstructorType.js @@ -33,7 +33,7 @@ var B = (function () { __decorate([ decorator, __metadata('design:type', A) - ], B.prototype, "x"); + ], B.prototype, "x", void 0); return B; })(); exports.B = B; diff --git a/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols b/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols index 57221f0d139..db1c388f206 100644 --- a/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols +++ b/tests/baselines/reference/decoratorMetadataWithConstructorType.symbols @@ -21,7 +21,7 @@ class A { function decorator(target: Object, propertyKey: string) { >decorator : Symbol(decorator, Decl(decoratorMetadataWithConstructorType.ts, 7, 1)) >target : Symbol(target, Decl(decoratorMetadataWithConstructorType.ts, 9, 19)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >propertyKey : Symbol(propertyKey, Decl(decoratorMetadataWithConstructorType.ts, 9, 34)) } diff --git a/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision.types b/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision.types index 60cf7f10cea..aa705735f3e 100644 --- a/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision.types +++ b/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision.types @@ -35,7 +35,7 @@ class MyClass { this.db = db; >this.db = db : db >this.db : db ->this : MyClass +>this : this >db : db >db : db @@ -43,7 +43,7 @@ class MyClass { >this.db.doSomething() : void >this.db.doSomething : () => void >this.db : db ->this : MyClass +>this : this >db : db >doSomething : () => void } diff --git a/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision2.types b/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision2.types index 73005b4673f..3d8ad0937bc 100644 --- a/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision2.types +++ b/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision2.types @@ -36,7 +36,7 @@ class MyClass { this.db = db; >this.db = db : Database >this.db : Database ->this : MyClass +>this : this >db : Database >db : Database @@ -44,7 +44,7 @@ class MyClass { >this.db.doSomething() : void >this.db.doSomething : () => void >this.db : Database ->this : MyClass +>this : this >db : Database >doSomething : () => void } diff --git a/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision3.types b/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision3.types index 0eea3e13b66..634c45e650c 100644 --- a/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision3.types +++ b/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision3.types @@ -28,7 +28,7 @@ class MyClass { this.db = db; >this.db = db : db.db >this.db : db.db ->this : MyClass +>this : this >db : db.db >db : db.db @@ -36,7 +36,7 @@ class MyClass { >this.db.doSomething() : void >this.db.doSomething : () => void >this.db : db.db ->this : MyClass +>this : this >db : db.db >doSomething : () => void } diff --git a/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision5.types b/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision5.types index 0fbc48db157..987d7a532e8 100644 --- a/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision5.types +++ b/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision5.types @@ -35,7 +35,7 @@ class MyClass { this.db = db; >this.db = db : db >this.db : db ->this : MyClass +>this : this >db : db >db : db @@ -43,7 +43,7 @@ class MyClass { >this.db.doSomething() : void >this.db.doSomething : () => void >this.db : db ->this : MyClass +>this : this >db : db >doSomething : () => void } diff --git a/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision6.types b/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision6.types index e3a68882dfb..3bd8df0eff3 100644 --- a/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision6.types +++ b/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision6.types @@ -35,7 +35,7 @@ class MyClass { this.db = db; >this.db = db : database >this.db : database ->this : MyClass +>this : this >db : database >db : database @@ -43,7 +43,7 @@ class MyClass { >this.db.doSomething() : void >this.db.doSomething : () => void >this.db : database ->this : MyClass +>this : this >db : database >doSomething : () => void } diff --git a/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision8.types b/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision8.types index faaab056885..f0f1ca190aa 100644 --- a/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision8.types +++ b/tests/baselines/reference/decoratorMetadataWithImportDeclarationNameCollision8.types @@ -28,7 +28,7 @@ class MyClass { this.db = db; >this.db = db : database.db >this.db : database.db ->this : MyClass +>this : this >db : database.db >db : database.db @@ -36,7 +36,7 @@ class MyClass { >this.db.doSomething() : void >this.db.doSomething : () => void >this.db : database.db ->this : MyClass +>this : this >db : database.db >doSomething : () => void } diff --git a/tests/baselines/reference/decoratorOnClass1.js b/tests/baselines/reference/decoratorOnClass1.js index b8099222acc..81fb8a4afbf 100644 --- a/tests/baselines/reference/decoratorOnClass1.js +++ b/tests/baselines/reference/decoratorOnClass1.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClass1.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { diff --git a/tests/baselines/reference/decoratorOnClass2.js b/tests/baselines/reference/decoratorOnClass2.js index 18492794331..5e5f4e4b07d 100644 --- a/tests/baselines/reference/decoratorOnClass2.js +++ b/tests/baselines/reference/decoratorOnClass2.js @@ -7,12 +7,10 @@ export class C { //// [decoratorOnClass2.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { diff --git a/tests/baselines/reference/decoratorOnClass3.js b/tests/baselines/reference/decoratorOnClass3.js index 2291a2dbc57..53888b7f107 100644 --- a/tests/baselines/reference/decoratorOnClass3.js +++ b/tests/baselines/reference/decoratorOnClass3.js @@ -8,12 +8,10 @@ class C { //// [decoratorOnClass3.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { diff --git a/tests/baselines/reference/decoratorOnClass4.js b/tests/baselines/reference/decoratorOnClass4.js index 484efdf6128..bfcfe490498 100644 --- a/tests/baselines/reference/decoratorOnClass4.js +++ b/tests/baselines/reference/decoratorOnClass4.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClass4.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { diff --git a/tests/baselines/reference/decoratorOnClass5.js b/tests/baselines/reference/decoratorOnClass5.js index 02ea01c3fd6..b3ceb807408 100644 --- a/tests/baselines/reference/decoratorOnClass5.js +++ b/tests/baselines/reference/decoratorOnClass5.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClass5.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { diff --git a/tests/baselines/reference/decoratorOnClass8.js b/tests/baselines/reference/decoratorOnClass8.js index e75ccac3c86..81edefc39fa 100644 --- a/tests/baselines/reference/decoratorOnClass8.js +++ b/tests/baselines/reference/decoratorOnClass8.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClass8.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { diff --git a/tests/baselines/reference/decoratorOnClassAccessor1.js b/tests/baselines/reference/decoratorOnClassAccessor1.js index 2700c531e42..5a5d7ec98ee 100644 --- a/tests/baselines/reference/decoratorOnClassAccessor1.js +++ b/tests/baselines/reference/decoratorOnClassAccessor1.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClassAccessor1.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { @@ -22,9 +20,8 @@ var C = (function () { enumerable: true, configurable: true }); - Object.defineProperty(C.prototype, "accessor", - __decorate([ - dec - ], C.prototype, "accessor", Object.getOwnPropertyDescriptor(C.prototype, "accessor"))); + __decorate([ + dec + ], C.prototype, "accessor", null); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassAccessor1.symbols b/tests/baselines/reference/decoratorOnClassAccessor1.symbols index 933dff1b4c5..6b8e3a16c18 100644 --- a/tests/baselines/reference/decoratorOnClassAccessor1.symbols +++ b/tests/baselines/reference/decoratorOnClassAccessor1.symbols @@ -5,9 +5,9 @@ declare function dec(target: any, propertyKey: string, descriptor: TypedPrope >target : Symbol(target, Decl(decoratorOnClassAccessor1.ts, 0, 24)) >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassAccessor1.ts, 0, 36)) >descriptor : Symbol(descriptor, Decl(decoratorOnClassAccessor1.ts, 0, 57)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassAccessor1.ts, 0, 21)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassAccessor1.ts, 0, 21)) class C { diff --git a/tests/baselines/reference/decoratorOnClassAccessor2.js b/tests/baselines/reference/decoratorOnClassAccessor2.js index c29c7598013..62b4d46669b 100644 --- a/tests/baselines/reference/decoratorOnClassAccessor2.js +++ b/tests/baselines/reference/decoratorOnClassAccessor2.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClassAccessor2.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { @@ -22,9 +20,8 @@ var C = (function () { enumerable: true, configurable: true }); - Object.defineProperty(C.prototype, "accessor", - __decorate([ - dec - ], C.prototype, "accessor", Object.getOwnPropertyDescriptor(C.prototype, "accessor"))); + __decorate([ + dec + ], C.prototype, "accessor", null); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassAccessor2.symbols b/tests/baselines/reference/decoratorOnClassAccessor2.symbols index 5738bb50bb8..936afa14de9 100644 --- a/tests/baselines/reference/decoratorOnClassAccessor2.symbols +++ b/tests/baselines/reference/decoratorOnClassAccessor2.symbols @@ -5,9 +5,9 @@ declare function dec(target: any, propertyKey: string, descriptor: TypedPrope >target : Symbol(target, Decl(decoratorOnClassAccessor2.ts, 0, 24)) >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassAccessor2.ts, 0, 36)) >descriptor : Symbol(descriptor, Decl(decoratorOnClassAccessor2.ts, 0, 57)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassAccessor2.ts, 0, 21)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassAccessor2.ts, 0, 21)) class C { diff --git a/tests/baselines/reference/decoratorOnClassAccessor3.js b/tests/baselines/reference/decoratorOnClassAccessor3.js index 61430a986ac..ce630dde3b2 100644 --- a/tests/baselines/reference/decoratorOnClassAccessor3.js +++ b/tests/baselines/reference/decoratorOnClassAccessor3.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClassAccessor3.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { @@ -22,9 +20,8 @@ var C = (function () { enumerable: true, configurable: true }); - Object.defineProperty(C.prototype, "accessor", - __decorate([ - dec - ], C.prototype, "accessor", Object.getOwnPropertyDescriptor(C.prototype, "accessor"))); + __decorate([ + dec + ], C.prototype, "accessor", null); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassAccessor4.js b/tests/baselines/reference/decoratorOnClassAccessor4.js index 0ad11c4c09e..5d47233c797 100644 --- a/tests/baselines/reference/decoratorOnClassAccessor4.js +++ b/tests/baselines/reference/decoratorOnClassAccessor4.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClassAccessor4.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { @@ -22,9 +20,8 @@ var C = (function () { enumerable: true, configurable: true }); - Object.defineProperty(C.prototype, "accessor", - __decorate([ - dec - ], C.prototype, "accessor", Object.getOwnPropertyDescriptor(C.prototype, "accessor"))); + __decorate([ + dec + ], C.prototype, "accessor", null); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassAccessor4.symbols b/tests/baselines/reference/decoratorOnClassAccessor4.symbols index 1100df1c081..0acd491abed 100644 --- a/tests/baselines/reference/decoratorOnClassAccessor4.symbols +++ b/tests/baselines/reference/decoratorOnClassAccessor4.symbols @@ -5,9 +5,9 @@ declare function dec(target: any, propertyKey: string, descriptor: TypedPrope >target : Symbol(target, Decl(decoratorOnClassAccessor4.ts, 0, 24)) >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassAccessor4.ts, 0, 36)) >descriptor : Symbol(descriptor, Decl(decoratorOnClassAccessor4.ts, 0, 57)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassAccessor4.ts, 0, 21)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassAccessor4.ts, 0, 21)) class C { diff --git a/tests/baselines/reference/decoratorOnClassAccessor5.js b/tests/baselines/reference/decoratorOnClassAccessor5.js index 53a43f7912c..b0383637272 100644 --- a/tests/baselines/reference/decoratorOnClassAccessor5.js +++ b/tests/baselines/reference/decoratorOnClassAccessor5.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClassAccessor5.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { @@ -22,9 +20,8 @@ var C = (function () { enumerable: true, configurable: true }); - Object.defineProperty(C.prototype, "accessor", - __decorate([ - dec - ], C.prototype, "accessor", Object.getOwnPropertyDescriptor(C.prototype, "accessor"))); + __decorate([ + dec + ], C.prototype, "accessor", null); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassAccessor5.symbols b/tests/baselines/reference/decoratorOnClassAccessor5.symbols index 8d9927776c2..0585cff96b6 100644 --- a/tests/baselines/reference/decoratorOnClassAccessor5.symbols +++ b/tests/baselines/reference/decoratorOnClassAccessor5.symbols @@ -5,9 +5,9 @@ declare function dec(target: any, propertyKey: string, descriptor: TypedPrope >target : Symbol(target, Decl(decoratorOnClassAccessor5.ts, 0, 24)) >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassAccessor5.ts, 0, 36)) >descriptor : Symbol(descriptor, Decl(decoratorOnClassAccessor5.ts, 0, 57)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassAccessor5.ts, 0, 21)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassAccessor5.ts, 0, 21)) class C { diff --git a/tests/baselines/reference/decoratorOnClassAccessor6.js b/tests/baselines/reference/decoratorOnClassAccessor6.js index eaa21f45234..e76151ef562 100644 --- a/tests/baselines/reference/decoratorOnClassAccessor6.js +++ b/tests/baselines/reference/decoratorOnClassAccessor6.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClassAccessor6.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { @@ -22,9 +20,8 @@ var C = (function () { enumerable: true, configurable: true }); - Object.defineProperty(C.prototype, "accessor", - __decorate([ - dec - ], C.prototype, "accessor", Object.getOwnPropertyDescriptor(C.prototype, "accessor"))); + __decorate([ + dec + ], C.prototype, "accessor", null); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassConstructorParameter1.js b/tests/baselines/reference/decoratorOnClassConstructorParameter1.js index b2af1450123..b100a5a60f8 100644 --- a/tests/baselines/reference/decoratorOnClassConstructorParameter1.js +++ b/tests/baselines/reference/decoratorOnClassConstructorParameter1.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClassConstructorParameter1.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var __param = (this && this.__param) || function (paramIndex, decorator) { return function (target, key) { decorator(target, key, paramIndex); } diff --git a/tests/baselines/reference/decoratorOnClassConstructorParameter1.symbols b/tests/baselines/reference/decoratorOnClassConstructorParameter1.symbols index a863f74e2ff..2349029421c 100644 --- a/tests/baselines/reference/decoratorOnClassConstructorParameter1.symbols +++ b/tests/baselines/reference/decoratorOnClassConstructorParameter1.symbols @@ -2,7 +2,7 @@ declare function dec(target: Function, propertyKey: string | symbol, parameterIndex: number): void; >dec : Symbol(dec, Decl(decoratorOnClassConstructorParameter1.ts, 0, 0)) >target : Symbol(target, Decl(decoratorOnClassConstructorParameter1.ts, 0, 21)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassConstructorParameter1.ts, 0, 38)) >parameterIndex : Symbol(parameterIndex, Decl(decoratorOnClassConstructorParameter1.ts, 0, 68)) diff --git a/tests/baselines/reference/decoratorOnClassConstructorParameter4.js b/tests/baselines/reference/decoratorOnClassConstructorParameter4.js index 5273482586e..73d7bfba5a9 100644 --- a/tests/baselines/reference/decoratorOnClassConstructorParameter4.js +++ b/tests/baselines/reference/decoratorOnClassConstructorParameter4.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClassConstructorParameter4.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var __param = (this && this.__param) || function (paramIndex, decorator) { return function (target, key) { decorator(target, key, paramIndex); } diff --git a/tests/baselines/reference/decoratorOnClassMethod1.js b/tests/baselines/reference/decoratorOnClassMethod1.js index 65c2f4b6008..3b8d308570c 100644 --- a/tests/baselines/reference/decoratorOnClassMethod1.js +++ b/tests/baselines/reference/decoratorOnClassMethod1.js @@ -7,20 +7,17 @@ class C { //// [decoratorOnClassMethod1.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } C.prototype.method = function () { }; - Object.defineProperty(C.prototype, "method", - __decorate([ - dec - ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method"))); + __decorate([ + dec + ], C.prototype, "method", null); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassMethod1.symbols b/tests/baselines/reference/decoratorOnClassMethod1.symbols index f1463115f49..8a92ad7b01b 100644 --- a/tests/baselines/reference/decoratorOnClassMethod1.symbols +++ b/tests/baselines/reference/decoratorOnClassMethod1.symbols @@ -5,9 +5,9 @@ declare function dec(target: any, propertyKey: string, descriptor: TypedPrope >target : Symbol(target, Decl(decoratorOnClassMethod1.ts, 0, 24)) >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod1.ts, 0, 36)) >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod1.ts, 0, 57)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassMethod1.ts, 0, 21)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassMethod1.ts, 0, 21)) class C { diff --git a/tests/baselines/reference/decoratorOnClassMethod10.js b/tests/baselines/reference/decoratorOnClassMethod10.js index bae4e97fb5b..22a6be7f613 100644 --- a/tests/baselines/reference/decoratorOnClassMethod10.js +++ b/tests/baselines/reference/decoratorOnClassMethod10.js @@ -7,20 +7,17 @@ class C { //// [decoratorOnClassMethod10.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } C.prototype.method = function () { }; - Object.defineProperty(C.prototype, "method", - __decorate([ - dec - ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method"))); + __decorate([ + dec + ], C.prototype, "method", null); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassMethod11.js b/tests/baselines/reference/decoratorOnClassMethod11.js index 5d4ac60c14e..59f0594f483 100644 --- a/tests/baselines/reference/decoratorOnClassMethod11.js +++ b/tests/baselines/reference/decoratorOnClassMethod11.js @@ -10,12 +10,10 @@ module M { //// [decoratorOnClassMethod11.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var M; (function (M) { @@ -24,10 +22,9 @@ var M; } C.prototype.decorator = function (target, key) { }; C.prototype.method = function () { }; - Object.defineProperty(C.prototype, "method", - __decorate([ - this.decorator - ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method"))); + __decorate([ + this.decorator + ], C.prototype, "method", null); return C; })(); })(M || (M = {})); diff --git a/tests/baselines/reference/decoratorOnClassMethod12.js b/tests/baselines/reference/decoratorOnClassMethod12.js index 05c4f285291..5c43251e4c1 100644 --- a/tests/baselines/reference/decoratorOnClassMethod12.js +++ b/tests/baselines/reference/decoratorOnClassMethod12.js @@ -16,12 +16,10 @@ var __extends = (this && this.__extends) || function (d, b) { d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); }; var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var M; (function (M) { @@ -37,10 +35,9 @@ var M; _super.apply(this, arguments); } C.prototype.method = function () { }; - Object.defineProperty(C.prototype, "method", - __decorate([ - _super.decorator - ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method"))); + __decorate([ + _super.decorator + ], C.prototype, "method", null); return C; })(S); })(M || (M = {})); diff --git a/tests/baselines/reference/decoratorOnClassMethod13.js b/tests/baselines/reference/decoratorOnClassMethod13.js index b39fa63686a..adf21f733eb 100644 --- a/tests/baselines/reference/decoratorOnClassMethod13.js +++ b/tests/baselines/reference/decoratorOnClassMethod13.js @@ -8,23 +8,19 @@ class C { //// [decoratorOnClassMethod13.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; class C { [_a = "1"]() { } [_b = "b"]() { } } -Object.defineProperty(C.prototype, _a, - __decorate([ - dec - ], C.prototype, _a, Object.getOwnPropertyDescriptor(C.prototype, _a))); -Object.defineProperty(C.prototype, _b, - __decorate([ - dec - ], C.prototype, _b, Object.getOwnPropertyDescriptor(C.prototype, _b))); +__decorate([ + dec +], C.prototype, _a, null); +__decorate([ + dec +], C.prototype, _b, null); var _a, _b; diff --git a/tests/baselines/reference/decoratorOnClassMethod13.symbols b/tests/baselines/reference/decoratorOnClassMethod13.symbols index 42f44d885ee..6dfcd15d040 100644 --- a/tests/baselines/reference/decoratorOnClassMethod13.symbols +++ b/tests/baselines/reference/decoratorOnClassMethod13.symbols @@ -5,9 +5,9 @@ declare function dec(target: any, propertyKey: string, descriptor: TypedPrope >target : Symbol(target, Decl(decoratorOnClassMethod13.ts, 0, 24)) >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod13.ts, 0, 36)) >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod13.ts, 0, 57)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassMethod13.ts, 0, 21)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassMethod13.ts, 0, 21)) class C { diff --git a/tests/baselines/reference/decoratorOnClassMethod2.js b/tests/baselines/reference/decoratorOnClassMethod2.js index 8b4ceeb47ee..1841baeb724 100644 --- a/tests/baselines/reference/decoratorOnClassMethod2.js +++ b/tests/baselines/reference/decoratorOnClassMethod2.js @@ -7,20 +7,17 @@ class C { //// [decoratorOnClassMethod2.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } C.prototype.method = function () { }; - Object.defineProperty(C.prototype, "method", - __decorate([ - dec - ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method"))); + __decorate([ + dec + ], C.prototype, "method", null); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassMethod2.symbols b/tests/baselines/reference/decoratorOnClassMethod2.symbols index e7942d3ae45..ebab8905469 100644 --- a/tests/baselines/reference/decoratorOnClassMethod2.symbols +++ b/tests/baselines/reference/decoratorOnClassMethod2.symbols @@ -5,9 +5,9 @@ declare function dec(target: any, propertyKey: string, descriptor: TypedPrope >target : Symbol(target, Decl(decoratorOnClassMethod2.ts, 0, 24)) >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod2.ts, 0, 36)) >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod2.ts, 0, 57)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassMethod2.ts, 0, 21)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassMethod2.ts, 0, 21)) class C { diff --git a/tests/baselines/reference/decoratorOnClassMethod3.js b/tests/baselines/reference/decoratorOnClassMethod3.js index fff0e845860..8ede72027d8 100644 --- a/tests/baselines/reference/decoratorOnClassMethod3.js +++ b/tests/baselines/reference/decoratorOnClassMethod3.js @@ -7,20 +7,17 @@ class C { //// [decoratorOnClassMethod3.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } C.prototype.method = function () { }; - Object.defineProperty(C.prototype, "method", - __decorate([ - dec - ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method"))); + __decorate([ + dec + ], C.prototype, "method", null); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassMethod4.js b/tests/baselines/reference/decoratorOnClassMethod4.js index 9f5b0d67eb1..5c7b91c1c83 100644 --- a/tests/baselines/reference/decoratorOnClassMethod4.js +++ b/tests/baselines/reference/decoratorOnClassMethod4.js @@ -7,18 +7,15 @@ class C { //// [decoratorOnClassMethod4.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; class C { [_a = "method"]() { } } -Object.defineProperty(C.prototype, _a, - __decorate([ - dec - ], C.prototype, _a, Object.getOwnPropertyDescriptor(C.prototype, _a))); +__decorate([ + dec +], C.prototype, _a, null); var _a; diff --git a/tests/baselines/reference/decoratorOnClassMethod4.symbols b/tests/baselines/reference/decoratorOnClassMethod4.symbols index 688bc03775a..745fb8c4ce7 100644 --- a/tests/baselines/reference/decoratorOnClassMethod4.symbols +++ b/tests/baselines/reference/decoratorOnClassMethod4.symbols @@ -5,9 +5,9 @@ declare function dec(target: any, propertyKey: string, descriptor: TypedPrope >target : Symbol(target, Decl(decoratorOnClassMethod4.ts, 0, 24)) >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod4.ts, 0, 36)) >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod4.ts, 0, 57)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassMethod4.ts, 0, 21)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassMethod4.ts, 0, 21)) class C { diff --git a/tests/baselines/reference/decoratorOnClassMethod5.js b/tests/baselines/reference/decoratorOnClassMethod5.js index f767b176207..2fedbaaf764 100644 --- a/tests/baselines/reference/decoratorOnClassMethod5.js +++ b/tests/baselines/reference/decoratorOnClassMethod5.js @@ -7,18 +7,15 @@ class C { //// [decoratorOnClassMethod5.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; class C { [_a = "method"]() { } } -Object.defineProperty(C.prototype, _a, - __decorate([ - dec() - ], C.prototype, _a, Object.getOwnPropertyDescriptor(C.prototype, _a))); +__decorate([ + dec() +], C.prototype, _a, null); var _a; diff --git a/tests/baselines/reference/decoratorOnClassMethod5.symbols b/tests/baselines/reference/decoratorOnClassMethod5.symbols index 6356ca35449..124ace783fe 100644 --- a/tests/baselines/reference/decoratorOnClassMethod5.symbols +++ b/tests/baselines/reference/decoratorOnClassMethod5.symbols @@ -5,9 +5,9 @@ declare function dec(): (target: any, propertyKey: string, descriptor: TypedP >target : Symbol(target, Decl(decoratorOnClassMethod5.ts, 0, 28)) >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod5.ts, 0, 40)) >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod5.ts, 0, 61)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassMethod5.ts, 0, 25)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassMethod5.ts, 0, 25)) class C { diff --git a/tests/baselines/reference/decoratorOnClassMethod6.js b/tests/baselines/reference/decoratorOnClassMethod6.js index 33dc4c86fd2..7966225e221 100644 --- a/tests/baselines/reference/decoratorOnClassMethod6.js +++ b/tests/baselines/reference/decoratorOnClassMethod6.js @@ -7,18 +7,15 @@ class C { //// [decoratorOnClassMethod6.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; class C { [_a = "method"]() { } } -Object.defineProperty(C.prototype, _a, - __decorate([ - dec - ], C.prototype, _a, Object.getOwnPropertyDescriptor(C.prototype, _a))); +__decorate([ + dec +], C.prototype, _a, null); var _a; diff --git a/tests/baselines/reference/decoratorOnClassMethod7.js b/tests/baselines/reference/decoratorOnClassMethod7.js index c20a726fc46..3ec509e17f0 100644 --- a/tests/baselines/reference/decoratorOnClassMethod7.js +++ b/tests/baselines/reference/decoratorOnClassMethod7.js @@ -7,18 +7,15 @@ class C { //// [decoratorOnClassMethod7.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; class C { [_a = "method"]() { } } -Object.defineProperty(C.prototype, _a, - __decorate([ - dec - ], C.prototype, _a, Object.getOwnPropertyDescriptor(C.prototype, _a))); +__decorate([ + dec +], C.prototype, _a, null); var _a; diff --git a/tests/baselines/reference/decoratorOnClassMethod7.symbols b/tests/baselines/reference/decoratorOnClassMethod7.symbols index 75c3bee294d..e870a798559 100644 --- a/tests/baselines/reference/decoratorOnClassMethod7.symbols +++ b/tests/baselines/reference/decoratorOnClassMethod7.symbols @@ -5,9 +5,9 @@ declare function dec(target: any, propertyKey: string, descriptor: TypedPrope >target : Symbol(target, Decl(decoratorOnClassMethod7.ts, 0, 24)) >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethod7.ts, 0, 36)) >descriptor : Symbol(descriptor, Decl(decoratorOnClassMethod7.ts, 0, 57)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassMethod7.ts, 0, 21)) ->TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, 1171, 36)) +>TypedPropertyDescriptor : Symbol(TypedPropertyDescriptor, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(decoratorOnClassMethod7.ts, 0, 21)) class C { diff --git a/tests/baselines/reference/decoratorOnClassMethod8.js b/tests/baselines/reference/decoratorOnClassMethod8.js index a664bdb8494..2cb404cf078 100644 --- a/tests/baselines/reference/decoratorOnClassMethod8.js +++ b/tests/baselines/reference/decoratorOnClassMethod8.js @@ -7,20 +7,17 @@ class C { //// [decoratorOnClassMethod8.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } C.prototype.method = function () { }; - Object.defineProperty(C.prototype, "method", - __decorate([ - dec - ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method"))); + __decorate([ + dec + ], C.prototype, "method", null); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassMethodParameter1.js b/tests/baselines/reference/decoratorOnClassMethodParameter1.js index a6ab1704acc..099f746727c 100644 --- a/tests/baselines/reference/decoratorOnClassMethodParameter1.js +++ b/tests/baselines/reference/decoratorOnClassMethodParameter1.js @@ -7,12 +7,10 @@ class C { //// [decoratorOnClassMethodParameter1.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var __param = (this && this.__param) || function (paramIndex, decorator) { return function (target, key) { decorator(target, key, paramIndex); } @@ -21,9 +19,8 @@ var C = (function () { function C() { } C.prototype.method = function (p) { }; - Object.defineProperty(C.prototype, "method", - __decorate([ - __param(0, dec) - ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method"))); + __decorate([ + __param(0, dec) + ], C.prototype, "method", null); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassMethodParameter1.symbols b/tests/baselines/reference/decoratorOnClassMethodParameter1.symbols index 47c5999ff47..1358343a9c5 100644 --- a/tests/baselines/reference/decoratorOnClassMethodParameter1.symbols +++ b/tests/baselines/reference/decoratorOnClassMethodParameter1.symbols @@ -2,7 +2,7 @@ declare function dec(target: Object, propertyKey: string | symbol, parameterIndex: number): void; >dec : Symbol(dec, Decl(decoratorOnClassMethodParameter1.ts, 0, 0)) >target : Symbol(target, Decl(decoratorOnClassMethodParameter1.ts, 0, 21)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >propertyKey : Symbol(propertyKey, Decl(decoratorOnClassMethodParameter1.ts, 0, 36)) >parameterIndex : Symbol(parameterIndex, Decl(decoratorOnClassMethodParameter1.ts, 0, 66)) diff --git a/tests/baselines/reference/decoratorOnClassProperty1.js b/tests/baselines/reference/decoratorOnClassProperty1.js index 567eb510cb3..9283570bf3a 100644 --- a/tests/baselines/reference/decoratorOnClassProperty1.js +++ b/tests/baselines/reference/decoratorOnClassProperty1.js @@ -7,18 +7,16 @@ class C { //// [decoratorOnClassProperty1.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } __decorate([ dec - ], C.prototype, "prop"); + ], C.prototype, "prop", void 0); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassProperty10.js b/tests/baselines/reference/decoratorOnClassProperty10.js index b64986a8c97..5246dff9643 100644 --- a/tests/baselines/reference/decoratorOnClassProperty10.js +++ b/tests/baselines/reference/decoratorOnClassProperty10.js @@ -7,18 +7,16 @@ class C { //// [decoratorOnClassProperty10.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } __decorate([ dec() - ], C.prototype, "prop"); + ], C.prototype, "prop", void 0); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassProperty11.js b/tests/baselines/reference/decoratorOnClassProperty11.js index a33fc724180..51bce1f1385 100644 --- a/tests/baselines/reference/decoratorOnClassProperty11.js +++ b/tests/baselines/reference/decoratorOnClassProperty11.js @@ -7,18 +7,16 @@ class C { //// [decoratorOnClassProperty11.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } __decorate([ dec - ], C.prototype, "prop"); + ], C.prototype, "prop", void 0); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassProperty2.js b/tests/baselines/reference/decoratorOnClassProperty2.js index f5de593b057..153c72ce0b9 100644 --- a/tests/baselines/reference/decoratorOnClassProperty2.js +++ b/tests/baselines/reference/decoratorOnClassProperty2.js @@ -7,18 +7,16 @@ class C { //// [decoratorOnClassProperty2.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } __decorate([ dec - ], C.prototype, "prop"); + ], C.prototype, "prop", void 0); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassProperty3.js b/tests/baselines/reference/decoratorOnClassProperty3.js index d2876d2cd6a..4f3b1ca5929 100644 --- a/tests/baselines/reference/decoratorOnClassProperty3.js +++ b/tests/baselines/reference/decoratorOnClassProperty3.js @@ -7,18 +7,16 @@ class C { //// [decoratorOnClassProperty3.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } __decorate([ dec - ], C.prototype, "prop"); + ], C.prototype, "prop", void 0); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassProperty6.js b/tests/baselines/reference/decoratorOnClassProperty6.js index 4ebd19ceee8..e92e018c587 100644 --- a/tests/baselines/reference/decoratorOnClassProperty6.js +++ b/tests/baselines/reference/decoratorOnClassProperty6.js @@ -7,18 +7,16 @@ class C { //// [decoratorOnClassProperty6.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } __decorate([ dec - ], C.prototype, "prop"); + ], C.prototype, "prop", void 0); return C; })(); diff --git a/tests/baselines/reference/decoratorOnClassProperty7.js b/tests/baselines/reference/decoratorOnClassProperty7.js index 045f8722b97..9521fe0ce5e 100644 --- a/tests/baselines/reference/decoratorOnClassProperty7.js +++ b/tests/baselines/reference/decoratorOnClassProperty7.js @@ -7,18 +7,16 @@ class C { //// [decoratorOnClassProperty7.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } __decorate([ dec - ], C.prototype, "prop"); + ], C.prototype, "prop", void 0); return C; })(); diff --git a/tests/baselines/reference/defaultExportWithOverloads01.js b/tests/baselines/reference/defaultExportWithOverloads01.js new file mode 100644 index 00000000000..9ec8cccf5bf --- /dev/null +++ b/tests/baselines/reference/defaultExportWithOverloads01.js @@ -0,0 +1,16 @@ +//// [defaultExportWithOverloads01.ts] + +export default function f(); +export default function f(x: string); +export default function f(...args: any[]) { +} + +//// [defaultExportWithOverloads01.js] +function f() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i - 0] = arguments[_i]; + } +} +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = f; diff --git a/tests/baselines/reference/defaultExportWithOverloads01.symbols b/tests/baselines/reference/defaultExportWithOverloads01.symbols new file mode 100644 index 00000000000..a5ff0df5262 --- /dev/null +++ b/tests/baselines/reference/defaultExportWithOverloads01.symbols @@ -0,0 +1,13 @@ +=== 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)) + +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)) + +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)) +} diff --git a/tests/baselines/reference/defaultExportWithOverloads01.types b/tests/baselines/reference/defaultExportWithOverloads01.types new file mode 100644 index 00000000000..c006083b4ba --- /dev/null +++ b/tests/baselines/reference/defaultExportWithOverloads01.types @@ -0,0 +1,13 @@ +=== tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts === + +export default function f(); +>f : { (): any; (x: string): any; } + +export default function f(x: string); +>f : { (): any; (x: string): any; } +>x : string + +export default function f(...args: any[]) { +>f : { (): any; (x: string): any; } +>args : any[] +} diff --git a/tests/baselines/reference/deleteOperatorWithStringType.symbols b/tests/baselines/reference/deleteOperatorWithStringType.symbols index a13ddd5fa39..204aac0123b 100644 --- a/tests/baselines/reference/deleteOperatorWithStringType.symbols +++ b/tests/baselines/reference/deleteOperatorWithStringType.symbols @@ -88,9 +88,9 @@ var ResultIsBoolean11 = delete (STRING + STRING); var ResultIsBoolean12 = delete STRING.charAt(0); >ResultIsBoolean12 : Symbol(ResultIsBoolean12, Decl(deleteOperatorWithStringType.ts, 32, 3)) ->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(deleteOperatorWithStringType.ts, 1, 3)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) // multiple delete operator var ResultIsBoolean13 = delete delete STRING; diff --git a/tests/baselines/reference/derivedClassOverridesIndexersWithAssignmentCompatibility.symbols b/tests/baselines/reference/derivedClassOverridesIndexersWithAssignmentCompatibility.symbols index dd384838694..17fb21e867d 100644 --- a/tests/baselines/reference/derivedClassOverridesIndexersWithAssignmentCompatibility.symbols +++ b/tests/baselines/reference/derivedClassOverridesIndexersWithAssignmentCompatibility.symbols @@ -4,7 +4,7 @@ class Base { [x: string]: Object; >x : Symbol(x, Decl(derivedClassOverridesIndexersWithAssignmentCompatibility.ts, 1, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } // ok, use assignment compatibility @@ -21,7 +21,7 @@ class Base2 { [x: number]: Object; >x : Symbol(x, Decl(derivedClassOverridesIndexersWithAssignmentCompatibility.ts, 10, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } // ok, use assignment compatibility diff --git a/tests/baselines/reference/derivedClassOverridesProtectedMembers2.symbols b/tests/baselines/reference/derivedClassOverridesProtectedMembers2.symbols index 59d062f459c..b1160328160 100644 --- a/tests/baselines/reference/derivedClassOverridesProtectedMembers2.symbols +++ b/tests/baselines/reference/derivedClassOverridesProtectedMembers2.symbols @@ -193,7 +193,7 @@ class Base2 { [i: string]: Object; >i : Symbol(i, Decl(derivedClassOverridesProtectedMembers2.ts, 49, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [i: number]: typeof x; >i : Symbol(i, Decl(derivedClassOverridesProtectedMembers2.ts, 50, 5)) diff --git a/tests/baselines/reference/derivedClasses.types b/tests/baselines/reference/derivedClasses.types index 906cfb2741c..7fc585e29ce 100644 --- a/tests/baselines/reference/derivedClasses.types +++ b/tests/baselines/reference/derivedClasses.types @@ -11,7 +11,7 @@ class Red extends Color { >() => { return this.hue(); } : () => string >this.hue() : string >this.hue : () => string ->this : Red +>this : this >hue : () => string return getHue() + " red"; @@ -46,7 +46,7 @@ class Blue extends Color { >() => { return this.hue(); } : () => string >this.hue() : string >this.hue : () => string ->this : Blue +>this : this >hue : () => string return getHue() + " blue"; diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols index c2130f060ab..c4dc8fd0f79 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES5.symbols @@ -8,19 +8,19 @@ type arrayString = Array >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES5.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type someArray = Array | number[]; >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES5.ts, 7, 32)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), 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(destructuringParameterDeclaration3ES5.ts, 8, 42)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), 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, --, --)) function a1(...x: (number|string)[]) { } >a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES5.ts, 9, 45)) @@ -33,8 +33,8 @@ function a2(...a) { } function a3(...a: Array) { } >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES5.ts, 12, 21)) >a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 13, 12)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), 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(destructuringParameterDeclaration3ES5.ts, 13, 36)) @@ -122,7 +122,7 @@ const enum E1 { a, b } function foo1(...a: T[]) { } >foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES5.ts, 39, 22)) >T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 40, 14)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(destructuringParameterDeclaration3ES5.ts, 40, 32)) >T : Symbol(T, Decl(destructuringParameterDeclaration3ES5.ts, 40, 14)) diff --git a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols index 976c402d2b0..46682802e2a 100644 --- a/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols +++ b/tests/baselines/reference/destructuringParameterDeclaration3ES6.symbols @@ -8,19 +8,19 @@ type arrayString = Array >arrayString : Symbol(arrayString, Decl(destructuringParameterDeclaration3ES6.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) type someArray = Array | number[]; >someArray : Symbol(someArray, Decl(destructuringParameterDeclaration3ES6.ts, 7, 32)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), 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(destructuringParameterDeclaration3ES6.ts, 8, 42)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), 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, --, --)) function a1(...x: (number|string)[]) { } >a1 : Symbol(a1, Decl(destructuringParameterDeclaration3ES6.ts, 9, 45)) @@ -33,8 +33,8 @@ function a2(...a) { } function a3(...a: Array) { } >a3 : Symbol(a3, Decl(destructuringParameterDeclaration3ES6.ts, 12, 21)) >a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 13, 12)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(lib.d.ts, 4118, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), 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(destructuringParameterDeclaration3ES6.ts, 13, 36)) @@ -122,7 +122,7 @@ const enum E1 { a, b } function foo1(...a: T[]) { } >foo1 : Symbol(foo1, Decl(destructuringParameterDeclaration3ES6.ts, 39, 22)) >T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 40, 14)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(destructuringParameterDeclaration3ES6.ts, 40, 32)) >T : Symbol(T, Decl(destructuringParameterDeclaration3ES6.ts, 40, 14)) diff --git a/tests/baselines/reference/destructuringWithGenericParameter.js b/tests/baselines/reference/destructuringWithGenericParameter.js new file mode 100644 index 00000000000..61d523f81fa --- /dev/null +++ b/tests/baselines/reference/destructuringWithGenericParameter.js @@ -0,0 +1,30 @@ +//// [destructuringWithGenericParameter.ts] +class GenericClass { + payload: T; +} + +var genericObject = new GenericClass<{ greeting: string }>(); + +function genericFunction(object: GenericClass, callback: (payload: T) => void) { + callback(object.payload); +} + +genericFunction(genericObject, ({greeting}) => { + var s = greeting.toLocaleLowerCase(); // Greeting should be of type string +}); + + +//// [destructuringWithGenericParameter.js] +var GenericClass = (function () { + function GenericClass() { + } + return GenericClass; +})(); +var genericObject = new GenericClass(); +function genericFunction(object, callback) { + callback(object.payload); +} +genericFunction(genericObject, function (_a) { + var greeting = _a.greeting; + var s = greeting.toLocaleLowerCase(); // Greeting should be of type string +}); diff --git a/tests/baselines/reference/destructuringWithGenericParameter.symbols b/tests/baselines/reference/destructuringWithGenericParameter.symbols new file mode 100644 index 00000000000..0c489cf1ef2 --- /dev/null +++ b/tests/baselines/reference/destructuringWithGenericParameter.symbols @@ -0,0 +1,45 @@ +=== tests/cases/compiler/destructuringWithGenericParameter.ts === +class GenericClass { +>GenericClass : Symbol(GenericClass, Decl(destructuringWithGenericParameter.ts, 0, 0)) +>T : Symbol(T, Decl(destructuringWithGenericParameter.ts, 0, 19)) + + payload: T; +>payload : Symbol(payload, Decl(destructuringWithGenericParameter.ts, 0, 23)) +>T : Symbol(T, Decl(destructuringWithGenericParameter.ts, 0, 19)) +} + +var genericObject = new GenericClass<{ greeting: string }>(); +>genericObject : Symbol(genericObject, Decl(destructuringWithGenericParameter.ts, 4, 3)) +>GenericClass : Symbol(GenericClass, Decl(destructuringWithGenericParameter.ts, 0, 0)) +>greeting : Symbol(greeting, Decl(destructuringWithGenericParameter.ts, 4, 38)) + +function genericFunction(object: GenericClass, callback: (payload: T) => void) { +>genericFunction : Symbol(genericFunction, Decl(destructuringWithGenericParameter.ts, 4, 61)) +>T : Symbol(T, Decl(destructuringWithGenericParameter.ts, 6, 25)) +>object : Symbol(object, Decl(destructuringWithGenericParameter.ts, 6, 28)) +>GenericClass : Symbol(GenericClass, Decl(destructuringWithGenericParameter.ts, 0, 0)) +>T : Symbol(T, Decl(destructuringWithGenericParameter.ts, 6, 25)) +>callback : Symbol(callback, Decl(destructuringWithGenericParameter.ts, 6, 52)) +>payload : Symbol(payload, Decl(destructuringWithGenericParameter.ts, 6, 64)) +>T : Symbol(T, Decl(destructuringWithGenericParameter.ts, 6, 25)) + + callback(object.payload); +>callback : Symbol(callback, Decl(destructuringWithGenericParameter.ts, 6, 52)) +>object.payload : Symbol(GenericClass.payload, Decl(destructuringWithGenericParameter.ts, 0, 23)) +>object : Symbol(object, Decl(destructuringWithGenericParameter.ts, 6, 28)) +>payload : Symbol(GenericClass.payload, Decl(destructuringWithGenericParameter.ts, 0, 23)) +} + +genericFunction(genericObject, ({greeting}) => { +>genericFunction : Symbol(genericFunction, Decl(destructuringWithGenericParameter.ts, 4, 61)) +>genericObject : Symbol(genericObject, Decl(destructuringWithGenericParameter.ts, 4, 3)) +>greeting : Symbol(greeting, Decl(destructuringWithGenericParameter.ts, 10, 33)) + + var s = greeting.toLocaleLowerCase(); // Greeting should be of type string +>s : Symbol(s, Decl(destructuringWithGenericParameter.ts, 11, 7)) +>greeting.toLocaleLowerCase : Symbol(String.toLocaleLowerCase, Decl(lib.d.ts, --, --)) +>greeting : Symbol(greeting, Decl(destructuringWithGenericParameter.ts, 10, 33)) +>toLocaleLowerCase : Symbol(String.toLocaleLowerCase, Decl(lib.d.ts, --, --)) + +}); + diff --git a/tests/baselines/reference/destructuringWithGenericParameter.types b/tests/baselines/reference/destructuringWithGenericParameter.types new file mode 100644 index 00000000000..07a86e679a9 --- /dev/null +++ b/tests/baselines/reference/destructuringWithGenericParameter.types @@ -0,0 +1,50 @@ +=== tests/cases/compiler/destructuringWithGenericParameter.ts === +class GenericClass { +>GenericClass : GenericClass +>T : T + + payload: T; +>payload : T +>T : T +} + +var genericObject = new GenericClass<{ greeting: string }>(); +>genericObject : GenericClass<{ greeting: string; }> +>new GenericClass<{ greeting: string }>() : GenericClass<{ greeting: string; }> +>GenericClass : typeof GenericClass +>greeting : string + +function genericFunction(object: GenericClass, callback: (payload: T) => void) { +>genericFunction : (object: GenericClass, callback: (payload: T) => void) => void +>T : T +>object : GenericClass +>GenericClass : GenericClass +>T : T +>callback : (payload: T) => void +>payload : T +>T : T + + callback(object.payload); +>callback(object.payload) : void +>callback : (payload: T) => void +>object.payload : T +>object : GenericClass +>payload : T +} + +genericFunction(genericObject, ({greeting}) => { +>genericFunction(genericObject, ({greeting}) => { var s = greeting.toLocaleLowerCase(); // Greeting should be of type string}) : void +>genericFunction : (object: GenericClass, callback: (payload: T) => void) => void +>genericObject : GenericClass<{ greeting: string; }> +>({greeting}) => { var s = greeting.toLocaleLowerCase(); // Greeting should be of type string} : ({greeting}: { greeting: string; }) => void +>greeting : string + + var s = greeting.toLocaleLowerCase(); // Greeting should be of type string +>s : string +>greeting.toLocaleLowerCase() : string +>greeting.toLocaleLowerCase : () => string +>greeting : string +>toLocaleLowerCase : () => string + +}); + diff --git a/tests/baselines/reference/detachedCommentAtStartOfConstructor1.types b/tests/baselines/reference/detachedCommentAtStartOfConstructor1.types index 392821de751..7cbae62f83d 100644 --- a/tests/baselines/reference/detachedCommentAtStartOfConstructor1.types +++ b/tests/baselines/reference/detachedCommentAtStartOfConstructor1.types @@ -19,13 +19,13 @@ class TestFile { >message + this.name : string >message : string >this.name : any ->this : TestFile +>this : this >name : any this.message = getMessage(); >this.message = getMessage() : string >this.message : string ->this : TestFile +>this : this >message : string >getMessage() : string >getMessage : () => string diff --git a/tests/baselines/reference/detachedCommentAtStartOfConstructor2.types b/tests/baselines/reference/detachedCommentAtStartOfConstructor2.types index b413cd557a5..830be456e9a 100644 --- a/tests/baselines/reference/detachedCommentAtStartOfConstructor2.types +++ b/tests/baselines/reference/detachedCommentAtStartOfConstructor2.types @@ -20,13 +20,13 @@ class TestFile { >message + this.name : string >message : string >this.name : string ->this : TestFile +>this : this >name : string this.message = getMessage(); >this.message = getMessage() : string >this.message : string ->this : TestFile +>this : this >message : string >getMessage() : string >getMessage : () => string diff --git a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.types b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.types index 016a123c5c1..e05a4c083cb 100644 --- a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.types +++ b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction1.types @@ -20,7 +20,7 @@ class TestFile { >message + this.name : string >message : string >this.name : string ->this : TestFile +>this : this >name : string } } diff --git a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.types b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.types index 2199a4490b5..8dde223dad0 100644 --- a/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.types +++ b/tests/baselines/reference/detachedCommentAtStartOfLambdaFunction2.types @@ -21,7 +21,7 @@ class TestFile { >message + this.name : string >message : string >this.name : string ->this : TestFile +>this : this >name : string } } diff --git a/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols b/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols index 41916162553..a1c083fbc15 100644 --- a/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols +++ b/tests/baselines/reference/duplicateOverloadInTypeAugmentation1.symbols @@ -1,36 +1,36 @@ === tests/cases/compiler/duplicateOverloadInTypeAugmentation1.ts === interface Array { ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 0)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 0)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, ->reduce : Symbol(reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29)) +>reduce : Symbol(reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29)) >callbackfn : Symbol(callbackfn, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 11)) >previousValue : Symbol(previousValue, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 24)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) >currentValue : Symbol(currentValue, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 41)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) >currentIndex : Symbol(currentIndex, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 58)) >array : Symbol(array, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 80)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) initialValue?: T): T; >initialValue : Symbol(initialValue, Decl(duplicateOverloadInTypeAugmentation1.ts, 1, 98)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) reduce(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, ->reduce : Symbol(reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29)) +>reduce : Symbol(reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29)) >U : Symbol(U, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 11)) >callbackfn : Symbol(callbackfn, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 14)) >previousValue : Symbol(previousValue, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 27)) >U : Symbol(U, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 11)) >currentValue : Symbol(currentValue, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 44)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) >currentIndex : Symbol(currentIndex, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 61)) >array : Symbol(array, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 83)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 16)) >U : Symbol(U, Decl(duplicateOverloadInTypeAugmentation1.ts, 3, 11)) initialValue: U): U; @@ -40,13 +40,13 @@ interface Array { } var a: Array; >a : Symbol(a, Decl(duplicateOverloadInTypeAugmentation1.ts, 6, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 0)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 0)) var r5 = a.reduce((x, y) => x + y); >r5 : Symbol(r5, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 3)) ->a.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29)) +>a.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29)) >a : Symbol(a, Decl(duplicateOverloadInTypeAugmentation1.ts, 6, 3)) ->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29)) +>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(duplicateOverloadInTypeAugmentation1.ts, 0, 20), Decl(duplicateOverloadInTypeAugmentation1.ts, 2, 29)) >x : Symbol(x, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 19)) >y : Symbol(y, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 21)) >x : Symbol(x, Decl(duplicateOverloadInTypeAugmentation1.ts, 7, 19)) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols index 3e7770ccdda..f5846be3738 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments14_ES6.symbols @@ -4,9 +4,9 @@ function f() { >f : Symbol(f, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 0, 0)) if (Math.random()) { ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.d.ts, --, --)) let arguments = 100; >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments14_ES6.ts, 3, 11)) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols index c0ea901fbbf..648f04b0814 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments15_ES6.symbols @@ -7,9 +7,9 @@ function f() { >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 2, 7)) if (Math.random()) { ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.d.ts, --, --)) const arguments = 100; >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments15_ES6.ts, 4, 13)) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols index 3d09056c8c3..bc9fcbfa159 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments16_ES6.symbols @@ -7,9 +7,9 @@ function f() { >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 2, 7), Decl(emitArrowFunctionWhenUsingArguments16_ES6.ts, 6, 7)) if (Math.random()) { ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.d.ts, --, --)) return () => arguments[0]; >arguments : Symbol(arguments) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols index 22431e495cc..65f4e121d10 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments17_ES6.symbols @@ -8,9 +8,9 @@ function f() { >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments17_ES6.ts, 2, 25)) if (Math.random()) { ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.d.ts, --, --)) return () => arguments[0]; >arguments : Symbol(arguments) diff --git a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols index 6dbbe9501d0..a15a10c29d8 100644 --- a/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols +++ b/tests/baselines/reference/emitArrowFunctionWhenUsingArguments18_ES6.symbols @@ -9,9 +9,9 @@ function f() { >arguments : Symbol(arguments, Decl(emitArrowFunctionWhenUsingArguments18_ES6.ts, 2, 31)) if (Math.random()) { ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11), Decl(lib.d.ts, 4419, 60)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>Math.random : Symbol(Math.random, Decl(lib.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>random : Symbol(Math.random, Decl(lib.d.ts, --, --)) return () => arguments; >arguments : Symbol(arguments) diff --git a/tests/baselines/reference/emitClassDeclarationWithConstructorInES6.types b/tests/baselines/reference/emitClassDeclarationWithConstructorInES6.types index ecb48cb3047..3bdf5af2ba5 100644 --- a/tests/baselines/reference/emitClassDeclarationWithConstructorInES6.types +++ b/tests/baselines/reference/emitClassDeclarationWithConstructorInES6.types @@ -38,7 +38,7 @@ class B { this.y = 10; >this.y = 10 : number >this.y : number ->this : B +>this : this >y : number >10 : number } @@ -53,7 +53,7 @@ class B { return this._bar; >this._bar : string ->this : B +>this : this >_bar : string } } diff --git a/tests/baselines/reference/emitClassDeclarationWithGetterSetterInES6.types b/tests/baselines/reference/emitClassDeclarationWithGetterSetterInES6.types index b26d6b3dd81..292fb961b10 100644 --- a/tests/baselines/reference/emitClassDeclarationWithGetterSetterInES6.types +++ b/tests/baselines/reference/emitClassDeclarationWithGetterSetterInES6.types @@ -10,7 +10,7 @@ class C { return this._name; >this._name : string ->this : C +>this : this >_name : string } static get name2(): string { diff --git a/tests/baselines/reference/emitClassDeclarationWithMethodInES6.types b/tests/baselines/reference/emitClassDeclarationWithMethodInES6.types index d3e75c9235c..10ae930c244 100644 --- a/tests/baselines/reference/emitClassDeclarationWithMethodInES6.types +++ b/tests/baselines/reference/emitClassDeclarationWithMethodInES6.types @@ -25,7 +25,7 @@ class D { return this._bar; >this._bar : string ->this : D +>this : this >_bar : string } baz(a: any, x: string): string { diff --git a/tests/baselines/reference/emitClassDeclarationWithPropertyAssignmentInES6.types b/tests/baselines/reference/emitClassDeclarationWithPropertyAssignmentInES6.types index f3504d655ed..ccf4ca3ca9d 100644 --- a/tests/baselines/reference/emitClassDeclarationWithPropertyAssignmentInES6.types +++ b/tests/baselines/reference/emitClassDeclarationWithPropertyAssignmentInES6.types @@ -21,7 +21,7 @@ class D { this.y = 10; >this.y = 10 : number >this.y : number ->this : D +>this : this >y : number >10 : number } @@ -55,7 +55,7 @@ class F extends D{ this.j = "HI"; >this.j = "HI" : string >this.j : string ->this : F +>this : this >j : string >"HI" : string } diff --git a/tests/baselines/reference/emitClassDeclarationWithThisKeywordInES6.types b/tests/baselines/reference/emitClassDeclarationWithThisKeywordInES6.types index 14c57a60bc4..7c0159fbd63 100644 --- a/tests/baselines/reference/emitClassDeclarationWithThisKeywordInES6.types +++ b/tests/baselines/reference/emitClassDeclarationWithThisKeywordInES6.types @@ -10,7 +10,7 @@ class B { this.x = 10; >this.x = 10 : number >this.x : number ->this : B +>this : this >x : number >10 : number } @@ -27,7 +27,7 @@ class B { >B : typeof B >log : (a: number) => void >this.x : number ->this : B +>this : this >x : number } @@ -36,7 +36,7 @@ class B { return this.x; >this.x : number ->this : B +>this : this >x : number } @@ -47,7 +47,7 @@ class B { this.x = y; >this.x = y : number >this.x : number ->this : B +>this : this >x : number >y : number } diff --git a/tests/baselines/reference/emitClassDeclarationWithTypeArgumentAndOverloadInES6.types b/tests/baselines/reference/emitClassDeclarationWithTypeArgumentAndOverloadInES6.types index ba515168a5d..4bc2bfdfa92 100644 --- a/tests/baselines/reference/emitClassDeclarationWithTypeArgumentAndOverloadInES6.types +++ b/tests/baselines/reference/emitClassDeclarationWithTypeArgumentAndOverloadInES6.types @@ -24,7 +24,7 @@ class B { >T : T >this.B = a : T >this.B : T ->this : B +>this : this >B : T >a : T @@ -47,7 +47,7 @@ class B { return this.x; >this.x : T ->this : B +>this : this >x : T } @@ -57,7 +57,7 @@ class B { return this.B; >this.B : T ->this : B +>this : this >B : T } set BBWith(c: T) { @@ -68,7 +68,7 @@ class B { this.B = c; >this.B = c : T >this.B : T ->this : B +>this : this >B : T >c : T } diff --git a/tests/baselines/reference/emitClassDeclarationWithTypeArgumentInES6.types b/tests/baselines/reference/emitClassDeclarationWithTypeArgumentInES6.types index 8081d044e35..b4d2df96712 100644 --- a/tests/baselines/reference/emitClassDeclarationWithTypeArgumentInES6.types +++ b/tests/baselines/reference/emitClassDeclarationWithTypeArgumentInES6.types @@ -16,7 +16,7 @@ class B { >T : T >this.B = a : T >this.B : T ->this : B +>this : this >B : T >a : T @@ -26,7 +26,7 @@ class B { return this.x; >this.x : T ->this : B +>this : this >x : T } get BB(): T { @@ -35,7 +35,7 @@ class B { return this.B; >this.B : T ->this : B +>this : this >B : T } set BBWith(c: T) { @@ -46,7 +46,7 @@ class B { this.B = c; >this.B = c : T >this.B : T ->this : B +>this : this >B : T >c : T } diff --git a/tests/baselines/reference/enumBasics.symbols b/tests/baselines/reference/enumBasics.symbols index 32bbfc3124e..23f2a400741 100644 --- a/tests/baselines/reference/enumBasics.symbols +++ b/tests/baselines/reference/enumBasics.symbols @@ -76,8 +76,8 @@ enum E3 { X = 'foo'.length, Y = 4 + 3, Z = +'foo' >X : Symbol(E3.X, Decl(enumBasics.ts, 31, 9)) ->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >Y : Symbol(E3.Y, Decl(enumBasics.ts, 32, 21)) >Z : Symbol(E3.Z, Decl(enumBasics.ts, 32, 32)) } @@ -90,8 +90,8 @@ enum E4 { >X : Symbol(E4.X, Decl(enumBasics.ts, 36, 9)) >Y : Symbol(E4.Y, Decl(enumBasics.ts, 37, 10)) >Z : Symbol(E4.Z, Decl(enumBasics.ts, 37, 13)) ->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } // Enum with > 2 constant members with no initializer for first member, non zero initializer for second element diff --git a/tests/baselines/reference/enumConstantMembers.errors.txt b/tests/baselines/reference/enumConstantMembers.errors.txt deleted file mode 100644 index d425b7a6f4b..00000000000 --- a/tests/baselines/reference/enumConstantMembers.errors.txt +++ /dev/null @@ -1,28 +0,0 @@ -tests/cases/conformance/enums/enumConstantMembers.ts(12,5): error TS1061: Enum member must have initializer. -tests/cases/conformance/enums/enumConstantMembers.ts(18,5): error TS1066: Ambient enum elements can only have integer literal initializers. - - -==== tests/cases/conformance/enums/enumConstantMembers.ts (2 errors) ==== - // Constant members allow negatives, but not decimals. Also hex literals are allowed - enum E1 { - a = 1, - b - } - enum E2 { - a = - 1, - b - } - enum E3 { - a = 0.1, - b // Error because 0.1 is not a constant - ~ -!!! error TS1061: Enum member must have initializer. - } - - declare enum E4 { - a = 1, - b = -1, - c = 0.1 // Not a constant - ~ -!!! error TS1066: Ambient enum elements can only have integer literal initializers. - } \ No newline at end of file diff --git a/tests/baselines/reference/enumConstantMembers.symbols b/tests/baselines/reference/enumConstantMembers.symbols new file mode 100644 index 00000000000..6bf516cceef --- /dev/null +++ b/tests/baselines/reference/enumConstantMembers.symbols @@ -0,0 +1,42 @@ +=== tests/cases/conformance/enums/enumConstantMembers.ts === +// Constant members allow negatives, but not decimals. Also hex literals are allowed +enum E1 { +>E1 : Symbol(E1, Decl(enumConstantMembers.ts, 0, 0)) + + a = 1, +>a : Symbol(E1.a, Decl(enumConstantMembers.ts, 1, 9)) + + b +>b : Symbol(E1.b, Decl(enumConstantMembers.ts, 2, 10)) +} +enum E2 { +>E2 : Symbol(E2, Decl(enumConstantMembers.ts, 4, 1)) + + a = - 1, +>a : Symbol(E2.a, Decl(enumConstantMembers.ts, 5, 9)) + + b +>b : Symbol(E2.b, Decl(enumConstantMembers.ts, 6, 12)) +} +enum E3 { +>E3 : Symbol(E3, Decl(enumConstantMembers.ts, 8, 1)) + + a = 0.1, +>a : Symbol(E3.a, Decl(enumConstantMembers.ts, 9, 9)) + + b // Error because 0.1 is not a constant +>b : Symbol(E3.b, Decl(enumConstantMembers.ts, 10, 12)) +} + +declare enum E4 { +>E4 : Symbol(E4, Decl(enumConstantMembers.ts, 12, 1)) + + a = 1, +>a : Symbol(E4.a, Decl(enumConstantMembers.ts, 14, 17)) + + b = -1, +>b : Symbol(E4.b, Decl(enumConstantMembers.ts, 15, 10)) + + c = 0.1 // Not a constant +>c : Symbol(E4.c, Decl(enumConstantMembers.ts, 16, 11)) +} diff --git a/tests/baselines/reference/enumConstantMembers.types b/tests/baselines/reference/enumConstantMembers.types new file mode 100644 index 00000000000..c99b5eeb62f --- /dev/null +++ b/tests/baselines/reference/enumConstantMembers.types @@ -0,0 +1,50 @@ +=== tests/cases/conformance/enums/enumConstantMembers.ts === +// Constant members allow negatives, but not decimals. Also hex literals are allowed +enum E1 { +>E1 : E1 + + a = 1, +>a : E1 +>1 : number + + b +>b : E1 +} +enum E2 { +>E2 : E2 + + a = - 1, +>a : E2 +>- 1 : number +>1 : number + + b +>b : E2 +} +enum E3 { +>E3 : E3 + + a = 0.1, +>a : E3 +>0.1 : number + + b // Error because 0.1 is not a constant +>b : E3 +} + +declare enum E4 { +>E4 : E4 + + a = 1, +>a : E4 +>1 : number + + b = -1, +>b : E4 +>-1 : number +>1 : number + + c = 0.1 // Not a constant +>c : E4 +>0.1 : number +} diff --git a/tests/baselines/reference/enumIndexer.symbols b/tests/baselines/reference/enumIndexer.symbols index 3f65044c2ec..59191a73276 100644 --- a/tests/baselines/reference/enumIndexer.symbols +++ b/tests/baselines/reference/enumIndexer.symbols @@ -19,9 +19,9 @@ var enumValue = MyEnumType.foo; var x = _arr.map(o => MyEnumType[o.key] === enumValue); // these are not same type >x : Symbol(x, Decl(enumIndexer.ts, 5, 3)) ->_arr.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>_arr.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >_arr : Symbol(_arr, Decl(enumIndexer.ts, 3, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >o : Symbol(o, Decl(enumIndexer.ts, 5, 17)) >MyEnumType : Symbol(MyEnumType, Decl(enumIndexer.ts, 0, 0)) >o.key : Symbol(key, Decl(enumIndexer.ts, 3, 13)) diff --git a/tests/baselines/reference/enumInitializersWithExponents.errors.txt b/tests/baselines/reference/enumInitializersWithExponents.errors.txt deleted file mode 100644 index c4338cdf78b..00000000000 --- a/tests/baselines/reference/enumInitializersWithExponents.errors.txt +++ /dev/null @@ -1,18 +0,0 @@ -tests/cases/compiler/enumInitializersWithExponents.ts(5,5): error TS1066: Ambient enum elements can only have integer literal initializers. -tests/cases/compiler/enumInitializersWithExponents.ts(6,5): error TS1066: Ambient enum elements can only have integer literal initializers. - - -==== tests/cases/compiler/enumInitializersWithExponents.ts (2 errors) ==== - // Must be integer literals. - declare enum E { - a = 1e3, // ok - b = 1e25, // ok - c = 1e-3, // error - ~ -!!! error TS1066: Ambient enum elements can only have integer literal initializers. - d = 1e-9, // error - ~ -!!! error TS1066: Ambient enum elements can only have integer literal initializers. - e = 1e0, // ok - f = 1e+25 // ok - } \ No newline at end of file diff --git a/tests/baselines/reference/enumInitializersWithExponents.symbols b/tests/baselines/reference/enumInitializersWithExponents.symbols new file mode 100644 index 00000000000..13f7141a322 --- /dev/null +++ b/tests/baselines/reference/enumInitializersWithExponents.symbols @@ -0,0 +1,23 @@ +=== tests/cases/compiler/enumInitializersWithExponents.ts === +// Must be integer literals. +declare enum E { +>E : Symbol(E, Decl(enumInitializersWithExponents.ts, 0, 0)) + + a = 1e3, // ok +>a : Symbol(E.a, Decl(enumInitializersWithExponents.ts, 1, 16)) + + b = 1e25, // ok +>b : Symbol(E.b, Decl(enumInitializersWithExponents.ts, 2, 12)) + + c = 1e-3, // error +>c : Symbol(E.c, Decl(enumInitializersWithExponents.ts, 3, 13)) + + d = 1e-9, // error +>d : Symbol(E.d, Decl(enumInitializersWithExponents.ts, 4, 13)) + + e = 1e0, // ok +>e : Symbol(E.e, Decl(enumInitializersWithExponents.ts, 5, 13)) + + f = 1e+25 // ok +>f : Symbol(E.f, Decl(enumInitializersWithExponents.ts, 6, 12)) +} diff --git a/tests/baselines/reference/enumInitializersWithExponents.types b/tests/baselines/reference/enumInitializersWithExponents.types new file mode 100644 index 00000000000..8da208e5f87 --- /dev/null +++ b/tests/baselines/reference/enumInitializersWithExponents.types @@ -0,0 +1,29 @@ +=== tests/cases/compiler/enumInitializersWithExponents.ts === +// Must be integer literals. +declare enum E { +>E : E + + a = 1e3, // ok +>a : E +>1e3 : number + + b = 1e25, // ok +>b : E +>1e25 : number + + c = 1e-3, // error +>c : E +>1e-3 : number + + d = 1e-9, // error +>d : E +>1e-9 : number + + e = 1e0, // ok +>e : E +>1e0 : number + + f = 1e+25 // ok +>f : E +>1e+25 : number +} diff --git a/tests/baselines/reference/enumMerging.symbols b/tests/baselines/reference/enumMerging.symbols index 414dd839952..7b94cb49b29 100644 --- a/tests/baselines/reference/enumMerging.symbols +++ b/tests/baselines/reference/enumMerging.symbols @@ -71,14 +71,14 @@ module M2 { A = 'foo'.length, B = 'foo'.length, C = 'foo'.length >A : Symbol(EComp2.A, Decl(enumMerging.ts, 24, 24)) ->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >B : Symbol(EComp2.B, Decl(enumMerging.ts, 25, 25)) ->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >C : Symbol(EComp2.C, Decl(enumMerging.ts, 25, 43)) ->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } export enum EComp2 { @@ -86,14 +86,14 @@ module M2 { D = 'foo'.length, E = 'foo'.length, F = 'foo'.length >D : Symbol(EComp2.D, Decl(enumMerging.ts, 28, 24)) ->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >E : Symbol(EComp2.E, Decl(enumMerging.ts, 29, 25)) ->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >F : Symbol(EComp2.F, Decl(enumMerging.ts, 29, 43)) ->'foo'.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>'foo'.length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } var x = [EComp2.A, EComp2.B, EComp2.C, EComp2.D, EComp2.E, EComp2.F]; diff --git a/tests/baselines/reference/enumNumbering1.symbols b/tests/baselines/reference/enumNumbering1.symbols index 7722b5bad78..274798f6aad 100644 --- a/tests/baselines/reference/enumNumbering1.symbols +++ b/tests/baselines/reference/enumNumbering1.symbols @@ -10,12 +10,12 @@ enum Test { C = Math.floor(Math.random() * 1000), >C : Symbol(Test.C, Decl(enumNumbering1.ts, 2, 6)) ->Math.floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27)) ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>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, --, --)) D = 10, >D : Symbol(Test.D, Decl(enumNumbering1.ts, 3, 41)) diff --git a/tests/baselines/reference/enumWithoutInitializerAfterComputedMember.errors.txt b/tests/baselines/reference/enumWithoutInitializerAfterComputedMember.errors.txt deleted file mode 100644 index 876c04a0322..00000000000 --- a/tests/baselines/reference/enumWithoutInitializerAfterComputedMember.errors.txt +++ /dev/null @@ -1,11 +0,0 @@ -tests/cases/compiler/enumWithoutInitializerAfterComputedMember.ts(4,5): error TS1061: Enum member must have initializer. - - -==== tests/cases/compiler/enumWithoutInitializerAfterComputedMember.ts (1 errors) ==== - enum E { - a, - b = a, - c - ~ -!!! error TS1061: Enum member must have initializer. - } \ No newline at end of file diff --git a/tests/baselines/reference/enumWithoutInitializerAfterComputedMember.symbols b/tests/baselines/reference/enumWithoutInitializerAfterComputedMember.symbols new file mode 100644 index 00000000000..54449b29399 --- /dev/null +++ b/tests/baselines/reference/enumWithoutInitializerAfterComputedMember.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/enumWithoutInitializerAfterComputedMember.ts === +enum E { +>E : Symbol(E, Decl(enumWithoutInitializerAfterComputedMember.ts, 0, 0)) + + a, +>a : Symbol(E.a, Decl(enumWithoutInitializerAfterComputedMember.ts, 0, 8)) + + b = a, +>b : Symbol(E.b, Decl(enumWithoutInitializerAfterComputedMember.ts, 1, 6)) +>a : Symbol(E.a, Decl(enumWithoutInitializerAfterComputedMember.ts, 0, 8)) + + c +>c : Symbol(E.c, Decl(enumWithoutInitializerAfterComputedMember.ts, 2, 10)) +} diff --git a/tests/baselines/reference/enumWithoutInitializerAfterComputedMember.types b/tests/baselines/reference/enumWithoutInitializerAfterComputedMember.types new file mode 100644 index 00000000000..0ece7b76f1e --- /dev/null +++ b/tests/baselines/reference/enumWithoutInitializerAfterComputedMember.types @@ -0,0 +1,14 @@ +=== tests/cases/compiler/enumWithoutInitializerAfterComputedMember.ts === +enum E { +>E : E + + a, +>a : E + + b = a, +>b : E +>a : E + + c +>c : E +} diff --git a/tests/baselines/reference/es3defaultAliasIsQuoted.symbols b/tests/baselines/reference/es3defaultAliasIsQuoted.symbols index 907f1d71b89..3472258373e 100644 --- a/tests/baselines/reference/es3defaultAliasIsQuoted.symbols +++ b/tests/baselines/reference/es3defaultAliasIsQuoted.symbols @@ -13,7 +13,7 @@ export default function assert(value: boolean) { if (!value) throw new Error("Assertion failed!"); >value : Symbol(value, Decl(es3defaultAliasQuoted_file0.ts, 5, 31)) ->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } === tests/cases/compiler/es3defaultAliasQuoted_file1.ts === diff --git a/tests/baselines/reference/es5-umd2.js b/tests/baselines/reference/es5-umd2.js index 4267e7a3331..9b79f5f17b7 100644 --- a/tests/baselines/reference/es5-umd2.js +++ b/tests/baselines/reference/es5-umd2.js @@ -15,14 +15,14 @@ export class A //// [es5-umd2.js] -(function (deps, factory) { +(function (factory) { if (typeof module === 'object' && typeof module.exports === 'object') { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === 'function' && define.amd) { - define(deps, factory); + define(["require", "exports"], factory); } -})(["require", "exports"], function (require, exports) { +})(function (require, exports) { var A = (function () { function A() { } diff --git a/tests/baselines/reference/es5-umd3.js b/tests/baselines/reference/es5-umd3.js index 92ac306698a..042316b710e 100644 --- a/tests/baselines/reference/es5-umd3.js +++ b/tests/baselines/reference/es5-umd3.js @@ -15,14 +15,14 @@ export default class A //// [es5-umd3.js] -(function (deps, factory) { +(function (factory) { if (typeof module === 'object' && typeof module.exports === 'object') { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === 'function' && define.amd) { - define(deps, factory); + define(["require", "exports"], factory); } -})(["require", "exports"], function (require, exports) { +})(function (require, exports) { var A = (function () { function A() { } diff --git a/tests/baselines/reference/es5-umd4.js b/tests/baselines/reference/es5-umd4.js index 058ad545f42..81dcf440cb8 100644 --- a/tests/baselines/reference/es5-umd4.js +++ b/tests/baselines/reference/es5-umd4.js @@ -17,14 +17,14 @@ export = A; //// [es5-umd4.js] -(function (deps, factory) { +(function (factory) { if (typeof module === 'object' && typeof module.exports === 'object') { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === 'function' && define.amd) { - define(deps, factory); + define(["require", "exports"], factory); } -})(["require", "exports"], function (require, exports) { +})(function (require, exports) { var A = (function () { function A() { } diff --git a/tests/baselines/reference/es5andes6module.errors.txt b/tests/baselines/reference/es5andes6module.errors.txt new file mode 100644 index 00000000000..d5a672b9486 --- /dev/null +++ b/tests/baselines/reference/es5andes6module.errors.txt @@ -0,0 +1,19 @@ +error TS1204: Cannot compile modules into 'es6' when targeting 'ES5' or lower. + + +!!! error TS1204: Cannot compile modules into 'es6' when targeting 'ES5' or lower. +==== tests/cases/compiler/es5andes6module.ts (0 errors) ==== + + export default class A + { + constructor () + { + + } + + public B() + { + return 42; + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/es5andes6module.js b/tests/baselines/reference/es5andes6module.js new file mode 100644 index 00000000000..0d489357852 --- /dev/null +++ b/tests/baselines/reference/es5andes6module.js @@ -0,0 +1,26 @@ +//// [es5andes6module.ts] + +export default class A +{ + constructor () + { + + } + + public B() + { + return 42; + } +} + + +//// [es5andes6module.js] +var A = (function () { + function A() { + } + A.prototype.B = function () { + return 42; + }; + return A; +})(); +exports.default = A; diff --git a/tests/baselines/reference/es6-amd.errors.txt b/tests/baselines/reference/es6-amd.errors.txt deleted file mode 100644 index b4a6442458b..00000000000 --- a/tests/baselines/reference/es6-amd.errors.txt +++ /dev/null @@ -1,18 +0,0 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. - - -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/es6-amd.ts (0 errors) ==== - - class A - { - constructor () - { - - } - - public B() - { - return 42; - } - } \ No newline at end of file diff --git a/tests/baselines/reference/es6-amd.symbols b/tests/baselines/reference/es6-amd.symbols new file mode 100644 index 00000000000..ad5cf38e7cd --- /dev/null +++ b/tests/baselines/reference/es6-amd.symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/es6-amd.ts === + +class A +>A : Symbol(A, Decl(es6-amd.ts, 0, 0)) +{ + constructor () + { + + } + + public B() +>B : Symbol(B, Decl(es6-amd.ts, 6, 5)) + { + return 42; + } +} diff --git a/tests/baselines/reference/es6-amd.types b/tests/baselines/reference/es6-amd.types new file mode 100644 index 00000000000..7a6fb6e32f5 --- /dev/null +++ b/tests/baselines/reference/es6-amd.types @@ -0,0 +1,17 @@ +=== tests/cases/compiler/es6-amd.ts === + +class A +>A : A +{ + constructor () + { + + } + + public B() +>B : () => number + { + return 42; +>42 : number + } +} diff --git a/tests/baselines/reference/es6-declaration-amd.errors.txt b/tests/baselines/reference/es6-declaration-amd.errors.txt deleted file mode 100644 index fe5a254dd54..00000000000 --- a/tests/baselines/reference/es6-declaration-amd.errors.txt +++ /dev/null @@ -1,18 +0,0 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. - - -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/es6-declaration-amd.ts (0 errors) ==== - - class A - { - constructor () - { - - } - - public B() - { - return 42; - } - } \ No newline at end of file diff --git a/tests/baselines/reference/es6-declaration-amd.symbols b/tests/baselines/reference/es6-declaration-amd.symbols new file mode 100644 index 00000000000..f1a728396cc --- /dev/null +++ b/tests/baselines/reference/es6-declaration-amd.symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/es6-declaration-amd.ts === + +class A +>A : Symbol(A, Decl(es6-declaration-amd.ts, 0, 0)) +{ + constructor () + { + + } + + public B() +>B : Symbol(B, Decl(es6-declaration-amd.ts, 6, 5)) + { + return 42; + } +} diff --git a/tests/baselines/reference/es6-declaration-amd.types b/tests/baselines/reference/es6-declaration-amd.types new file mode 100644 index 00000000000..a46d22c82c5 --- /dev/null +++ b/tests/baselines/reference/es6-declaration-amd.types @@ -0,0 +1,17 @@ +=== tests/cases/compiler/es6-declaration-amd.ts === + +class A +>A : A +{ + constructor () + { + + } + + public B() +>B : () => number + { + return 42; +>42 : number + } +} diff --git a/tests/baselines/reference/es6-sourcemap-amd.errors.txt b/tests/baselines/reference/es6-sourcemap-amd.errors.txt deleted file mode 100644 index 8ffa16aaa23..00000000000 --- a/tests/baselines/reference/es6-sourcemap-amd.errors.txt +++ /dev/null @@ -1,18 +0,0 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. - - -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/es6-sourcemap-amd.ts (0 errors) ==== - - class A - { - constructor () - { - - } - - public B() - { - return 42; - } - } \ No newline at end of file diff --git a/tests/baselines/reference/es6-sourcemap-amd.symbols b/tests/baselines/reference/es6-sourcemap-amd.symbols new file mode 100644 index 00000000000..13be6367ba0 --- /dev/null +++ b/tests/baselines/reference/es6-sourcemap-amd.symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/es6-sourcemap-amd.ts === + +class A +>A : Symbol(A, Decl(es6-sourcemap-amd.ts, 0, 0)) +{ + constructor () + { + + } + + public B() +>B : Symbol(B, Decl(es6-sourcemap-amd.ts, 6, 5)) + { + return 42; + } +} diff --git a/tests/baselines/reference/es6-sourcemap-amd.types b/tests/baselines/reference/es6-sourcemap-amd.types new file mode 100644 index 00000000000..580a688afab --- /dev/null +++ b/tests/baselines/reference/es6-sourcemap-amd.types @@ -0,0 +1,17 @@ +=== tests/cases/compiler/es6-sourcemap-amd.ts === + +class A +>A : A +{ + constructor () + { + + } + + public B() +>B : () => number + { + return 42; +>42 : number + } +} diff --git a/tests/baselines/reference/es6-umd.errors.txt b/tests/baselines/reference/es6-umd.errors.txt deleted file mode 100644 index 72a58585073..00000000000 --- a/tests/baselines/reference/es6-umd.errors.txt +++ /dev/null @@ -1,18 +0,0 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. - - -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/es6-umd.ts (0 errors) ==== - - class A - { - constructor () - { - - } - - public B() - { - return 42; - } - } \ No newline at end of file diff --git a/tests/baselines/reference/es6-umd.symbols b/tests/baselines/reference/es6-umd.symbols new file mode 100644 index 00000000000..f7c57215ea6 --- /dev/null +++ b/tests/baselines/reference/es6-umd.symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/es6-umd.ts === + +class A +>A : Symbol(A, Decl(es6-umd.ts, 0, 0)) +{ + constructor () + { + + } + + public B() +>B : Symbol(B, Decl(es6-umd.ts, 6, 5)) + { + return 42; + } +} diff --git a/tests/baselines/reference/es6-umd.types b/tests/baselines/reference/es6-umd.types new file mode 100644 index 00000000000..f43c491e003 --- /dev/null +++ b/tests/baselines/reference/es6-umd.types @@ -0,0 +1,17 @@ +=== tests/cases/compiler/es6-umd.ts === + +class A +>A : A +{ + constructor () + { + + } + + public B() +>B : () => number + { + return 42; +>42 : number + } +} diff --git a/tests/baselines/reference/es6-umd2.errors.txt b/tests/baselines/reference/es6-umd2.errors.txt deleted file mode 100644 index 00becfb105f..00000000000 --- a/tests/baselines/reference/es6-umd2.errors.txt +++ /dev/null @@ -1,18 +0,0 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. - - -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/es6-umd2.ts (0 errors) ==== - - export class A - { - constructor () - { - - } - - public B() - { - return 42; - } - } \ No newline at end of file diff --git a/tests/baselines/reference/es6-umd2.js b/tests/baselines/reference/es6-umd2.js index 416932d89bc..b87027b21b1 100644 --- a/tests/baselines/reference/es6-umd2.js +++ b/tests/baselines/reference/es6-umd2.js @@ -14,10 +14,20 @@ export class A } //// [es6-umd2.js] -export class A { - constructor() { +(function (factory) { + if (typeof module === 'object' && typeof module.exports === 'object') { + var v = factory(require, exports); if (v !== undefined) module.exports = v; } - B() { - return 42; + else if (typeof define === 'function' && define.amd) { + define(["require", "exports"], factory); } -} +})(function (require, exports) { + class A { + constructor() { + } + B() { + return 42; + } + } + exports.A = A; +}); diff --git a/tests/baselines/reference/es6-umd2.symbols b/tests/baselines/reference/es6-umd2.symbols new file mode 100644 index 00000000000..88acf127279 --- /dev/null +++ b/tests/baselines/reference/es6-umd2.symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/es6-umd2.ts === + +export class A +>A : Symbol(A, Decl(es6-umd2.ts, 0, 0)) +{ + constructor () + { + + } + + public B() +>B : Symbol(B, Decl(es6-umd2.ts, 6, 5)) + { + return 42; + } +} diff --git a/tests/baselines/reference/es6-umd2.types b/tests/baselines/reference/es6-umd2.types new file mode 100644 index 00000000000..eb66523c6ec --- /dev/null +++ b/tests/baselines/reference/es6-umd2.types @@ -0,0 +1,17 @@ +=== tests/cases/compiler/es6-umd2.ts === + +export class A +>A : A +{ + constructor () + { + + } + + public B() +>B : () => number + { + return 42; +>42 : number + } +} diff --git a/tests/baselines/reference/es6ClassTest3.types b/tests/baselines/reference/es6ClassTest3.types index d73007f211b..208d8cdf4d9 100644 --- a/tests/baselines/reference/es6ClassTest3.types +++ b/tests/baselines/reference/es6ClassTest3.types @@ -24,14 +24,14 @@ module M { this.x = 1; >this.x = 1 : number >this.x : number ->this : Visibility +>this : this >x : number >1 : number this.y = 2; >this.y = 2 : number >this.y : number ->this : Visibility +>this : this >y : number >2 : number } diff --git a/tests/baselines/reference/es6ClassTest8.types b/tests/baselines/reference/es6ClassTest8.types index 622f81f1d10..b12d65e595f 100644 --- a/tests/baselines/reference/es6ClassTest8.types +++ b/tests/baselines/reference/es6ClassTest8.types @@ -119,7 +119,7 @@ class Camera { this.forward = Vector.norm(Vector.minus(lookAt,this.pos)); >this.forward = Vector.norm(Vector.minus(lookAt,this.pos)) : Vector >this.forward : Vector ->this : Camera +>this : this >forward : Vector >Vector.norm(Vector.minus(lookAt,this.pos)) : Vector >Vector.norm : (v: Vector) => Vector @@ -131,13 +131,13 @@ class Camera { >minus : (v1: Vector, v2: Vector) => Vector >lookAt : Vector >this.pos : Vector ->this : Camera +>this : this >pos : Vector this.right = Vector.times(down, Vector.norm(Vector.cross(this.forward, down))); >this.right = Vector.times(down, Vector.norm(Vector.cross(this.forward, down))) : Vector >this.right : Vector ->this : Camera +>this : this >right : Vector >Vector.times(down, Vector.norm(Vector.cross(this.forward, down))) : Vector >Vector.times : (v1: Vector, v2: Vector) => Vector @@ -153,14 +153,14 @@ class Camera { >Vector : typeof Vector >cross : (v1: Vector, v2: Vector) => Vector >this.forward : Vector ->this : Camera +>this : this >forward : Vector >down : Vector this.up = Vector.times(down, Vector.norm(Vector.cross(this.forward, this.right))); >this.up = Vector.times(down, Vector.norm(Vector.cross(this.forward, this.right))) : Vector >this.up : Vector ->this : Camera +>this : this >up : Vector >Vector.times(down, Vector.norm(Vector.cross(this.forward, this.right))) : Vector >Vector.times : (v1: Vector, v2: Vector) => Vector @@ -176,10 +176,10 @@ class Camera { >Vector : typeof Vector >cross : (v1: Vector, v2: Vector) => Vector >this.forward : Vector ->this : Camera +>this : this >forward : Vector >this.right : Vector ->this : Camera +>this : this >right : Vector } } diff --git a/tests/baselines/reference/es6ExportAssignment.errors.txt b/tests/baselines/reference/es6ExportAssignment.errors.txt index 1db7d04e05e..970d2e184dc 100644 --- a/tests/baselines/reference/es6ExportAssignment.errors.txt +++ b/tests/baselines/reference/es6ExportAssignment.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/es6ExportAssignment.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead. +tests/cases/compiler/es6ExportAssignment.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 6 modules. Consider using 'export default' or another module format instead. ==== tests/cases/compiler/es6ExportAssignment.ts (1 errors) ==== @@ -6,4 +6,4 @@ tests/cases/compiler/es6ExportAssignment.ts(3,1): error TS1203: Export assignmen var a = 10; export = a; ~~~~~~~~~~~ -!!! error TS1203: Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead. \ No newline at end of file +!!! error TS1203: Export assignment cannot be used when targeting ECMAScript 6 modules. Consider using 'export default' or another module format instead. \ No newline at end of file diff --git a/tests/baselines/reference/es6ExportAssignment2.errors.txt b/tests/baselines/reference/es6ExportAssignment2.errors.txt index d5e1dfebd9d..248491f98c3 100644 --- a/tests/baselines/reference/es6ExportAssignment2.errors.txt +++ b/tests/baselines/reference/es6ExportAssignment2.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/a.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead. +tests/cases/compiler/a.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 6 modules. Consider using 'export default' or another module format instead. ==== tests/cases/compiler/a.ts (1 errors) ==== @@ -6,7 +6,7 @@ tests/cases/compiler/a.ts(3,1): error TS1203: Export assignment cannot be used w var a = 10; export = a; // Error: export = not allowed in ES6 ~~~~~~~~~~~ -!!! error TS1203: Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead. +!!! error TS1203: Export assignment cannot be used when targeting ECMAScript 6 modules. Consider using 'export default' or another module format instead. ==== tests/cases/compiler/b.ts (0 errors) ==== import * as a from "a"; diff --git a/tests/baselines/reference/es6ExportEquals.errors.txt b/tests/baselines/reference/es6ExportEquals.errors.txt index 174c72341f6..e8db09456d3 100644 --- a/tests/baselines/reference/es6ExportEquals.errors.txt +++ b/tests/baselines/reference/es6ExportEquals.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/es6ExportEquals.ts(4,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead. +tests/cases/compiler/es6ExportEquals.ts(4,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 6 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. @@ -8,7 +8,7 @@ tests/cases/compiler/es6ExportEquals.ts(4,1): error TS2309: An export assignment export = f; ~~~~~~~~~~~ -!!! error TS1203: Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead. +!!! error TS1203: Export assignment cannot be used when targeting ECMAScript 6 modules. Consider using 'export default' or another module format instead. ~~~~~~~~~~~ !!! error TS2309: An export assignment cannot be used in a module with other exported elements. \ No newline at end of file diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.errors.txt b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.errors.txt deleted file mode 100644 index b0b7465477b..00000000000 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.errors.txt +++ /dev/null @@ -1,25 +0,0 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. - - -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport_0.ts (0 errors) ==== - - export var a = 10; - export var x = a; - export var m = a; - export default {}; - -==== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport_1.ts (0 errors) ==== - import defaultBinding1, { } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; - import defaultBinding2, { a } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; - var x1: number = a; - import defaultBinding3, { a as b } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; - var x1: number = b; - import defaultBinding4, { x, a as y } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; - var x1: number = x; - var x1: number = y; - import defaultBinding5, { x as z, } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; - var x1: number = z; - import defaultBinding6, { m, } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; - var x1: number = m; - \ No newline at end of file diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js index 554fecf9116..d6be494a8d1 100644 --- a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.js @@ -23,22 +23,22 @@ var x1: number = m; //// [es6ImportDefaultBindingFollowedWithNamedImport_0.js] -export var a = 10; -export var x = a; -export var m = a; -export default {}; +exports.a = 10; +exports.x = exports.a; +exports.m = exports.a; +exports.default = {}; //// [es6ImportDefaultBindingFollowedWithNamedImport_1.js] -import { a } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; -var x1 = a; -import { a as b } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; -var x1 = b; -import { x, a as y } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; -var x1 = x; -var x1 = y; -import { x as z } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; -var x1 = z; -import { m } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; -var x1 = m; +var es6ImportDefaultBindingFollowedWithNamedImport_0_1 = require("./es6ImportDefaultBindingFollowedWithNamedImport_0"); +var x1 = es6ImportDefaultBindingFollowedWithNamedImport_0_1.a; +var es6ImportDefaultBindingFollowedWithNamedImport_0_2 = require("./es6ImportDefaultBindingFollowedWithNamedImport_0"); +var x1 = es6ImportDefaultBindingFollowedWithNamedImport_0_2.a; +var es6ImportDefaultBindingFollowedWithNamedImport_0_3 = require("./es6ImportDefaultBindingFollowedWithNamedImport_0"); +var x1 = es6ImportDefaultBindingFollowedWithNamedImport_0_3.x; +var x1 = es6ImportDefaultBindingFollowedWithNamedImport_0_3.a; +var es6ImportDefaultBindingFollowedWithNamedImport_0_4 = require("./es6ImportDefaultBindingFollowedWithNamedImport_0"); +var x1 = es6ImportDefaultBindingFollowedWithNamedImport_0_4.x; +var es6ImportDefaultBindingFollowedWithNamedImport_0_5 = require("./es6ImportDefaultBindingFollowedWithNamedImport_0"); +var x1 = es6ImportDefaultBindingFollowedWithNamedImport_0_5.m; //// [es6ImportDefaultBindingFollowedWithNamedImport_0.d.ts] diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.symbols b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.symbols new file mode 100644 index 00000000000..5da138f6c62 --- /dev/null +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.symbols @@ -0,0 +1,67 @@ +=== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport_0.ts === + +export var a = 10; +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 1, 10)) + +export var x = a; +>x : Symbol(x, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 2, 10)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 1, 10)) + +export var m = a; +>m : Symbol(m, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 3, 10)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_0.ts, 1, 10)) + +export default {}; + +=== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport_1.ts === +import defaultBinding1, { } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; +>defaultBinding1 : Symbol(defaultBinding1, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 0, 6)) + +import defaultBinding2, { a } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; +>defaultBinding2 : Symbol(defaultBinding2, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 1, 6)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 1, 25)) + +var x1: number = a; +>x1 : Symbol(x1, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 2, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 4, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 6, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 7, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 9, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 11, 3)) +>a : Symbol(a, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 1, 25)) + +import defaultBinding3, { a as b } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; +>defaultBinding3 : Symbol(defaultBinding3, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 3, 6)) +>a : Symbol(b, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 3, 25)) +>b : Symbol(b, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 3, 25)) + +var x1: number = b; +>x1 : Symbol(x1, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 2, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 4, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 6, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 7, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 9, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 11, 3)) +>b : Symbol(b, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 3, 25)) + +import defaultBinding4, { x, a as y } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; +>defaultBinding4 : Symbol(defaultBinding4, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 5, 6)) +>x : Symbol(x, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 5, 25)) +>a : Symbol(y, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 5, 28)) +>y : Symbol(y, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 5, 28)) + +var x1: number = x; +>x1 : Symbol(x1, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 2, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 4, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 6, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 7, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 9, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 11, 3)) +>x : Symbol(x, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 5, 25)) + +var x1: number = y; +>x1 : Symbol(x1, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 2, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 4, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 6, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 7, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 9, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 11, 3)) +>y : Symbol(y, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 5, 28)) + +import defaultBinding5, { x as z, } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; +>defaultBinding5 : Symbol(defaultBinding5, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 8, 6)) +>x : Symbol(z, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 8, 25)) +>z : Symbol(z, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 8, 25)) + +var x1: number = z; +>x1 : Symbol(x1, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 2, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 4, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 6, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 7, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 9, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 11, 3)) +>z : Symbol(z, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 8, 25)) + +import defaultBinding6, { m, } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; +>defaultBinding6 : Symbol(defaultBinding6, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 10, 6)) +>m : Symbol(m, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 10, 25)) + +var x1: number = m; +>x1 : Symbol(x1, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 2, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 4, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 6, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 7, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 9, 3), Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 11, 3)) +>m : Symbol(m, Decl(es6ImportDefaultBindingFollowedWithNamedImport_1.ts, 10, 25)) + diff --git a/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.types b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.types new file mode 100644 index 00000000000..fe0137403a9 --- /dev/null +++ b/tests/baselines/reference/es6ImportDefaultBindingFollowedWithNamedImport.types @@ -0,0 +1,69 @@ +=== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport_0.ts === + +export var a = 10; +>a : number +>10 : number + +export var x = a; +>x : number +>a : number + +export var m = a; +>m : number +>a : number + +export default {}; +>{} : {} + +=== tests/cases/compiler/es6ImportDefaultBindingFollowedWithNamedImport_1.ts === +import defaultBinding1, { } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; +>defaultBinding1 : {} + +import defaultBinding2, { a } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; +>defaultBinding2 : {} +>a : number + +var x1: number = a; +>x1 : number +>a : number + +import defaultBinding3, { a as b } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; +>defaultBinding3 : {} +>a : number +>b : number + +var x1: number = b; +>x1 : number +>b : number + +import defaultBinding4, { x, a as y } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; +>defaultBinding4 : {} +>x : number +>a : number +>y : number + +var x1: number = x; +>x1 : number +>x : number + +var x1: number = y; +>x1 : number +>y : number + +import defaultBinding5, { x as z, } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; +>defaultBinding5 : {} +>x : number +>z : number + +var x1: number = z; +>x1 : number +>z : number + +import defaultBinding6, { m, } from "./es6ImportDefaultBindingFollowedWithNamedImport_0"; +>defaultBinding6 : {} +>m : number + +var x1: number = m; +>x1 : number +>m : number + diff --git a/tests/baselines/reference/es6ImportEqualsDeclaration.errors.txt b/tests/baselines/reference/es6ImportEqualsDeclaration.errors.txt index d3351ee97b2..7de5d7f0e3d 100644 --- a/tests/baselines/reference/es6ImportEqualsDeclaration.errors.txt +++ b/tests/baselines/reference/es6ImportEqualsDeclaration.errors.txt @@ -1,15 +1,15 @@ -tests/cases/compiler/client.ts(1,1): error TS1202: Import assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'import * as ns from "mod"', 'import {a} from "mod"' or 'import d from "mod"' instead. -tests/cases/compiler/server.ts(3,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead. +tests/cases/compiler/client.ts(1,1): error TS1202: Import assignment cannot be used when targeting ECMAScript 6 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 6 modules. Consider using 'export default' or another module format instead. ==== tests/cases/compiler/client.ts (1 errors) ==== import a = require("server"); ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS1202: Import assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'import * as ns from "mod"', 'import {a} from "mod"' or 'import d from "mod"' instead. +!!! error TS1202: Import assignment cannot be used when targeting ECMAScript 6 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; ~~~~~~~~~~~ -!!! error TS1203: Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead. +!!! error TS1203: Export assignment cannot be used when targeting ECMAScript 6 modules. Consider using 'export default' or another module format instead. \ No newline at end of file diff --git a/tests/baselines/reference/es6ImportNameSpaceImport.errors.txt b/tests/baselines/reference/es6ImportNameSpaceImport.errors.txt deleted file mode 100644 index 67616662ca8..00000000000 --- a/tests/baselines/reference/es6ImportNameSpaceImport.errors.txt +++ /dev/null @@ -1,13 +0,0 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. - - -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/es6ImportNameSpaceImport_0.ts (0 errors) ==== - - export var a = 10; - -==== tests/cases/compiler/es6ImportNameSpaceImport_1.ts (0 errors) ==== - import * as nameSpaceBinding from "./es6ImportNameSpaceImport_0"; - var x = nameSpaceBinding.a; - import * as nameSpaceBinding2 from "./es6ImportNameSpaceImport_0"; // elide this - \ No newline at end of file diff --git a/tests/baselines/reference/es6ImportNameSpaceImport.js b/tests/baselines/reference/es6ImportNameSpaceImport.js index 7498b8ee9e8..32bdd78b329 100644 --- a/tests/baselines/reference/es6ImportNameSpaceImport.js +++ b/tests/baselines/reference/es6ImportNameSpaceImport.js @@ -11,9 +11,9 @@ import * as nameSpaceBinding2 from "./es6ImportNameSpaceImport_0"; // elide this //// [es6ImportNameSpaceImport_0.js] -export var a = 10; +exports.a = 10; //// [es6ImportNameSpaceImport_1.js] -import * as nameSpaceBinding from "./es6ImportNameSpaceImport_0"; +var nameSpaceBinding = require("./es6ImportNameSpaceImport_0"); var x = nameSpaceBinding.a; diff --git a/tests/baselines/reference/es6ImportNameSpaceImport.symbols b/tests/baselines/reference/es6ImportNameSpaceImport.symbols new file mode 100644 index 00000000000..add2b792d49 --- /dev/null +++ b/tests/baselines/reference/es6ImportNameSpaceImport.symbols @@ -0,0 +1,18 @@ +=== tests/cases/compiler/es6ImportNameSpaceImport_0.ts === + +export var a = 10; +>a : Symbol(a, Decl(es6ImportNameSpaceImport_0.ts, 1, 10)) + +=== tests/cases/compiler/es6ImportNameSpaceImport_1.ts === +import * as nameSpaceBinding from "./es6ImportNameSpaceImport_0"; +>nameSpaceBinding : Symbol(nameSpaceBinding, Decl(es6ImportNameSpaceImport_1.ts, 0, 6)) + +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 : Symbol(nameSpaceBinding, Decl(es6ImportNameSpaceImport_1.ts, 0, 6)) +>a : Symbol(nameSpaceBinding.a, Decl(es6ImportNameSpaceImport_0.ts, 1, 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 new file mode 100644 index 00000000000..56ee0c4d87a --- /dev/null +++ b/tests/baselines/reference/es6ImportNameSpaceImport.types @@ -0,0 +1,19 @@ +=== tests/cases/compiler/es6ImportNameSpaceImport_0.ts === + +export var a = 10; +>a : number +>10 : number + +=== tests/cases/compiler/es6ImportNameSpaceImport_1.ts === +import * as nameSpaceBinding from "./es6ImportNameSpaceImport_0"; +>nameSpaceBinding : typeof nameSpaceBinding + +var x = nameSpaceBinding.a; +>x : number +>nameSpaceBinding.a : number +>nameSpaceBinding : typeof nameSpaceBinding +>a : number + +import * as nameSpaceBinding2 from "./es6ImportNameSpaceImport_0"; // elide this +>nameSpaceBinding2 : typeof nameSpaceBinding + diff --git a/tests/baselines/reference/es6ImportNamedImport.errors.txt b/tests/baselines/reference/es6ImportNamedImport.errors.txt deleted file mode 100644 index efcda1f5368..00000000000 --- a/tests/baselines/reference/es6ImportNamedImport.errors.txt +++ /dev/null @@ -1,44 +0,0 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. - - -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/es6ImportNamedImport_0.ts (0 errors) ==== - - export var a = 10; - export var x = a; - export var m = a; - export var a1 = 10; - export var x1 = 10; - export var z1 = 10; - export var z2 = 10; - export var aaaa = 10; - -==== tests/cases/compiler/es6ImportNamedImport_1.ts (0 errors) ==== - import { } from "./es6ImportNamedImport_0"; - import { a } from "./es6ImportNamedImport_0"; - var xxxx = a; - import { a as b } from "./es6ImportNamedImport_0"; - var xxxx = b; - import { x, a as y } from "./es6ImportNamedImport_0"; - var xxxx = x; - var xxxx = y; - import { x as z, } from "./es6ImportNamedImport_0"; - var xxxx = z; - import { m, } from "./es6ImportNamedImport_0"; - var xxxx = m; - import { a1, x1 } from "./es6ImportNamedImport_0"; - var xxxx = a1; - var xxxx = x1; - import { a1 as a11, x1 as x11 } from "./es6ImportNamedImport_0"; - var xxxx = a11; - var xxxx = x11; - import { z1 } from "./es6ImportNamedImport_0"; - var z111 = z1; - import { z2 as z3 } from "./es6ImportNamedImport_0"; - var z2 = z3; // z2 shouldn't give redeclare error - - // These are elided - import { aaaa } from "./es6ImportNamedImport_0"; - // These are elided - import { aaaa as bbbb } from "./es6ImportNamedImport_0"; - \ No newline at end of file diff --git a/tests/baselines/reference/es6ImportNamedImport.js b/tests/baselines/reference/es6ImportNamedImport.js index 6edb6ccb7cd..3ed7a6adeb0 100644 --- a/tests/baselines/reference/es6ImportNamedImport.js +++ b/tests/baselines/reference/es6ImportNamedImport.js @@ -42,36 +42,36 @@ import { aaaa as bbbb } from "./es6ImportNamedImport_0"; //// [es6ImportNamedImport_0.js] -export var a = 10; -export var x = a; -export var m = a; -export var a1 = 10; -export var x1 = 10; -export var z1 = 10; -export var z2 = 10; -export var aaaa = 10; +exports.a = 10; +exports.x = exports.a; +exports.m = exports.a; +exports.a1 = 10; +exports.x1 = 10; +exports.z1 = 10; +exports.z2 = 10; +exports.aaaa = 10; //// [es6ImportNamedImport_1.js] -import { a } from "./es6ImportNamedImport_0"; -var xxxx = a; -import { a as b } from "./es6ImportNamedImport_0"; -var xxxx = b; -import { x, a as y } from "./es6ImportNamedImport_0"; -var xxxx = x; -var xxxx = y; -import { x as z } from "./es6ImportNamedImport_0"; -var xxxx = z; -import { m } from "./es6ImportNamedImport_0"; -var xxxx = m; -import { a1, x1 } from "./es6ImportNamedImport_0"; -var xxxx = a1; -var xxxx = x1; -import { a1 as a11, x1 as x11 } from "./es6ImportNamedImport_0"; -var xxxx = a11; -var xxxx = x11; -import { z1 } from "./es6ImportNamedImport_0"; -var z111 = z1; -import { z2 as z3 } from "./es6ImportNamedImport_0"; -var z2 = z3; // z2 shouldn't give redeclare error +var es6ImportNamedImport_0_1 = require("./es6ImportNamedImport_0"); +var xxxx = es6ImportNamedImport_0_1.a; +var es6ImportNamedImport_0_2 = require("./es6ImportNamedImport_0"); +var xxxx = es6ImportNamedImport_0_2.a; +var es6ImportNamedImport_0_3 = require("./es6ImportNamedImport_0"); +var xxxx = es6ImportNamedImport_0_3.x; +var xxxx = es6ImportNamedImport_0_3.a; +var es6ImportNamedImport_0_4 = require("./es6ImportNamedImport_0"); +var xxxx = es6ImportNamedImport_0_4.x; +var es6ImportNamedImport_0_5 = require("./es6ImportNamedImport_0"); +var xxxx = es6ImportNamedImport_0_5.m; +var es6ImportNamedImport_0_6 = require("./es6ImportNamedImport_0"); +var xxxx = es6ImportNamedImport_0_6.a1; +var xxxx = es6ImportNamedImport_0_6.x1; +var es6ImportNamedImport_0_7 = require("./es6ImportNamedImport_0"); +var xxxx = es6ImportNamedImport_0_7.a1; +var xxxx = es6ImportNamedImport_0_7.x1; +var es6ImportNamedImport_0_8 = require("./es6ImportNamedImport_0"); +var z111 = es6ImportNamedImport_0_8.z1; +var es6ImportNamedImport_0_9 = require("./es6ImportNamedImport_0"); +var z2 = es6ImportNamedImport_0_9.z2; // z2 shouldn't give redeclare error //// [es6ImportNamedImport_0.d.ts] diff --git a/tests/baselines/reference/es6ImportNamedImport.symbols b/tests/baselines/reference/es6ImportNamedImport.symbols new file mode 100644 index 00000000000..0d30db6113f --- /dev/null +++ b/tests/baselines/reference/es6ImportNamedImport.symbols @@ -0,0 +1,123 @@ +=== tests/cases/compiler/es6ImportNamedImport_0.ts === + +export var a = 10; +>a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 1, 10)) + +export var x = a; +>x : Symbol(x, Decl(es6ImportNamedImport_0.ts, 2, 10)) +>a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 1, 10)) + +export var m = a; +>m : Symbol(m, Decl(es6ImportNamedImport_0.ts, 3, 10)) +>a : Symbol(a, Decl(es6ImportNamedImport_0.ts, 1, 10)) + +export var a1 = 10; +>a1 : Symbol(a1, Decl(es6ImportNamedImport_0.ts, 4, 10)) + +export var x1 = 10; +>x1 : Symbol(x1, Decl(es6ImportNamedImport_0.ts, 5, 10)) + +export var z1 = 10; +>z1 : Symbol(z1, Decl(es6ImportNamedImport_0.ts, 6, 10)) + +export var z2 = 10; +>z2 : Symbol(z2, Decl(es6ImportNamedImport_0.ts, 7, 10)) + +export var aaaa = 10; +>aaaa : Symbol(aaaa, Decl(es6ImportNamedImport_0.ts, 8, 10)) + +=== tests/cases/compiler/es6ImportNamedImport_1.ts === +import { } from "./es6ImportNamedImport_0"; +import { a } from "./es6ImportNamedImport_0"; +>a : Symbol(a, Decl(es6ImportNamedImport_1.ts, 1, 8)) + +var xxxx = a; +>xxxx : Symbol(xxxx, Decl(es6ImportNamedImport_1.ts, 2, 3), Decl(es6ImportNamedImport_1.ts, 4, 3), Decl(es6ImportNamedImport_1.ts, 6, 3), Decl(es6ImportNamedImport_1.ts, 7, 3), Decl(es6ImportNamedImport_1.ts, 9, 3), Decl(es6ImportNamedImport_1.ts, 11, 3), Decl(es6ImportNamedImport_1.ts, 13, 3), Decl(es6ImportNamedImport_1.ts, 14, 3), Decl(es6ImportNamedImport_1.ts, 16, 3), Decl(es6ImportNamedImport_1.ts, 17, 3)) +>a : Symbol(a, Decl(es6ImportNamedImport_1.ts, 1, 8)) + +import { a as b } from "./es6ImportNamedImport_0"; +>a : Symbol(b, Decl(es6ImportNamedImport_1.ts, 3, 8)) +>b : Symbol(b, Decl(es6ImportNamedImport_1.ts, 3, 8)) + +var xxxx = b; +>xxxx : Symbol(xxxx, Decl(es6ImportNamedImport_1.ts, 2, 3), Decl(es6ImportNamedImport_1.ts, 4, 3), Decl(es6ImportNamedImport_1.ts, 6, 3), Decl(es6ImportNamedImport_1.ts, 7, 3), Decl(es6ImportNamedImport_1.ts, 9, 3), Decl(es6ImportNamedImport_1.ts, 11, 3), Decl(es6ImportNamedImport_1.ts, 13, 3), Decl(es6ImportNamedImport_1.ts, 14, 3), Decl(es6ImportNamedImport_1.ts, 16, 3), Decl(es6ImportNamedImport_1.ts, 17, 3)) +>b : Symbol(b, Decl(es6ImportNamedImport_1.ts, 3, 8)) + +import { x, a as y } from "./es6ImportNamedImport_0"; +>x : Symbol(x, Decl(es6ImportNamedImport_1.ts, 5, 8)) +>a : Symbol(y, Decl(es6ImportNamedImport_1.ts, 5, 11)) +>y : Symbol(y, Decl(es6ImportNamedImport_1.ts, 5, 11)) + +var xxxx = x; +>xxxx : Symbol(xxxx, Decl(es6ImportNamedImport_1.ts, 2, 3), Decl(es6ImportNamedImport_1.ts, 4, 3), Decl(es6ImportNamedImport_1.ts, 6, 3), Decl(es6ImportNamedImport_1.ts, 7, 3), Decl(es6ImportNamedImport_1.ts, 9, 3), Decl(es6ImportNamedImport_1.ts, 11, 3), Decl(es6ImportNamedImport_1.ts, 13, 3), Decl(es6ImportNamedImport_1.ts, 14, 3), Decl(es6ImportNamedImport_1.ts, 16, 3), Decl(es6ImportNamedImport_1.ts, 17, 3)) +>x : Symbol(x, Decl(es6ImportNamedImport_1.ts, 5, 8)) + +var xxxx = y; +>xxxx : Symbol(xxxx, Decl(es6ImportNamedImport_1.ts, 2, 3), Decl(es6ImportNamedImport_1.ts, 4, 3), Decl(es6ImportNamedImport_1.ts, 6, 3), Decl(es6ImportNamedImport_1.ts, 7, 3), Decl(es6ImportNamedImport_1.ts, 9, 3), Decl(es6ImportNamedImport_1.ts, 11, 3), Decl(es6ImportNamedImport_1.ts, 13, 3), Decl(es6ImportNamedImport_1.ts, 14, 3), Decl(es6ImportNamedImport_1.ts, 16, 3), Decl(es6ImportNamedImport_1.ts, 17, 3)) +>y : Symbol(y, Decl(es6ImportNamedImport_1.ts, 5, 11)) + +import { x as z, } from "./es6ImportNamedImport_0"; +>x : Symbol(z, Decl(es6ImportNamedImport_1.ts, 8, 8)) +>z : Symbol(z, Decl(es6ImportNamedImport_1.ts, 8, 8)) + +var xxxx = z; +>xxxx : Symbol(xxxx, Decl(es6ImportNamedImport_1.ts, 2, 3), Decl(es6ImportNamedImport_1.ts, 4, 3), Decl(es6ImportNamedImport_1.ts, 6, 3), Decl(es6ImportNamedImport_1.ts, 7, 3), Decl(es6ImportNamedImport_1.ts, 9, 3), Decl(es6ImportNamedImport_1.ts, 11, 3), Decl(es6ImportNamedImport_1.ts, 13, 3), Decl(es6ImportNamedImport_1.ts, 14, 3), Decl(es6ImportNamedImport_1.ts, 16, 3), Decl(es6ImportNamedImport_1.ts, 17, 3)) +>z : Symbol(z, Decl(es6ImportNamedImport_1.ts, 8, 8)) + +import { m, } from "./es6ImportNamedImport_0"; +>m : Symbol(m, Decl(es6ImportNamedImport_1.ts, 10, 8)) + +var xxxx = m; +>xxxx : Symbol(xxxx, Decl(es6ImportNamedImport_1.ts, 2, 3), Decl(es6ImportNamedImport_1.ts, 4, 3), Decl(es6ImportNamedImport_1.ts, 6, 3), Decl(es6ImportNamedImport_1.ts, 7, 3), Decl(es6ImportNamedImport_1.ts, 9, 3), Decl(es6ImportNamedImport_1.ts, 11, 3), Decl(es6ImportNamedImport_1.ts, 13, 3), Decl(es6ImportNamedImport_1.ts, 14, 3), Decl(es6ImportNamedImport_1.ts, 16, 3), Decl(es6ImportNamedImport_1.ts, 17, 3)) +>m : Symbol(m, Decl(es6ImportNamedImport_1.ts, 10, 8)) + +import { a1, x1 } from "./es6ImportNamedImport_0"; +>a1 : Symbol(a1, Decl(es6ImportNamedImport_1.ts, 12, 8)) +>x1 : Symbol(x1, Decl(es6ImportNamedImport_1.ts, 12, 12)) + +var xxxx = a1; +>xxxx : Symbol(xxxx, Decl(es6ImportNamedImport_1.ts, 2, 3), Decl(es6ImportNamedImport_1.ts, 4, 3), Decl(es6ImportNamedImport_1.ts, 6, 3), Decl(es6ImportNamedImport_1.ts, 7, 3), Decl(es6ImportNamedImport_1.ts, 9, 3), Decl(es6ImportNamedImport_1.ts, 11, 3), Decl(es6ImportNamedImport_1.ts, 13, 3), Decl(es6ImportNamedImport_1.ts, 14, 3), Decl(es6ImportNamedImport_1.ts, 16, 3), Decl(es6ImportNamedImport_1.ts, 17, 3)) +>a1 : Symbol(a1, Decl(es6ImportNamedImport_1.ts, 12, 8)) + +var xxxx = x1; +>xxxx : Symbol(xxxx, Decl(es6ImportNamedImport_1.ts, 2, 3), Decl(es6ImportNamedImport_1.ts, 4, 3), Decl(es6ImportNamedImport_1.ts, 6, 3), Decl(es6ImportNamedImport_1.ts, 7, 3), Decl(es6ImportNamedImport_1.ts, 9, 3), Decl(es6ImportNamedImport_1.ts, 11, 3), Decl(es6ImportNamedImport_1.ts, 13, 3), Decl(es6ImportNamedImport_1.ts, 14, 3), Decl(es6ImportNamedImport_1.ts, 16, 3), Decl(es6ImportNamedImport_1.ts, 17, 3)) +>x1 : Symbol(x1, Decl(es6ImportNamedImport_1.ts, 12, 12)) + +import { a1 as a11, x1 as x11 } from "./es6ImportNamedImport_0"; +>a1 : Symbol(a11, Decl(es6ImportNamedImport_1.ts, 15, 8)) +>a11 : Symbol(a11, Decl(es6ImportNamedImport_1.ts, 15, 8)) +>x1 : Symbol(x11, Decl(es6ImportNamedImport_1.ts, 15, 19)) +>x11 : Symbol(x11, Decl(es6ImportNamedImport_1.ts, 15, 19)) + +var xxxx = a11; +>xxxx : Symbol(xxxx, Decl(es6ImportNamedImport_1.ts, 2, 3), Decl(es6ImportNamedImport_1.ts, 4, 3), Decl(es6ImportNamedImport_1.ts, 6, 3), Decl(es6ImportNamedImport_1.ts, 7, 3), Decl(es6ImportNamedImport_1.ts, 9, 3), Decl(es6ImportNamedImport_1.ts, 11, 3), Decl(es6ImportNamedImport_1.ts, 13, 3), Decl(es6ImportNamedImport_1.ts, 14, 3), Decl(es6ImportNamedImport_1.ts, 16, 3), Decl(es6ImportNamedImport_1.ts, 17, 3)) +>a11 : Symbol(a11, Decl(es6ImportNamedImport_1.ts, 15, 8)) + +var xxxx = x11; +>xxxx : Symbol(xxxx, Decl(es6ImportNamedImport_1.ts, 2, 3), Decl(es6ImportNamedImport_1.ts, 4, 3), Decl(es6ImportNamedImport_1.ts, 6, 3), Decl(es6ImportNamedImport_1.ts, 7, 3), Decl(es6ImportNamedImport_1.ts, 9, 3), Decl(es6ImportNamedImport_1.ts, 11, 3), Decl(es6ImportNamedImport_1.ts, 13, 3), Decl(es6ImportNamedImport_1.ts, 14, 3), Decl(es6ImportNamedImport_1.ts, 16, 3), Decl(es6ImportNamedImport_1.ts, 17, 3)) +>x11 : Symbol(x11, Decl(es6ImportNamedImport_1.ts, 15, 19)) + +import { z1 } from "./es6ImportNamedImport_0"; +>z1 : Symbol(z1, Decl(es6ImportNamedImport_1.ts, 18, 8)) + +var z111 = z1; +>z111 : Symbol(z111, Decl(es6ImportNamedImport_1.ts, 19, 3)) +>z1 : Symbol(z1, Decl(es6ImportNamedImport_1.ts, 18, 8)) + +import { z2 as z3 } from "./es6ImportNamedImport_0"; +>z2 : Symbol(z3, Decl(es6ImportNamedImport_1.ts, 20, 8)) +>z3 : Symbol(z3, Decl(es6ImportNamedImport_1.ts, 20, 8)) + +var z2 = z3; // z2 shouldn't give redeclare error +>z2 : Symbol(z2, Decl(es6ImportNamedImport_1.ts, 21, 3)) +>z3 : Symbol(z3, Decl(es6ImportNamedImport_1.ts, 20, 8)) + +// These are elided +import { aaaa } from "./es6ImportNamedImport_0"; +>aaaa : Symbol(aaaa, Decl(es6ImportNamedImport_1.ts, 24, 8)) + +// These are elided +import { aaaa as bbbb } from "./es6ImportNamedImport_0"; +>aaaa : Symbol(bbbb, Decl(es6ImportNamedImport_1.ts, 26, 8)) +>bbbb : Symbol(bbbb, Decl(es6ImportNamedImport_1.ts, 26, 8)) + diff --git a/tests/baselines/reference/es6ImportNamedImport.types b/tests/baselines/reference/es6ImportNamedImport.types new file mode 100644 index 00000000000..bd7c43d7031 --- /dev/null +++ b/tests/baselines/reference/es6ImportNamedImport.types @@ -0,0 +1,129 @@ +=== tests/cases/compiler/es6ImportNamedImport_0.ts === + +export var a = 10; +>a : number +>10 : number + +export var x = a; +>x : number +>a : number + +export var m = a; +>m : number +>a : number + +export var a1 = 10; +>a1 : number +>10 : number + +export var x1 = 10; +>x1 : number +>10 : number + +export var z1 = 10; +>z1 : number +>10 : number + +export var z2 = 10; +>z2 : number +>10 : number + +export var aaaa = 10; +>aaaa : number +>10 : number + +=== tests/cases/compiler/es6ImportNamedImport_1.ts === +import { } from "./es6ImportNamedImport_0"; +import { a } from "./es6ImportNamedImport_0"; +>a : number + +var xxxx = a; +>xxxx : number +>a : number + +import { a as b } from "./es6ImportNamedImport_0"; +>a : number +>b : number + +var xxxx = b; +>xxxx : number +>b : number + +import { x, a as y } from "./es6ImportNamedImport_0"; +>x : number +>a : number +>y : number + +var xxxx = x; +>xxxx : number +>x : number + +var xxxx = y; +>xxxx : number +>y : number + +import { x as z, } from "./es6ImportNamedImport_0"; +>x : number +>z : number + +var xxxx = z; +>xxxx : number +>z : number + +import { m, } from "./es6ImportNamedImport_0"; +>m : number + +var xxxx = m; +>xxxx : number +>m : number + +import { a1, x1 } from "./es6ImportNamedImport_0"; +>a1 : number +>x1 : number + +var xxxx = a1; +>xxxx : number +>a1 : number + +var xxxx = x1; +>xxxx : number +>x1 : number + +import { a1 as a11, x1 as x11 } from "./es6ImportNamedImport_0"; +>a1 : number +>a11 : number +>x1 : number +>x11 : number + +var xxxx = a11; +>xxxx : number +>a11 : number + +var xxxx = x11; +>xxxx : number +>x11 : number + +import { z1 } from "./es6ImportNamedImport_0"; +>z1 : number + +var z111 = z1; +>z111 : number +>z1 : number + +import { z2 as z3 } from "./es6ImportNamedImport_0"; +>z2 : number +>z3 : number + +var z2 = z3; // z2 shouldn't give redeclare error +>z2 : number +>z3 : number + +// These are elided +import { aaaa } from "./es6ImportNamedImport_0"; +>aaaa : number + +// These are elided +import { aaaa as bbbb } from "./es6ImportNamedImport_0"; +>aaaa : number +>bbbb : number + diff --git a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.errors.txt b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.errors.txt deleted file mode 100644 index fec4d182158..00000000000 --- a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.errors.txt +++ /dev/null @@ -1,14 +0,0 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -tests/cases/compiler/es6ImportNamedImportInExportAssignment_1.ts(2,1): error TS1203: Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead. - - -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/es6ImportNamedImportInExportAssignment_0.ts (0 errors) ==== - - export var a = 10; - -==== tests/cases/compiler/es6ImportNamedImportInExportAssignment_1.ts (1 errors) ==== - import { a } from "./es6ImportNamedImportInExportAssignment_0"; - export = a; - ~~~~~~~~~~~ -!!! error TS1203: Export assignment cannot be used when targeting ECMAScript 6 or higher. Consider using 'export default' instead. \ No newline at end of file diff --git a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.js b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.js index 44ac0d188b3..5bdbd89df07 100644 --- a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.js +++ b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.js @@ -9,9 +9,10 @@ import { a } from "./es6ImportNamedImportInExportAssignment_0"; export = a; //// [es6ImportNamedImportInExportAssignment_0.js] -export var a = 10; +exports.a = 10; //// [es6ImportNamedImportInExportAssignment_1.js] -import { a } from "./es6ImportNamedImportInExportAssignment_0"; +var es6ImportNamedImportInExportAssignment_0_1 = require("./es6ImportNamedImportInExportAssignment_0"); +module.exports = es6ImportNamedImportInExportAssignment_0_1.a; //// [es6ImportNamedImportInExportAssignment_0.d.ts] diff --git a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.symbols b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.symbols new file mode 100644 index 00000000000..03ca0740f08 --- /dev/null +++ b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.symbols @@ -0,0 +1,12 @@ +=== tests/cases/compiler/es6ImportNamedImportInExportAssignment_0.ts === + +export var a = 10; +>a : Symbol(a, Decl(es6ImportNamedImportInExportAssignment_0.ts, 1, 10)) + +=== tests/cases/compiler/es6ImportNamedImportInExportAssignment_1.ts === +import { a } from "./es6ImportNamedImportInExportAssignment_0"; +>a : Symbol(a, Decl(es6ImportNamedImportInExportAssignment_1.ts, 0, 8)) + +export = a; +>a : Symbol(a, Decl(es6ImportNamedImportInExportAssignment_1.ts, 0, 8)) + diff --git a/tests/baselines/reference/es6ImportNamedImportInExportAssignment.types b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.types new file mode 100644 index 00000000000..09023b6dd80 --- /dev/null +++ b/tests/baselines/reference/es6ImportNamedImportInExportAssignment.types @@ -0,0 +1,13 @@ +=== tests/cases/compiler/es6ImportNamedImportInExportAssignment_0.ts === + +export var a = 10; +>a : number +>10 : number + +=== tests/cases/compiler/es6ImportNamedImportInExportAssignment_1.ts === +import { a } from "./es6ImportNamedImportInExportAssignment_0"; +>a : number + +export = a; +>a : number + diff --git a/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.errors.txt b/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.errors.txt deleted file mode 100644 index 9592a9f899e..00000000000 --- a/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.errors.txt +++ /dev/null @@ -1,16 +0,0 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. - - -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/es6ModuleWithModuleGenTargetAmd.ts (0 errors) ==== - export class A - { - constructor () - { - } - - public B() - { - return 42; - } - } \ No newline at end of file diff --git a/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.js b/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.js index 8757bd1c88f..dec8de1e36e 100644 --- a/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.js +++ b/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.js @@ -12,10 +12,13 @@ export class A } //// [es6ModuleWithModuleGenTargetAmd.js] -export class A { - constructor() { +define(["require", "exports"], function (require, exports) { + class A { + constructor() { + } + B() { + return 42; + } } - B() { - return 42; - } -} + exports.A = A; +}); diff --git a/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.symbols b/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.symbols new file mode 100644 index 00000000000..24367cc28ad --- /dev/null +++ b/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/es6ModuleWithModuleGenTargetAmd.ts === +export class A +>A : Symbol(A, Decl(es6ModuleWithModuleGenTargetAmd.ts, 0, 0)) +{ + constructor () + { + } + + public B() +>B : Symbol(B, Decl(es6ModuleWithModuleGenTargetAmd.ts, 4, 5)) + { + return 42; + } +} diff --git a/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.types b/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.types new file mode 100644 index 00000000000..067ceb005e8 --- /dev/null +++ b/tests/baselines/reference/es6ModuleWithModuleGenTargetAmd.types @@ -0,0 +1,15 @@ +=== tests/cases/compiler/es6ModuleWithModuleGenTargetAmd.ts === +export class A +>A : A +{ + constructor () + { + } + + public B() +>B : () => number + { + return 42; +>42 : number + } +} diff --git a/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.errors.txt b/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.errors.txt deleted file mode 100644 index b7401040099..00000000000 --- a/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.errors.txt +++ /dev/null @@ -1,16 +0,0 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. - - -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/es6ModuleWithModuleGenTargetCommonjs.ts (0 errors) ==== - export class A - { - constructor () - { - } - - public B() - { - return 42; - } - } \ No newline at end of file diff --git a/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.js b/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.js index 2df98e20826..36e66cb5721 100644 --- a/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.js +++ b/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.js @@ -12,10 +12,11 @@ export class A } //// [es6ModuleWithModuleGenTargetCommonjs.js] -export class A { +class A { constructor() { } B() { return 42; } } +exports.A = A; diff --git a/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.symbols b/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.symbols new file mode 100644 index 00000000000..4a84c00c48f --- /dev/null +++ b/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/es6ModuleWithModuleGenTargetCommonjs.ts === +export class A +>A : Symbol(A, Decl(es6ModuleWithModuleGenTargetCommonjs.ts, 0, 0)) +{ + constructor () + { + } + + public B() +>B : Symbol(B, Decl(es6ModuleWithModuleGenTargetCommonjs.ts, 4, 5)) + { + return 42; + } +} diff --git a/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.types b/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.types new file mode 100644 index 00000000000..58f0f89f955 --- /dev/null +++ b/tests/baselines/reference/es6ModuleWithModuleGenTargetCommonjs.types @@ -0,0 +1,15 @@ +=== tests/cases/compiler/es6ModuleWithModuleGenTargetCommonjs.ts === +export class A +>A : A +{ + constructor () + { + } + + public B() +>B : () => number + { + return 42; +>42 : number + } +} diff --git a/tests/baselines/reference/es6modulekind.js b/tests/baselines/reference/es6modulekind.js new file mode 100644 index 00000000000..96b315389d1 --- /dev/null +++ b/tests/baselines/reference/es6modulekind.js @@ -0,0 +1,23 @@ +//// [es6modulekind.ts] + +export default class A +{ + constructor () + { + + } + + public B() + { + return 42; + } +} + +//// [es6modulekind.js] +export default class A { + constructor() { + } + B() { + return 42; + } +} diff --git a/tests/baselines/reference/es6modulekind.symbols b/tests/baselines/reference/es6modulekind.symbols new file mode 100644 index 00000000000..0b5eeb2a6fb --- /dev/null +++ b/tests/baselines/reference/es6modulekind.symbols @@ -0,0 +1,16 @@ +=== tests/cases/compiler/es6modulekind.ts === + +export default class A +>A : Symbol(A, Decl(es6modulekind.ts, 0, 0)) +{ + constructor () + { + + } + + public B() +>B : Symbol(B, Decl(es6modulekind.ts, 6, 5)) + { + return 42; + } +} diff --git a/tests/baselines/reference/es6modulekind.types b/tests/baselines/reference/es6modulekind.types new file mode 100644 index 00000000000..d7fde0c7d44 --- /dev/null +++ b/tests/baselines/reference/es6modulekind.types @@ -0,0 +1,17 @@ +=== tests/cases/compiler/es6modulekind.ts === + +export default class A +>A : A +{ + constructor () + { + + } + + public B() +>B : () => number + { + return 42; +>42 : number + } +} diff --git a/tests/baselines/reference/everyTypeAssignableToAny.symbols b/tests/baselines/reference/everyTypeAssignableToAny.symbols index 275a58641d2..be88c481ece 100644 --- a/tests/baselines/reference/everyTypeAssignableToAny.symbols +++ b/tests/baselines/reference/everyTypeAssignableToAny.symbols @@ -41,7 +41,7 @@ var d: boolean; var e: Date; >e : Symbol(e, Decl(everyTypeAssignableToAny.ts, 17, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var f: any; >f : Symbol(f, Decl(everyTypeAssignableToAny.ts, 18, 3)) @@ -51,7 +51,7 @@ var g: void; var h: Object; >h : Symbol(h, Decl(everyTypeAssignableToAny.ts, 20, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var i: {}; >i : Symbol(i, Decl(everyTypeAssignableToAny.ts, 21, 3)) @@ -61,7 +61,7 @@ var j: () => {}; var k: Function; >k : Symbol(k, Decl(everyTypeAssignableToAny.ts, 23, 3)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var l: (x: number) => string; >l : Symbol(l, Decl(everyTypeAssignableToAny.ts, 24, 3)) @@ -83,11 +83,11 @@ var o: (x: T) => T; var p: Number; >p : Symbol(p, Decl(everyTypeAssignableToAny.ts, 28, 3)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var q: String; >q : Symbol(q, Decl(everyTypeAssignableToAny.ts, 29, 3)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) a = b; >a : Symbol(a, Decl(everyTypeAssignableToAny.ts, 0, 3)) @@ -166,7 +166,7 @@ function foo(x: T, y: U, z: V) { >T : Symbol(T, Decl(everyTypeAssignableToAny.ts, 50, 13)) >U : Symbol(U, Decl(everyTypeAssignableToAny.ts, 50, 15)) >V : Symbol(V, Decl(everyTypeAssignableToAny.ts, 50, 32)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(everyTypeAssignableToAny.ts, 50, 49)) >T : Symbol(T, Decl(everyTypeAssignableToAny.ts, 50, 13)) >y : Symbol(y, Decl(everyTypeAssignableToAny.ts, 50, 54)) diff --git a/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols b/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols index 489903750f5..e76b3784e8a 100644 --- a/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols +++ b/tests/baselines/reference/everyTypeWithAnnotationAndInitializer.symbols @@ -51,9 +51,9 @@ module M { export function F2(x: number): string { return x.toString(); } >F2 : Symbol(F2, Decl(everyTypeWithAnnotationAndInitializer.ts, 19, 5)) >x : Symbol(x, Decl(everyTypeWithAnnotationAndInitializer.ts, 21, 23)) ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(everyTypeWithAnnotationAndInitializer.ts, 21, 23)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } var aNumber: number = 9.9; @@ -64,13 +64,13 @@ var aString: string = 'this is a string'; var aDate: Date = new Date(12); >aDate : Symbol(aDate, Decl(everyTypeWithAnnotationAndInitializer.ts, 26, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var anObject: Object = new Object(); >anObject : Symbol(anObject, Decl(everyTypeWithAnnotationAndInitializer.ts, 27, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var anAny: any = null; >anAny : Symbol(anAny, Decl(everyTypeWithAnnotationAndInitializer.ts, 29, 3)) diff --git a/tests/baselines/reference/everyTypeWithInitializer.symbols b/tests/baselines/reference/everyTypeWithInitializer.symbols index 0a22252164b..078f2e305d1 100644 --- a/tests/baselines/reference/everyTypeWithInitializer.symbols +++ b/tests/baselines/reference/everyTypeWithInitializer.symbols @@ -51,9 +51,9 @@ module M { export function F2(x: number): string { return x.toString(); } >F2 : Symbol(F2, Decl(everyTypeWithInitializer.ts, 19, 5)) >x : Symbol(x, Decl(everyTypeWithInitializer.ts, 21, 23)) ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(everyTypeWithInitializer.ts, 21, 23)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } var aNumber = 9.9; @@ -64,11 +64,11 @@ var aString = 'this is a string'; var aDate = new Date(12); >aDate : Symbol(aDate, Decl(everyTypeWithInitializer.ts, 26, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var anObject = new Object(); >anObject : Symbol(anObject, Decl(everyTypeWithInitializer.ts, 27, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var anAny = null; >anAny : Symbol(anAny, Decl(everyTypeWithInitializer.ts, 29, 3)) diff --git a/tests/baselines/reference/exportAssignValueAndType.symbols b/tests/baselines/reference/exportAssignValueAndType.symbols index b6d5b5b3bb6..faca2c6ffd0 100644 --- a/tests/baselines/reference/exportAssignValueAndType.symbols +++ b/tests/baselines/reference/exportAssignValueAndType.symbols @@ -16,7 +16,7 @@ interface server { startTime: Date; >startTime : Symbol(startTime, Decl(exportAssignValueAndType.ts, 5, 20)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var x = 5; @@ -24,7 +24,7 @@ var x = 5; var server = new Date(); >server : Symbol(server, Decl(exportAssignValueAndType.ts, 2, 1), Decl(exportAssignValueAndType.ts, 10, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) export = server; >server : Symbol(server, Decl(exportAssignValueAndType.ts, 2, 1), Decl(exportAssignValueAndType.ts, 10, 3)) diff --git a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols index 2c286e8518d..e79faf36f35 100644 --- a/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols +++ b/tests/baselines/reference/exportAssignedTypeAsTypeAnnotation.symbols @@ -13,7 +13,7 @@ interface x { >x : Symbol(x, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 0, 0)) (): Date; ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo: string; >foo : Symbol(foo, Decl(exportAssignedTypeAsTypeAnnotation_0.ts, 2, 13)) diff --git a/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols b/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols index bcbf5eb1f60..e2ddbdb419c 100644 --- a/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols +++ b/tests/baselines/reference/exportAssignmentWithoutIdentifier1.symbols @@ -5,9 +5,9 @@ function Greeter() { //... } Greeter.prototype.greet = function () { ->Greeter.prototype : Symbol(Function.prototype, Decl(lib.d.ts, 249, 48)) +>Greeter.prototype : Symbol(Function.prototype, Decl(lib.d.ts, --, --)) >Greeter : Symbol(Greeter, Decl(exportAssignmentWithoutIdentifier1.ts, 0, 0)) ->prototype : Symbol(Function.prototype, Decl(lib.d.ts, 249, 48)) +>prototype : Symbol(Function.prototype, Decl(lib.d.ts, --, --)) //... } diff --git a/tests/baselines/reference/exportDeclareClass1.errors.txt b/tests/baselines/reference/exportDeclareClass1.errors.txt index 247b0511ed1..8ff0cb52b5f 100644 --- a/tests/baselines/reference/exportDeclareClass1.errors.txt +++ b/tests/baselines/reference/exportDeclareClass1.errors.txt @@ -1,15 +1,15 @@ -tests/cases/compiler/exportDeclareClass1.ts(2,21): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/exportDeclareClass1.ts(3,31): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/exportDeclareClass1.ts(2,21): error TS1183: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/exportDeclareClass1.ts(3,31): error TS1183: An implementation cannot be declared in ambient contexts. ==== tests/cases/compiler/exportDeclareClass1.ts (2 errors) ==== export declare class eaC { static tF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static tsF(param:any) { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. }; export declare class eaC2 { diff --git a/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.js b/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.js new file mode 100644 index 00000000000..3acb89b8696 --- /dev/null +++ b/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.js @@ -0,0 +1,9 @@ +//// [exportDefaultClassWithStaticPropertyAssignmentsInES6.ts] +export default class { + static z: string = "Foo"; +} + +//// [exportDefaultClassWithStaticPropertyAssignmentsInES6.js] +export default class default_1 { +} +default_1.z = "Foo"; diff --git a/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.symbols b/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.symbols new file mode 100644 index 00000000000..6d08eb93d92 --- /dev/null +++ b/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.symbols @@ -0,0 +1,5 @@ +=== tests/cases/conformance/es6/classDeclaration/exportDefaultClassWithStaticPropertyAssignmentsInES6.ts === +export default class { + static z: string = "Foo"; +>z : Symbol(default.z, Decl(exportDefaultClassWithStaticPropertyAssignmentsInES6.ts, 0, 22)) +} diff --git a/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.types b/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.types new file mode 100644 index 00000000000..657e0301f83 --- /dev/null +++ b/tests/baselines/reference/exportDefaultClassWithStaticPropertyAssignmentsInES6.types @@ -0,0 +1,6 @@ +=== tests/cases/conformance/es6/classDeclaration/exportDefaultClassWithStaticPropertyAssignmentsInES6.ts === +export default class { + static z: string = "Foo"; +>z : string +>"Foo" : string +} diff --git a/tests/baselines/reference/exportEqualNamespaces.symbols b/tests/baselines/reference/exportEqualNamespaces.symbols index f6f0767d414..1773883c68b 100644 --- a/tests/baselines/reference/exportEqualNamespaces.symbols +++ b/tests/baselines/reference/exportEqualNamespaces.symbols @@ -4,7 +4,7 @@ declare module server { interface Server extends Object { } >Server : Symbol(Server, Decl(exportEqualNamespaces.ts, 0, 23)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface server { @@ -16,7 +16,7 @@ interface server { startTime: Date; >startTime : Symbol(startTime, Decl(exportEqualNamespaces.ts, 5, 22)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var x = 5; @@ -24,7 +24,7 @@ var x = 5; var server = new Date(); >server : Symbol(server, Decl(exportEqualNamespaces.ts, 0, 0), Decl(exportEqualNamespaces.ts, 2, 1), Decl(exportEqualNamespaces.ts, 10, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) export = server; >server : Symbol(server, Decl(exportEqualNamespaces.ts, 0, 0), Decl(exportEqualNamespaces.ts, 2, 1), Decl(exportEqualNamespaces.ts, 10, 3)) diff --git a/tests/baselines/reference/exportNonInitializedVariablesUMD.js b/tests/baselines/reference/exportNonInitializedVariablesUMD.js index 1e8b3ce4446..4b1e671669c 100644 --- a/tests/baselines/reference/exportNonInitializedVariablesUMD.js +++ b/tests/baselines/reference/exportNonInitializedVariablesUMD.js @@ -35,14 +35,14 @@ export let h1: D = new D; //// [exportNonInitializedVariablesUMD.js] -(function (deps, factory) { +(function (factory) { if (typeof module === 'object' && typeof module.exports === 'object') { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === 'function' && define.amd) { - define(deps, factory); + define(["require", "exports"], factory); } -})(["require", "exports"], function (require, exports) { +})(function (require, exports) { var ; let; var ; diff --git a/tests/baselines/reference/exportedBlockScopedDeclarations.errors.txt b/tests/baselines/reference/exportedBlockScopedDeclarations.errors.txt new file mode 100644 index 00000000000..06d832c86e1 --- /dev/null +++ b/tests/baselines/reference/exportedBlockScopedDeclarations.errors.txt @@ -0,0 +1,44 @@ +tests/cases/compiler/exportedBlockScopedDeclarations.ts(1,13): error TS2448: Block-scoped variable 'foo' used before its declaration. +tests/cases/compiler/exportedBlockScopedDeclarations.ts(2,20): error TS2448: Block-scoped variable 'bar' used before its declaration. +tests/cases/compiler/exportedBlockScopedDeclarations.ts(4,15): error TS2448: Block-scoped variable 'bar' used before its declaration. +tests/cases/compiler/exportedBlockScopedDeclarations.ts(7,22): error TS2448: Block-scoped variable 'bar' used before its declaration. +tests/cases/compiler/exportedBlockScopedDeclarations.ts(10,12): error TS2448: Block-scoped variable 'foo1' used before its declaration. +tests/cases/compiler/exportedBlockScopedDeclarations.ts(11,19): error TS2448: Block-scoped variable 'bar1' used before its declaration. +tests/cases/compiler/exportedBlockScopedDeclarations.ts(13,14): error TS2448: Block-scoped variable 'bar1' used before its declaration. +tests/cases/compiler/exportedBlockScopedDeclarations.ts(16,21): error TS2448: Block-scoped variable 'bar1' used before its declaration. + + +==== tests/cases/compiler/exportedBlockScopedDeclarations.ts (8 errors) ==== + const foo = foo; // compile error + ~~~ +!!! error TS2448: Block-scoped variable 'foo' used before its declaration. + export const bar = bar; // should be compile error + ~~~ +!!! error TS2448: Block-scoped variable 'bar' used before its declaration. + function f() { + const bar = bar; // compile error + ~~~ +!!! error TS2448: Block-scoped variable 'bar' used before its declaration. + } + namespace NS { + export const bar = bar; // should be compile error + ~~~ +!!! error TS2448: Block-scoped variable 'bar' used before its declaration. + } + + let foo1 = foo1; // compile error + ~~~~ +!!! error TS2448: Block-scoped variable 'foo1' used before its declaration. + export let bar1 = bar1; // should be compile error + ~~~~ +!!! error TS2448: Block-scoped variable 'bar1' used before its declaration. + function f1() { + let bar1 = bar1; // compile error + ~~~~ +!!! error TS2448: Block-scoped variable 'bar1' used before its declaration. + } + namespace NS1 { + export let bar1 = bar1; // should be compile error + ~~~~ +!!! error TS2448: Block-scoped variable 'bar1' used before its declaration. + } \ No newline at end of file diff --git a/tests/baselines/reference/exportedBlockScopedDeclarations.js b/tests/baselines/reference/exportedBlockScopedDeclarations.js new file mode 100644 index 00000000000..81399ddafb5 --- /dev/null +++ b/tests/baselines/reference/exportedBlockScopedDeclarations.js @@ -0,0 +1,40 @@ +//// [exportedBlockScopedDeclarations.ts] +const foo = foo; // compile error +export const bar = bar; // should be compile error +function f() { + const bar = bar; // compile error +} +namespace NS { + export const bar = bar; // should be compile error +} + +let foo1 = foo1; // compile error +export let bar1 = bar1; // should be compile error +function f1() { + let bar1 = bar1; // compile error +} +namespace NS1 { + export let bar1 = bar1; // should be compile error +} + +//// [exportedBlockScopedDeclarations.js] +define(["require", "exports"], function (require, exports) { + var foo = foo; // compile error + exports.bar = exports.bar; // should be compile error + function f() { + var bar = bar; // compile error + } + var NS; + (function (NS) { + NS.bar = NS.bar; // should be compile error + })(NS || (NS = {})); + var foo1 = foo1; // compile error + exports.bar1 = exports.bar1; // should be compile error + function f1() { + var bar1 = bar1; // compile error + } + var NS1; + (function (NS1) { + NS1.bar1 = NS1.bar1; // should be compile error + })(NS1 || (NS1 = {})); +}); diff --git a/tests/baselines/reference/exportedVariable1.symbols b/tests/baselines/reference/exportedVariable1.symbols index 96c4b0210ba..eb8d4d2f007 100644 --- a/tests/baselines/reference/exportedVariable1.symbols +++ b/tests/baselines/reference/exportedVariable1.symbols @@ -5,9 +5,9 @@ export var foo = {name: "Bill"}; var upper = foo.name.toUpperCase(); >upper : Symbol(upper, Decl(exportedVariable1.ts, 1, 3)) ->foo.name.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32)) +>foo.name.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --)) >foo.name : Symbol(name, Decl(exportedVariable1.ts, 0, 18)) >foo : Symbol(foo, Decl(exportedVariable1.ts, 0, 10)) >name : Symbol(name, Decl(exportedVariable1.ts, 0, 18)) ->toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/exportsAndImports1-es6.js b/tests/baselines/reference/exportsAndImports1-es6.js new file mode 100644 index 00000000000..5610968bf79 --- /dev/null +++ b/tests/baselines/reference/exportsAndImports1-es6.js @@ -0,0 +1,73 @@ +//// [tests/cases/conformance/es6/modules/exportsAndImports1-es6.ts] //// + +//// [t1.ts] + +var v = 1; +function f() { } +class C { +} +interface I { +} +enum E { + A, B, C +} +const enum D { + A, B, C +} +module M { + export var x; +} +module N { + export interface I { + } +} +type T = number; +import a = M.x; + +export { v, f, C, I, E, D, M, N, T, a }; + +//// [t2.ts] +export { v, f, C, I, E, D, M, N, T, a } from "./t1"; + +//// [t3.ts] +import { v, f, C, I, E, D, M, N, T, a } from "./t1"; +export { v, f, C, I, E, D, M, N, T, a }; + + +//// [t1.js] +var v = 1; +exports.v = v; +function f() { } +exports.f = f; +class C { +} +exports.C = C; +var E; +(function (E) { + E[E["A"] = 0] = "A"; + E[E["B"] = 1] = "B"; + E[E["C"] = 2] = "C"; +})(E || (E = {})); +exports.E = E; +var M; +(function (M) { +})(M || (M = {})); +exports.M = M; +var a = M.x; +exports.a = a; +//// [t2.js] +var t1_1 = require("./t1"); +exports.v = t1_1.v; +exports.f = t1_1.f; +exports.C = t1_1.C; +exports.E = t1_1.E; +exports.M = t1_1.M; +exports.a = t1_1.a; +//// [t3.js] +var t1_1 = require("./t1"); +exports.v = t1_1.v; +exports.f = t1_1.f; +exports.C = t1_1.C; +exports.E = t1_1.E; +exports.M = t1_1.M; +exports.a = t1_1.a; diff --git a/tests/baselines/reference/exportsAndImports1-es6.symbols b/tests/baselines/reference/exportsAndImports1-es6.symbols new file mode 100644 index 00000000000..dc90c8c7bf9 --- /dev/null +++ b/tests/baselines/reference/exportsAndImports1-es6.symbols @@ -0,0 +1,101 @@ +=== tests/cases/conformance/es6/modules/t1.ts === + +var v = 1; +>v : Symbol(v, Decl(t1.ts, 1, 3)) + +function f() { } +>f : Symbol(f, Decl(t1.ts, 1, 10)) + +class C { +>C : Symbol(C, Decl(t1.ts, 2, 16)) +} +interface I { +>I : Symbol(I, Decl(t1.ts, 4, 1)) +} +enum E { +>E : Symbol(E, Decl(t1.ts, 6, 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)) +} +const enum D { +>D : Symbol(D, Decl(t1.ts, 9, 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)) +} +module M { +>M : Symbol(M, Decl(t1.ts, 12, 1)) + + export var x; +>x : Symbol(x, Decl(t1.ts, 14, 14)) +} +module N { +>N : Symbol(N, Decl(t1.ts, 15, 1)) + + export interface I { +>I : Symbol(I, Decl(t1.ts, 16, 10)) + } +} +type T = number; +>T : Symbol(T, Decl(t1.ts, 19, 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)) + +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)) + +=== tests/cases/conformance/es6/modules/t2.ts === +export { v, f, C, I, E, D, M, N, T, a } from "./t1"; +>v : Symbol(v, Decl(t2.ts, 0, 8)) +>f : Symbol(f, Decl(t2.ts, 0, 11)) +>C : Symbol(C, Decl(t2.ts, 0, 14)) +>I : Symbol(I, Decl(t2.ts, 0, 17)) +>E : Symbol(E, Decl(t2.ts, 0, 20)) +>D : Symbol(D, Decl(t2.ts, 0, 23)) +>M : Symbol(M, Decl(t2.ts, 0, 26)) +>N : Symbol(N, Decl(t2.ts, 0, 29)) +>T : Symbol(T, Decl(t2.ts, 0, 32)) +>a : Symbol(a, Decl(t2.ts, 0, 35)) + +=== tests/cases/conformance/es6/modules/t3.ts === +import { v, f, C, I, E, D, M, N, T, a } from "./t1"; +>v : Symbol(v, Decl(t3.ts, 0, 8)) +>f : Symbol(f, Decl(t3.ts, 0, 11)) +>C : Symbol(C, Decl(t3.ts, 0, 14)) +>I : Symbol(I, Decl(t3.ts, 0, 17)) +>E : Symbol(E, Decl(t3.ts, 0, 20)) +>D : Symbol(D, Decl(t3.ts, 0, 23)) +>M : Symbol(M, Decl(t3.ts, 0, 26)) +>N : Symbol(N, Decl(t3.ts, 0, 29)) +>T : Symbol(T, Decl(t3.ts, 0, 32)) +>a : Symbol(a, Decl(t3.ts, 0, 35)) + +export { v, f, C, I, E, D, M, N, T, a }; +>v : Symbol(v, Decl(t3.ts, 1, 8)) +>f : Symbol(f, Decl(t3.ts, 1, 11)) +>C : Symbol(C, Decl(t3.ts, 1, 14)) +>I : Symbol(I, Decl(t3.ts, 1, 17)) +>E : Symbol(E, Decl(t3.ts, 1, 20)) +>D : Symbol(D, Decl(t3.ts, 1, 23)) +>M : Symbol(M, Decl(t3.ts, 1, 26)) +>N : Symbol(N, Decl(t3.ts, 1, 29)) +>T : Symbol(T, Decl(t3.ts, 1, 32)) +>a : Symbol(a, Decl(t3.ts, 1, 35)) + diff --git a/tests/baselines/reference/exportsAndImports1-es6.types b/tests/baselines/reference/exportsAndImports1-es6.types new file mode 100644 index 00000000000..4ba83121541 --- /dev/null +++ b/tests/baselines/reference/exportsAndImports1-es6.types @@ -0,0 +1,102 @@ +=== tests/cases/conformance/es6/modules/t1.ts === + +var v = 1; +>v : number +>1 : number + +function f() { } +>f : () => void + +class C { +>C : C +} +interface I { +>I : I +} +enum E { +>E : E + + A, B, C +>A : E +>B : E +>C : E +} +const enum D { +>D : D + + A, B, C +>A : D +>B : D +>C : D +} +module M { +>M : typeof M + + export var x; +>x : any +} +module N { +>N : any + + export interface I { +>I : I + } +} +type T = number; +>T : number + +import a = M.x; +>a : any +>M : typeof M +>x : any + +export { v, f, C, I, E, D, M, N, T, a }; +>v : number +>f : () => void +>C : typeof C +>I : any +>E : typeof E +>D : typeof D +>M : typeof M +>N : any +>T : any +>a : any + +=== tests/cases/conformance/es6/modules/t2.ts === +export { v, f, C, I, E, D, M, N, T, a } from "./t1"; +>v : number +>f : () => void +>C : typeof C +>I : any +>E : typeof E +>D : typeof D +>M : typeof M +>N : any +>T : any +>a : any + +=== tests/cases/conformance/es6/modules/t3.ts === +import { v, f, C, I, E, D, M, N, T, a } from "./t1"; +>v : number +>f : () => void +>C : typeof C +>I : any +>E : typeof E +>D : typeof D +>M : typeof M +>N : any +>T : any +>a : any + +export { v, f, C, I, E, D, M, N, T, a }; +>v : number +>f : () => void +>C : typeof C +>I : any +>E : typeof E +>D : typeof D +>M : typeof M +>N : any +>T : any +>a : any + diff --git a/tests/baselines/reference/exportsAndImports2-es6.js b/tests/baselines/reference/exportsAndImports2-es6.js new file mode 100644 index 00000000000..aa58c0d8902 --- /dev/null +++ b/tests/baselines/reference/exportsAndImports2-es6.js @@ -0,0 +1,26 @@ +//// [tests/cases/conformance/es6/modules/exportsAndImports2-es6.ts] //// + +//// [t1.ts] + +export var x = "x"; +export var y = "y"; + +//// [t2.ts] +export { x as y, y as x } from "./t1"; + +//// [t3.ts] +import { x, y } from "./t1"; +export { x as y, y as x }; + + +//// [t1.js] +exports.x = "x"; +exports.y = "y"; +//// [t2.js] +var t1_1 = require("./t1"); +exports.y = t1_1.x; +exports.x = t1_1.y; +//// [t3.js] +var t1_1 = require("./t1"); +exports.y = t1_1.x; +exports.x = t1_1.y; diff --git a/tests/baselines/reference/exportsAndImports2-es6.symbols b/tests/baselines/reference/exportsAndImports2-es6.symbols new file mode 100644 index 00000000000..8b53794abae --- /dev/null +++ b/tests/baselines/reference/exportsAndImports2-es6.symbols @@ -0,0 +1,26 @@ +=== tests/cases/conformance/es6/modules/t1.ts === + +export var x = "x"; +>x : Symbol(x, Decl(t1.ts, 1, 10)) + +export var y = "y"; +>y : Symbol(y, Decl(t1.ts, 2, 10)) + +=== tests/cases/conformance/es6/modules/t2.ts === +export { x as y, y as x } from "./t1"; +>x : Symbol(y, Decl(t2.ts, 0, 8)) +>y : Symbol(y, Decl(t2.ts, 0, 8)) +>y : Symbol(x, Decl(t2.ts, 0, 16)) +>x : Symbol(x, Decl(t2.ts, 0, 16)) + +=== tests/cases/conformance/es6/modules/t3.ts === +import { x, y } from "./t1"; +>x : Symbol(x, Decl(t3.ts, 0, 8)) +>y : Symbol(y, Decl(t3.ts, 0, 11)) + +export { x as y, y as x }; +>x : Symbol(y, Decl(t3.ts, 1, 8)) +>y : Symbol(y, Decl(t3.ts, 1, 8)) +>y : Symbol(x, Decl(t3.ts, 1, 16)) +>x : Symbol(x, Decl(t3.ts, 1, 16)) + diff --git a/tests/baselines/reference/exportsAndImports2-es6.types b/tests/baselines/reference/exportsAndImports2-es6.types new file mode 100644 index 00000000000..32de763c567 --- /dev/null +++ b/tests/baselines/reference/exportsAndImports2-es6.types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/es6/modules/t1.ts === + +export var x = "x"; +>x : string +>"x" : string + +export var y = "y"; +>y : string +>"y" : string + +=== tests/cases/conformance/es6/modules/t2.ts === +export { x as y, y as x } from "./t1"; +>x : string +>y : string +>y : string +>x : string + +=== tests/cases/conformance/es6/modules/t3.ts === +import { x, y } from "./t1"; +>x : string +>y : string + +export { x as y, y as x }; +>x : string +>y : string +>y : string +>x : string + diff --git a/tests/baselines/reference/exportsAndImports3-es6.js b/tests/baselines/reference/exportsAndImports3-es6.js new file mode 100644 index 00000000000..d8e142de41d --- /dev/null +++ b/tests/baselines/reference/exportsAndImports3-es6.js @@ -0,0 +1,75 @@ +//// [tests/cases/conformance/es6/modules/exportsAndImports3-es6.ts] //// + +//// [t1.ts] + +export var v = 1; +export function f() { } +export class C { +} +export interface I { +} +export enum E { + A, B, C +} +export const enum D { + A, B, C +} +export module M { + export var x; +} +export module N { + export interface I { + } +} +export type T = number; +export import a = M.x; + +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 }; + +//// [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"; + +//// [t3.ts] +import { 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"; +export { v, f, C, I, E, D, M, N, T, a }; + + +//// [t1.js] +exports.v = 1; +exports.v1 = exports.v; +function f() { } +exports.f = f; +exports.f1 = f; +class C { +} +exports.C = C; +exports.C1 = C; +(function (E) { + E[E["A"] = 0] = "A"; + E[E["B"] = 1] = "B"; + E[E["C"] = 2] = "C"; +})(exports.E || (exports.E = {})); +var E = exports.E; +exports.E1 = E; +var M; +(function (M) { +})(M = exports.M || (exports.M = {})); +exports.M1 = M; +exports.a = M.x; +exports.a1 = exports.a; +//// [t2.js] +var t1_1 = require("./t1"); +exports.v = t1_1.v1; +exports.f = t1_1.f1; +exports.C = t1_1.C1; +exports.E = t1_1.E1; +exports.M = t1_1.M1; +exports.a = t1_1.a1; +//// [t3.js] +var t1_1 = require("./t1"); +exports.v = t1_1.v1; +exports.f = t1_1.f1; +exports.C = t1_1.C1; +exports.E = t1_1.E1; +exports.M = t1_1.M1; +exports.a = t1_1.a1; diff --git a/tests/baselines/reference/exportsAndImports3-es6.symbols b/tests/baselines/reference/exportsAndImports3-es6.symbols new file mode 100644 index 00000000000..a46d7df2a68 --- /dev/null +++ b/tests/baselines/reference/exportsAndImports3-es6.symbols @@ -0,0 +1,131 @@ +=== tests/cases/conformance/es6/modules/t1.ts === + +export var v = 1; +>v : Symbol(v, Decl(t1.ts, 1, 10)) + +export function f() { } +>f : Symbol(f, Decl(t1.ts, 1, 17)) + +export class C { +>C : Symbol(C, Decl(t1.ts, 2, 23)) +} +export interface I { +>I : Symbol(I, Decl(t1.ts, 4, 1)) +} +export enum E { +>E : Symbol(E, Decl(t1.ts, 6, 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)) +} +export const enum D { +>D : Symbol(D, Decl(t1.ts, 9, 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)) +} +export module M { +>M : Symbol(M, Decl(t1.ts, 12, 1)) + + export var x; +>x : Symbol(x, Decl(t1.ts, 14, 14)) +} +export module N { +>N : Symbol(N, Decl(t1.ts, 15, 1)) + + export interface I { +>I : Symbol(I, Decl(t1.ts, 16, 17)) + } +} +export type T = number; +>T : Symbol(T, Decl(t1.ts, 19, 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)) + +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)) + +=== 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"; +>v1 : Symbol(v, Decl(t2.ts, 0, 8)) +>v : Symbol(v, Decl(t2.ts, 0, 8)) +>f1 : Symbol(f, Decl(t2.ts, 0, 17)) +>f : Symbol(f, Decl(t2.ts, 0, 17)) +>C1 : Symbol(C, Decl(t2.ts, 0, 26)) +>C : Symbol(C, Decl(t2.ts, 0, 26)) +>I1 : Symbol(I, Decl(t2.ts, 0, 35)) +>I : Symbol(I, Decl(t2.ts, 0, 35)) +>E1 : Symbol(E, Decl(t2.ts, 0, 44)) +>E : Symbol(E, Decl(t2.ts, 0, 44)) +>D1 : Symbol(D, Decl(t2.ts, 0, 53)) +>D : Symbol(D, Decl(t2.ts, 0, 53)) +>M1 : Symbol(M, Decl(t2.ts, 0, 62)) +>M : Symbol(M, Decl(t2.ts, 0, 62)) +>N1 : Symbol(N, Decl(t2.ts, 0, 71)) +>N : Symbol(N, Decl(t2.ts, 0, 71)) +>T1 : Symbol(T, Decl(t2.ts, 0, 80)) +>T : Symbol(T, Decl(t2.ts, 0, 80)) +>a1 : Symbol(a, Decl(t2.ts, 0, 89)) +>a : Symbol(a, Decl(t2.ts, 0, 89)) + +=== tests/cases/conformance/es6/modules/t3.ts === +import { 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"; +>v1 : Symbol(v, Decl(t3.ts, 0, 8)) +>v : Symbol(v, Decl(t3.ts, 0, 8)) +>f1 : Symbol(f, Decl(t3.ts, 0, 17)) +>f : Symbol(f, Decl(t3.ts, 0, 17)) +>C1 : Symbol(C, Decl(t3.ts, 0, 26)) +>C : Symbol(C, Decl(t3.ts, 0, 26)) +>I1 : Symbol(I, Decl(t3.ts, 0, 35)) +>I : Symbol(I, Decl(t3.ts, 0, 35)) +>E1 : Symbol(E, Decl(t3.ts, 0, 44)) +>E : Symbol(E, Decl(t3.ts, 0, 44)) +>D1 : Symbol(D, Decl(t3.ts, 0, 53)) +>D : Symbol(D, Decl(t3.ts, 0, 53)) +>M1 : Symbol(M, Decl(t3.ts, 0, 62)) +>M : Symbol(M, Decl(t3.ts, 0, 62)) +>N1 : Symbol(N, Decl(t3.ts, 0, 71)) +>N : Symbol(N, Decl(t3.ts, 0, 71)) +>T1 : Symbol(T, Decl(t3.ts, 0, 80)) +>T : Symbol(T, Decl(t3.ts, 0, 80)) +>a1 : Symbol(a, Decl(t3.ts, 0, 89)) +>a : Symbol(a, Decl(t3.ts, 0, 89)) + +export { v, f, C, I, E, D, M, N, T, a }; +>v : Symbol(v, Decl(t3.ts, 1, 8)) +>f : Symbol(f, Decl(t3.ts, 1, 11)) +>C : Symbol(C, Decl(t3.ts, 1, 14)) +>I : Symbol(I, Decl(t3.ts, 1, 17)) +>E : Symbol(E, Decl(t3.ts, 1, 20)) +>D : Symbol(D, Decl(t3.ts, 1, 23)) +>M : Symbol(M, Decl(t3.ts, 1, 26)) +>N : Symbol(N, Decl(t3.ts, 1, 29)) +>T : Symbol(T, Decl(t3.ts, 1, 32)) +>a : Symbol(a, Decl(t3.ts, 1, 35)) + diff --git a/tests/baselines/reference/exportsAndImports3-es6.types b/tests/baselines/reference/exportsAndImports3-es6.types new file mode 100644 index 00000000000..0b8235d969c --- /dev/null +++ b/tests/baselines/reference/exportsAndImports3-es6.types @@ -0,0 +1,132 @@ +=== tests/cases/conformance/es6/modules/t1.ts === + +export var v = 1; +>v : number +>1 : number + +export function f() { } +>f : () => void + +export class C { +>C : C +} +export interface I { +>I : I +} +export enum E { +>E : E + + A, B, C +>A : E +>B : E +>C : E +} +export const enum D { +>D : D + + A, B, C +>A : D +>B : D +>C : D +} +export module M { +>M : typeof M + + export var x; +>x : any +} +export module N { +>N : any + + export interface I { +>I : I + } +} +export type T = number; +>T : number + +export import a = M.x; +>a : any +>M : typeof M +>x : any + +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 : number +>v1 : number +>f : () => void +>f1 : () => void +>C : typeof C +>C1 : typeof C +>I : any +>I1 : any +>E : typeof E +>E1 : typeof E +>D : typeof D +>D1 : typeof D +>M : typeof M +>M1 : typeof M +>N : any +>N1 : any +>T : any +>T1 : any +>a : any +>a1 : any + +=== 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"; +>v1 : number +>v : number +>f1 : () => void +>f : () => void +>C1 : typeof C +>C : typeof C +>I1 : any +>I : any +>E1 : typeof E +>E : typeof E +>D1 : typeof D +>D : typeof D +>M1 : typeof M +>M : typeof M +>N1 : any +>N : any +>T1 : any +>T : any +>a1 : any +>a : any + +=== tests/cases/conformance/es6/modules/t3.ts === +import { 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"; +>v1 : number +>v : number +>f1 : () => void +>f : () => void +>C1 : typeof C +>C : typeof C +>I1 : any +>I : any +>E1 : typeof E +>E : typeof E +>D1 : typeof D +>D : typeof D +>M1 : typeof M +>M : typeof M +>N1 : any +>N : any +>T1 : any +>T : any +>a1 : any +>a : any + +export { v, f, C, I, E, D, M, N, T, a }; +>v : number +>f : () => void +>C : typeof C +>I : any +>E : typeof E +>D : typeof D +>M : typeof M +>N : any +>T : any +>a : any + diff --git a/tests/baselines/reference/exportsAndImports4-es6.js b/tests/baselines/reference/exportsAndImports4-es6.js new file mode 100644 index 00000000000..7cae0c01489 --- /dev/null +++ b/tests/baselines/reference/exportsAndImports4-es6.js @@ -0,0 +1,66 @@ +//// [tests/cases/conformance/es6/modules/exportsAndImports4-es6.ts] //// + +//// [t1.ts] + +export default "hello"; + +//// [t2.ts] +import a = require("./t1"); +a.default; +import b from "./t1"; +b; +import * as c from "./t1"; +c.default; +import { default as d } from "./t1"; +d; +import e1, * as e2 from "./t1"; +e1; +e2.default; +import f1, { default as f2 } from "./t1"; +f1; +f2; +import "./t1"; + +//// [t3.ts] +import a = require("./t1"); +a.default; +import b from "./t1"; +b; +import * as c from "./t1"; +c.default; +import { default as d } from "./t1"; +d; +import e1, * as e2 from "./t1"; +e1; +e2.default; +import f1, { default as f2 } from "./t1"; +f1; +f2; +export { a, b, c, d, e1, e2, f1, f2 }; + + +//// [t1.js] +exports.default = "hello"; +//// [t3.js] +var a = require("./t1"); +exports.a = a; +a.default; +var t1_1 = require("./t1"); +exports.b = t1_1.default; +t1_1.default; +var c = require("./t1"); +exports.c = c; +c.default; +var t1_2 = require("./t1"); +exports.d = t1_2.default; +t1_2.default; +var t1_3 = require("./t1"), e2 = t1_3; +exports.e1 = t1_3.default; +exports.e2 = e2; +t1_3.default; +e2.default; +var t1_4 = require("./t1"); +exports.f1 = t1_4.default; +exports.f2 = t1_4.default; +t1_4.default; +t1_4.default; diff --git a/tests/baselines/reference/exportsAndImports4-es6.symbols b/tests/baselines/reference/exportsAndImports4-es6.symbols new file mode 100644 index 00000000000..0204d9bd586 --- /dev/null +++ b/tests/baselines/reference/exportsAndImports4-es6.symbols @@ -0,0 +1,68 @@ +=== tests/cases/conformance/es6/modules/t3.ts === +import a = require("./t1"); +>a : Symbol(a, Decl(t3.ts, 0, 0)) + +a.default; +>a.default : Symbol(a.default, Decl(t1.ts, 0, 0)) +>a : Symbol(a, Decl(t3.ts, 0, 0)) +>default : Symbol(a.default, Decl(t1.ts, 0, 0)) + +import b from "./t1"; +>b : Symbol(b, Decl(t3.ts, 2, 6)) + +b; +>b : Symbol(b, Decl(t3.ts, 2, 6)) + +import * as c from "./t1"; +>c : Symbol(c, Decl(t3.ts, 4, 6)) + +c.default; +>c.default : Symbol(a.default, Decl(t1.ts, 0, 0)) +>c : Symbol(c, Decl(t3.ts, 4, 6)) +>default : Symbol(a.default, Decl(t1.ts, 0, 0)) + +import { default as d } from "./t1"; +>default : Symbol(d, Decl(t3.ts, 6, 8)) +>d : Symbol(d, Decl(t3.ts, 6, 8)) + +d; +>d : Symbol(d, Decl(t3.ts, 6, 8)) + +import e1, * as e2 from "./t1"; +>e1 : Symbol(e1, Decl(t3.ts, 8, 6)) +>e2 : Symbol(e2, Decl(t3.ts, 8, 10)) + +e1; +>e1 : Symbol(e1, Decl(t3.ts, 8, 6)) + +e2.default; +>e2.default : Symbol(a.default, Decl(t1.ts, 0, 0)) +>e2 : Symbol(e2, Decl(t3.ts, 8, 10)) +>default : Symbol(a.default, Decl(t1.ts, 0, 0)) + +import f1, { default as f2 } from "./t1"; +>f1 : Symbol(f1, Decl(t3.ts, 11, 6)) +>default : Symbol(f2, Decl(t3.ts, 11, 12)) +>f2 : Symbol(f2, Decl(t3.ts, 11, 12)) + +f1; +>f1 : Symbol(f1, Decl(t3.ts, 11, 6)) + +f2; +>f2 : Symbol(f2, Decl(t3.ts, 11, 12)) + +export { a, b, c, d, e1, e2, f1, f2 }; +>a : Symbol(a, Decl(t3.ts, 14, 8)) +>b : Symbol(b, Decl(t3.ts, 14, 11)) +>c : Symbol(c, Decl(t3.ts, 14, 14)) +>d : Symbol(d, Decl(t3.ts, 14, 17)) +>e1 : Symbol(e1, Decl(t3.ts, 14, 20)) +>e2 : Symbol(e2, Decl(t3.ts, 14, 24)) +>f1 : Symbol(f1, Decl(t3.ts, 14, 28)) +>f2 : Symbol(f2, Decl(t3.ts, 14, 32)) + +=== tests/cases/conformance/es6/modules/t1.ts === + +No type information for this code.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 new file mode 100644 index 00000000000..4bd6f8c0e1e --- /dev/null +++ b/tests/baselines/reference/exportsAndImports4-es6.types @@ -0,0 +1,68 @@ +=== tests/cases/conformance/es6/modules/t3.ts === +import a = require("./t1"); +>a : typeof a + +a.default; +>a.default : string +>a : typeof a +>default : string + +import b from "./t1"; +>b : string + +b; +>b : string + +import * as c from "./t1"; +>c : typeof a + +c.default; +>c.default : string +>c : typeof a +>default : string + +import { default as d } from "./t1"; +>default : string +>d : string + +d; +>d : string + +import e1, * as e2 from "./t1"; +>e1 : string +>e2 : typeof a + +e1; +>e1 : string + +e2.default; +>e2.default : string +>e2 : typeof a +>default : string + +import f1, { default as f2 } from "./t1"; +>f1 : string +>default : string +>f2 : string + +f1; +>f1 : string + +f2; +>f2 : string + +export { a, b, c, d, e1, e2, f1, f2 }; +>a : typeof a +>b : string +>c : typeof a +>d : string +>e1 : string +>e2 : typeof a +>f1 : string +>f2 : string + +=== tests/cases/conformance/es6/modules/t1.ts === + +No type information for this code.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/exportsInAmbientModules1.js b/tests/baselines/reference/exportsInAmbientModules1.js new file mode 100644 index 00000000000..4370b197403 --- /dev/null +++ b/tests/baselines/reference/exportsInAmbientModules1.js @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/exportsInAmbientModules1.ts] //// + +//// [external.d.ts] + +export var x: number + +//// [main.ts] + +declare module "M" { + export {x} from "external" +} + +//// [main.js] diff --git a/tests/baselines/reference/exportsInAmbientModules1.symbols b/tests/baselines/reference/exportsInAmbientModules1.symbols new file mode 100644 index 00000000000..58cdf8663a7 --- /dev/null +++ b/tests/baselines/reference/exportsInAmbientModules1.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/external.d.ts === + +export var x: number +>x : Symbol(x, Decl(external.d.ts, 1, 10)) + +=== tests/cases/compiler/main.ts === + +declare module "M" { + export {x} from "external" +>x : Symbol(x, Decl(main.ts, 2, 12)) +} diff --git a/tests/baselines/reference/exportsInAmbientModules1.types b/tests/baselines/reference/exportsInAmbientModules1.types new file mode 100644 index 00000000000..490a63caf92 --- /dev/null +++ b/tests/baselines/reference/exportsInAmbientModules1.types @@ -0,0 +1,11 @@ +=== 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 new file mode 100644 index 00000000000..f08ff17f8ba --- /dev/null +++ b/tests/baselines/reference/exportsInAmbientModules2.js @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/exportsInAmbientModules2.ts] //// + +//// [external.d.ts] + +export default class C {} + +//// [main.ts] + +declare module "M" { + export * from "external" +} + +//// [main.js] diff --git a/tests/baselines/reference/exportsInAmbientModules2.symbols b/tests/baselines/reference/exportsInAmbientModules2.symbols new file mode 100644 index 00000000000..54e8b44ec34 --- /dev/null +++ b/tests/baselines/reference/exportsInAmbientModules2.symbols @@ -0,0 +1,11 @@ +=== 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" { +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 new file mode 100644 index 00000000000..3472a35bf75 --- /dev/null +++ b/tests/baselines/reference/exportsInAmbientModules2.types @@ -0,0 +1,11 @@ +=== 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" { +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/extendBooleanInterface.symbols b/tests/baselines/reference/extendBooleanInterface.symbols index 8e123eb050e..be2fb30226d 100644 --- a/tests/baselines/reference/extendBooleanInterface.symbols +++ b/tests/baselines/reference/extendBooleanInterface.symbols @@ -1,6 +1,6 @@ === tests/cases/conformance/types/primitives/boolean/extendBooleanInterface.ts === interface Boolean { ->Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11), Decl(extendBooleanInterface.ts, 0, 0)) +>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(extendBooleanInterface.ts, 0, 0)) doStuff(): string; >doStuff : Symbol(doStuff, Decl(extendBooleanInterface.ts, 0, 19)) diff --git a/tests/baselines/reference/extendClassExpressionFromModule.symbols b/tests/baselines/reference/extendClassExpressionFromModule.symbols index c131ea8fa28..78d483b5d7d 100644 --- a/tests/baselines/reference/extendClassExpressionFromModule.symbols +++ b/tests/baselines/reference/extendClassExpressionFromModule.symbols @@ -8,6 +8,7 @@ var x = foo1; class y extends x {} >y : Symbol(y, Decl(foo2.ts, 1, 13)) +>x : Symbol(x, Decl(foo2.ts, 1, 3)) === tests/cases/conformance/classes/classExpressions/foo1.ts === class x{} diff --git a/tests/baselines/reference/extendNonClassSymbol1.symbols b/tests/baselines/reference/extendNonClassSymbol1.symbols index 02291ebb181..7c03ef3a97f 100644 --- a/tests/baselines/reference/extendNonClassSymbol1.symbols +++ b/tests/baselines/reference/extendNonClassSymbol1.symbols @@ -9,4 +9,5 @@ var x = A; class C extends x { } // error, could not find symbol xs >C : Symbol(C, Decl(extendNonClassSymbol1.ts, 1, 10)) +>x : Symbol(x, Decl(extendNonClassSymbol1.ts, 1, 3)) diff --git a/tests/baselines/reference/extendNumberInterface.symbols b/tests/baselines/reference/extendNumberInterface.symbols index 56d2f8b0014..218f0f41cb2 100644 --- a/tests/baselines/reference/extendNumberInterface.symbols +++ b/tests/baselines/reference/extendNumberInterface.symbols @@ -1,6 +1,6 @@ === tests/cases/conformance/types/primitives/number/extendNumberInterface.ts === interface Number { ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11), Decl(extendNumberInterface.ts, 0, 0)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(extendNumberInterface.ts, 0, 0)) doStuff(): string; >doStuff : Symbol(doStuff, Decl(extendNumberInterface.ts, 0, 18)) diff --git a/tests/baselines/reference/extendStringInterface.symbols b/tests/baselines/reference/extendStringInterface.symbols index a72773647a8..aa20b2e2c15 100644 --- a/tests/baselines/reference/extendStringInterface.symbols +++ b/tests/baselines/reference/extendStringInterface.symbols @@ -1,6 +1,6 @@ === tests/cases/conformance/types/primitives/string/extendStringInterface.ts === interface String { ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(extendStringInterface.ts, 0, 0)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(extendStringInterface.ts, 0, 0)) doStuff(): string; >doStuff : Symbol(doStuff, Decl(extendStringInterface.ts, 0, 18)) diff --git a/tests/baselines/reference/externFunc.symbols b/tests/baselines/reference/externFunc.symbols index 1a02596d7db..b23a70695cf 100644 --- a/tests/baselines/reference/externFunc.symbols +++ b/tests/baselines/reference/externFunc.symbols @@ -1,8 +1,8 @@ === tests/cases/compiler/externFunc.ts === declare function parseInt(s:string):number; ->parseInt : Symbol(parseInt, Decl(lib.d.ts, 28, 38), Decl(externFunc.ts, 0, 0)) +>parseInt : Symbol(parseInt, Decl(lib.d.ts, --, --), Decl(externFunc.ts, 0, 0)) >s : Symbol(s, Decl(externFunc.ts, 0, 26)) parseInt("2"); ->parseInt : Symbol(parseInt, Decl(lib.d.ts, 28, 38), Decl(externFunc.ts, 0, 0)) +>parseInt : Symbol(parseInt, Decl(lib.d.ts, --, --), Decl(externFunc.ts, 0, 0)) diff --git a/tests/baselines/reference/externSyntax.errors.txt b/tests/baselines/reference/externSyntax.errors.txt index 1d3380b99d5..464bfcd55e4 100644 --- a/tests/baselines/reference/externSyntax.errors.txt +++ b/tests/baselines/reference/externSyntax.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/externSyntax.ts(8,20): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/externSyntax.ts(8,20): error TS1183: An implementation cannot be declared in ambient contexts. ==== tests/cases/compiler/externSyntax.ts (1 errors) ==== @@ -11,7 +11,7 @@ tests/cases/compiler/externSyntax.ts(8,20): error TS1184: An implementation cann public f(); public g() { } // error body ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } } diff --git a/tests/baselines/reference/fatArrowSelf.types b/tests/baselines/reference/fatArrowSelf.types index c4b2936fd37..574262265bc 100644 --- a/tests/baselines/reference/fatArrowSelf.types +++ b/tests/baselines/reference/fatArrowSelf.types @@ -38,7 +38,7 @@ module Consumer { >this.emitter.addListener('change', (e) => { this.changed(); }) : void >this.emitter.addListener : (type: string, listener: Events.ListenerCallback) => void >this.emitter : Events.EventEmitter ->this : EventEmitterConsummer +>this : this >emitter : Events.EventEmitter >addListener : (type: string, listener: Events.ListenerCallback) => void >'change' : string @@ -48,7 +48,7 @@ module Consumer { this.changed(); >this.changed() : void >this.changed : () => void ->this : EventEmitterConsummer +>this : this >changed : () => void }); diff --git a/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols b/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols index 731e8558bab..ea0ed9a605c 100644 --- a/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols +++ b/tests/baselines/reference/fatarrowfunctionsInFunctionParameterDefaults.symbols @@ -12,7 +12,7 @@ function fn(x = () => this, y = x()) { } fn.call(4); // Should be 4 ->fn.call : Symbol(Function.call, Decl(lib.d.ts, 234, 45)) +>fn.call : Symbol(Function.call, Decl(lib.d.ts, --, --)) >fn : Symbol(fn, Decl(fatarrowfunctionsInFunctionParameterDefaults.ts, 0, 0)) ->call : Symbol(Function.call, Decl(lib.d.ts, 234, 45)) +>call : Symbol(Function.call, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/fillInMissingTypeArgsOnConstructCalls.symbols b/tests/baselines/reference/fillInMissingTypeArgsOnConstructCalls.symbols index eff8999a0f7..97d485c4b56 100644 --- a/tests/baselines/reference/fillInMissingTypeArgsOnConstructCalls.symbols +++ b/tests/baselines/reference/fillInMissingTypeArgsOnConstructCalls.symbols @@ -2,7 +2,7 @@ class A{ >A : Symbol(A, Decl(fillInMissingTypeArgsOnConstructCalls.ts, 0, 0)) >T : Symbol(T, Decl(fillInMissingTypeArgsOnConstructCalls.ts, 0, 8)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) list: T ; >list : Symbol(list, Decl(fillInMissingTypeArgsOnConstructCalls.ts, 0, 26)) diff --git a/tests/baselines/reference/fixingTypeParametersRepeatedly1.symbols b/tests/baselines/reference/fixingTypeParametersRepeatedly1.symbols index 998e59c0b8f..86f91c82663 100644 --- a/tests/baselines/reference/fixingTypeParametersRepeatedly1.symbols +++ b/tests/baselines/reference/fixingTypeParametersRepeatedly1.symbols @@ -18,9 +18,9 @@ f("", x => null, x => x.toLowerCase()); >f : Symbol(f, Decl(fixingTypeParametersRepeatedly1.ts, 0, 0)) >x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 1, 5)) >x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 1, 16)) ->x.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>x.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 1, 16)) ->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) // First overload of g should type check just like f declare function g(x: T, y: (p: T) => T, z: (p: T) => T): T; @@ -45,7 +45,7 @@ g("", x => null, x => x.toLowerCase()); >g : Symbol(g, Decl(fixingTypeParametersRepeatedly1.ts, 1, 39), Decl(fixingTypeParametersRepeatedly1.ts, 4, 63)) >x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 6, 5)) >x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 6, 16)) ->x.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>x.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(fixingTypeParametersRepeatedly1.ts, 6, 16)) ->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/fluentClasses.js b/tests/baselines/reference/fluentClasses.js new file mode 100644 index 00000000000..12f3cfff48d --- /dev/null +++ b/tests/baselines/reference/fluentClasses.js @@ -0,0 +1,56 @@ +//// [fluentClasses.ts] +class A { + foo() { + return this; + } +} +class B extends A { + bar() { + return this; + } +} +class C extends B { + baz() { + return this; + } +} +var c: C; +var z = c.foo().bar().baz(); // Fluent pattern + + +//// [fluentClasses.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var A = (function () { + function A() { + } + A.prototype.foo = function () { + return this; + }; + return A; +})(); +var B = (function (_super) { + __extends(B, _super); + function B() { + _super.apply(this, arguments); + } + B.prototype.bar = function () { + return this; + }; + return B; +})(A); +var C = (function (_super) { + __extends(C, _super); + function C() { + _super.apply(this, arguments); + } + C.prototype.baz = function () { + return this; + }; + return C; +})(B); +var c; +var z = c.foo().bar().baz(); // Fluent pattern diff --git a/tests/baselines/reference/fluentClasses.symbols b/tests/baselines/reference/fluentClasses.symbols new file mode 100644 index 00000000000..3125235b6b1 --- /dev/null +++ b/tests/baselines/reference/fluentClasses.symbols @@ -0,0 +1,47 @@ +=== tests/cases/conformance/types/thisType/fluentClasses.ts === +class A { +>A : Symbol(A, Decl(fluentClasses.ts, 0, 0)) + + foo() { +>foo : Symbol(foo, Decl(fluentClasses.ts, 0, 9)) + + return this; +>this : Symbol(A, Decl(fluentClasses.ts, 0, 0)) + } +} +class B extends A { +>B : Symbol(B, Decl(fluentClasses.ts, 4, 1)) +>A : Symbol(A, Decl(fluentClasses.ts, 0, 0)) + + bar() { +>bar : Symbol(bar, Decl(fluentClasses.ts, 5, 19)) + + return this; +>this : Symbol(B, Decl(fluentClasses.ts, 4, 1)) + } +} +class C extends B { +>C : Symbol(C, Decl(fluentClasses.ts, 9, 1)) +>B : Symbol(B, Decl(fluentClasses.ts, 4, 1)) + + baz() { +>baz : Symbol(baz, Decl(fluentClasses.ts, 10, 19)) + + return this; +>this : Symbol(C, Decl(fluentClasses.ts, 9, 1)) + } +} +var c: C; +>c : Symbol(c, Decl(fluentClasses.ts, 15, 3)) +>C : Symbol(C, Decl(fluentClasses.ts, 9, 1)) + +var z = c.foo().bar().baz(); // Fluent pattern +>z : Symbol(z, Decl(fluentClasses.ts, 16, 3)) +>c.foo().bar().baz : Symbol(C.baz, Decl(fluentClasses.ts, 10, 19)) +>c.foo().bar : Symbol(B.bar, Decl(fluentClasses.ts, 5, 19)) +>c.foo : Symbol(A.foo, Decl(fluentClasses.ts, 0, 9)) +>c : Symbol(c, Decl(fluentClasses.ts, 15, 3)) +>foo : Symbol(A.foo, Decl(fluentClasses.ts, 0, 9)) +>bar : Symbol(B.bar, Decl(fluentClasses.ts, 5, 19)) +>baz : Symbol(C.baz, Decl(fluentClasses.ts, 10, 19)) + diff --git a/tests/baselines/reference/fluentClasses.types b/tests/baselines/reference/fluentClasses.types new file mode 100644 index 00000000000..31ed6aafa01 --- /dev/null +++ b/tests/baselines/reference/fluentClasses.types @@ -0,0 +1,50 @@ +=== tests/cases/conformance/types/thisType/fluentClasses.ts === +class A { +>A : A + + foo() { +>foo : () => this + + return this; +>this : this + } +} +class B extends A { +>B : B +>A : A + + bar() { +>bar : () => this + + return this; +>this : this + } +} +class C extends B { +>C : C +>B : B + + baz() { +>baz : () => this + + return this; +>this : this + } +} +var c: C; +>c : C +>C : C + +var z = c.foo().bar().baz(); // Fluent pattern +>z : C +>c.foo().bar().baz() : C +>c.foo().bar().baz : () => C +>c.foo().bar() : C +>c.foo().bar : () => C +>c.foo() : C +>c.foo : () => C +>c : C +>foo : () => C +>bar : () => C +>baz : () => C + diff --git a/tests/baselines/reference/fluentInterfaces.js b/tests/baselines/reference/fluentInterfaces.js new file mode 100644 index 00000000000..1be15923d6c --- /dev/null +++ b/tests/baselines/reference/fluentInterfaces.js @@ -0,0 +1,17 @@ +//// [fluentInterfaces.ts] +interface A { + foo(): this; +} +interface B extends A { + bar(): this; +} +interface C extends B { + baz(): this; +} +var c: C; +var z = c.foo().bar().baz(); // Fluent pattern + + +//// [fluentInterfaces.js] +var c; +var z = c.foo().bar().baz(); // Fluent pattern diff --git a/tests/baselines/reference/fluentInterfaces.symbols b/tests/baselines/reference/fluentInterfaces.symbols new file mode 100644 index 00000000000..e059cdc127e --- /dev/null +++ b/tests/baselines/reference/fluentInterfaces.symbols @@ -0,0 +1,35 @@ +=== tests/cases/conformance/types/thisType/fluentInterfaces.ts === +interface A { +>A : Symbol(A, Decl(fluentInterfaces.ts, 0, 0)) + + foo(): this; +>foo : Symbol(foo, Decl(fluentInterfaces.ts, 0, 13)) +} +interface B extends A { +>B : Symbol(B, Decl(fluentInterfaces.ts, 2, 1)) +>A : Symbol(A, Decl(fluentInterfaces.ts, 0, 0)) + + bar(): this; +>bar : Symbol(bar, Decl(fluentInterfaces.ts, 3, 23)) +} +interface C extends B { +>C : Symbol(C, Decl(fluentInterfaces.ts, 5, 1)) +>B : Symbol(B, Decl(fluentInterfaces.ts, 2, 1)) + + baz(): this; +>baz : Symbol(baz, Decl(fluentInterfaces.ts, 6, 23)) +} +var c: C; +>c : Symbol(c, Decl(fluentInterfaces.ts, 9, 3)) +>C : Symbol(C, Decl(fluentInterfaces.ts, 5, 1)) + +var z = c.foo().bar().baz(); // Fluent pattern +>z : Symbol(z, Decl(fluentInterfaces.ts, 10, 3)) +>c.foo().bar().baz : Symbol(C.baz, Decl(fluentInterfaces.ts, 6, 23)) +>c.foo().bar : Symbol(B.bar, Decl(fluentInterfaces.ts, 3, 23)) +>c.foo : Symbol(A.foo, Decl(fluentInterfaces.ts, 0, 13)) +>c : Symbol(c, Decl(fluentInterfaces.ts, 9, 3)) +>foo : Symbol(A.foo, Decl(fluentInterfaces.ts, 0, 13)) +>bar : Symbol(B.bar, Decl(fluentInterfaces.ts, 3, 23)) +>baz : Symbol(C.baz, Decl(fluentInterfaces.ts, 6, 23)) + diff --git a/tests/baselines/reference/fluentInterfaces.types b/tests/baselines/reference/fluentInterfaces.types new file mode 100644 index 00000000000..26e5a74c188 --- /dev/null +++ b/tests/baselines/reference/fluentInterfaces.types @@ -0,0 +1,38 @@ +=== tests/cases/conformance/types/thisType/fluentInterfaces.ts === +interface A { +>A : A + + foo(): this; +>foo : () => this +} +interface B extends A { +>B : B +>A : A + + bar(): this; +>bar : () => this +} +interface C extends B { +>C : C +>B : B + + baz(): this; +>baz : () => this +} +var c: C; +>c : C +>C : C + +var z = c.foo().bar().baz(); // Fluent pattern +>z : C +>c.foo().bar().baz() : C +>c.foo().bar().baz : () => C +>c.foo().bar() : C +>c.foo().bar : () => C +>c.foo() : C +>c.foo : () => C +>c : C +>foo : () => C +>bar : () => C +>baz : () => C + diff --git a/tests/baselines/reference/for-of13.symbols b/tests/baselines/reference/for-of13.symbols index 09a7e06cc21..bcfc3f981bd 100644 --- a/tests/baselines/reference/for-of13.symbols +++ b/tests/baselines/reference/for-of13.symbols @@ -4,6 +4,6 @@ var v: string; for (v of [""].values()) { } >v : Symbol(v, Decl(for-of13.ts, 0, 3)) ->[""].values : Symbol(Array.values, Decl(lib.d.ts, 4146, 37)) ->values : Symbol(Array.values, Decl(lib.d.ts, 4146, 37)) +>[""].values : Symbol(Array.values, Decl(lib.d.ts, --, --)) +>values : Symbol(Array.values, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/for-of18.symbols b/tests/baselines/reference/for-of18.symbols index 76621026a00..34e11d3d388 100644 --- a/tests/baselines/reference/for-of18.symbols +++ b/tests/baselines/reference/for-of18.symbols @@ -22,9 +22,9 @@ class StringIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(StringIterator, Decl(for-of18.ts, 1, 33)) diff --git a/tests/baselines/reference/for-of18.types b/tests/baselines/reference/for-of18.types index 5b2be7edc3e..415f2b11568 100644 --- a/tests/baselines/reference/for-of18.types +++ b/tests/baselines/reference/for-of18.types @@ -32,6 +32,6 @@ class StringIterator { >iterator : symbol return this; ->this : StringIterator +>this : this } } diff --git a/tests/baselines/reference/for-of19.symbols b/tests/baselines/reference/for-of19.symbols index 35892922df3..81aafd32d13 100644 --- a/tests/baselines/reference/for-of19.symbols +++ b/tests/baselines/reference/for-of19.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(FooIterator, Decl(for-of19.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of19.types b/tests/baselines/reference/for-of19.types index 02ef786ddd9..5128617bf24 100644 --- a/tests/baselines/reference/for-of19.types +++ b/tests/baselines/reference/for-of19.types @@ -37,6 +37,6 @@ class FooIterator { >iterator : symbol return this; ->this : FooIterator +>this : this } } diff --git a/tests/baselines/reference/for-of20.symbols b/tests/baselines/reference/for-of20.symbols index f01969e23bb..727b69e3c9d 100644 --- a/tests/baselines/reference/for-of20.symbols +++ b/tests/baselines/reference/for-of20.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(FooIterator, Decl(for-of20.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of20.types b/tests/baselines/reference/for-of20.types index 3da6fd484b1..de12979c650 100644 --- a/tests/baselines/reference/for-of20.types +++ b/tests/baselines/reference/for-of20.types @@ -37,6 +37,6 @@ class FooIterator { >iterator : symbol return this; ->this : FooIterator +>this : this } } diff --git a/tests/baselines/reference/for-of21.symbols b/tests/baselines/reference/for-of21.symbols index c740cf62446..1464a42aab2 100644 --- a/tests/baselines/reference/for-of21.symbols +++ b/tests/baselines/reference/for-of21.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(FooIterator, Decl(for-of21.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of21.types b/tests/baselines/reference/for-of21.types index a0cc50e99d7..cab24c525d9 100644 --- a/tests/baselines/reference/for-of21.types +++ b/tests/baselines/reference/for-of21.types @@ -37,6 +37,6 @@ class FooIterator { >iterator : symbol return this; ->this : FooIterator +>this : this } } diff --git a/tests/baselines/reference/for-of22.symbols b/tests/baselines/reference/for-of22.symbols index bf4304a8216..1aac39dae6e 100644 --- a/tests/baselines/reference/for-of22.symbols +++ b/tests/baselines/reference/for-of22.symbols @@ -28,9 +28,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(FooIterator, Decl(for-of22.ts, 5, 13)) diff --git a/tests/baselines/reference/for-of22.types b/tests/baselines/reference/for-of22.types index 09e85798554..f15a1d7e114 100644 --- a/tests/baselines/reference/for-of22.types +++ b/tests/baselines/reference/for-of22.types @@ -38,6 +38,6 @@ class FooIterator { >iterator : symbol return this; ->this : FooIterator +>this : this } } diff --git a/tests/baselines/reference/for-of23.symbols b/tests/baselines/reference/for-of23.symbols index a45775127b0..f4f34fcef93 100644 --- a/tests/baselines/reference/for-of23.symbols +++ b/tests/baselines/reference/for-of23.symbols @@ -27,9 +27,9 @@ class FooIterator { }; } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(FooIterator, Decl(for-of23.ts, 4, 13)) diff --git a/tests/baselines/reference/for-of23.types b/tests/baselines/reference/for-of23.types index 37515c0b70a..87f1eeabbb7 100644 --- a/tests/baselines/reference/for-of23.types +++ b/tests/baselines/reference/for-of23.types @@ -38,6 +38,6 @@ class FooIterator { >iterator : symbol return this; ->this : FooIterator +>this : this } } diff --git a/tests/baselines/reference/for-of25.symbols b/tests/baselines/reference/for-of25.symbols index ef08deb568d..dfa358da0bd 100644 --- a/tests/baselines/reference/for-of25.symbols +++ b/tests/baselines/reference/for-of25.symbols @@ -10,9 +10,9 @@ class StringIterator { >StringIterator : Symbol(StringIterator, Decl(for-of25.ts, 1, 37)) [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return x; >x : Symbol(x, Decl(for-of25.ts, 0, 3)) diff --git a/tests/baselines/reference/for-of26.symbols b/tests/baselines/reference/for-of26.symbols index abaa0a92dcc..9f4d1455c3f 100644 --- a/tests/baselines/reference/for-of26.symbols +++ b/tests/baselines/reference/for-of26.symbols @@ -16,9 +16,9 @@ class StringIterator { >x : Symbol(x, Decl(for-of26.ts, 0, 3)) } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(StringIterator, Decl(for-of26.ts, 1, 37)) diff --git a/tests/baselines/reference/for-of26.types b/tests/baselines/reference/for-of26.types index d2608fbf154..fe930e2e57f 100644 --- a/tests/baselines/reference/for-of26.types +++ b/tests/baselines/reference/for-of26.types @@ -22,6 +22,6 @@ class StringIterator { >iterator : symbol return this; ->this : StringIterator +>this : this } } diff --git a/tests/baselines/reference/for-of27.symbols b/tests/baselines/reference/for-of27.symbols index 727574805b9..57148c53f13 100644 --- a/tests/baselines/reference/for-of27.symbols +++ b/tests/baselines/reference/for-of27.symbols @@ -7,7 +7,7 @@ class StringIterator { >StringIterator : Symbol(StringIterator, Decl(for-of27.ts, 0, 37)) [Symbol.iterator]: any; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/for-of28.symbols b/tests/baselines/reference/for-of28.symbols index 4e1bf8ad3dc..91081d3abdf 100644 --- a/tests/baselines/reference/for-of28.symbols +++ b/tests/baselines/reference/for-of28.symbols @@ -10,9 +10,9 @@ class StringIterator { >next : Symbol(next, Decl(for-of28.ts, 2, 22)) [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(StringIterator, Decl(for-of28.ts, 0, 37)) diff --git a/tests/baselines/reference/for-of28.types b/tests/baselines/reference/for-of28.types index 91b77a55a4d..882d2df6186 100644 --- a/tests/baselines/reference/for-of28.types +++ b/tests/baselines/reference/for-of28.types @@ -16,6 +16,6 @@ class StringIterator { >iterator : symbol return this; ->this : StringIterator +>this : this } } diff --git a/tests/baselines/reference/for-of37.symbols b/tests/baselines/reference/for-of37.symbols index b0a39571f6f..b8ce9da9ce2 100644 --- a/tests/baselines/reference/for-of37.symbols +++ b/tests/baselines/reference/for-of37.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of37.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of37.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for (var v of map) { >v : Symbol(v, Decl(for-of37.ts, 1, 8)) diff --git a/tests/baselines/reference/for-of38.symbols b/tests/baselines/reference/for-of38.symbols index 67ee08bbb5f..18d2dda6db8 100644 --- a/tests/baselines/reference/for-of38.symbols +++ b/tests/baselines/reference/for-of38.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of38.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of38.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for (var [k, v] of map) { >k : Symbol(k, Decl(for-of38.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of40.symbols b/tests/baselines/reference/for-of40.symbols index 2f3a2a9a574..a9177d12435 100644 --- a/tests/baselines/reference/for-of40.symbols +++ b/tests/baselines/reference/for-of40.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of40.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of40.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for (var [k = "", v = false] of map) { >k : Symbol(k, Decl(for-of40.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of44.symbols b/tests/baselines/reference/for-of44.symbols index 839de020702..d7057da0ee2 100644 --- a/tests/baselines/reference/for-of44.symbols +++ b/tests/baselines/reference/for-of44.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of44.ts === var array: [number, string | boolean | symbol][] = [[0, ""], [0, true], [1, Symbol()]] >array : Symbol(array, Decl(for-of44.ts, 0, 3)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for (var [num, strBoolSym] of array) { >num : Symbol(num, Decl(for-of44.ts, 1, 10)) diff --git a/tests/baselines/reference/for-of45.symbols b/tests/baselines/reference/for-of45.symbols index 6f75dd6311d..7d8ffd4ba86 100644 --- a/tests/baselines/reference/for-of45.symbols +++ b/tests/baselines/reference/for-of45.symbols @@ -5,7 +5,7 @@ var k: string, v: boolean; var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of45.ts, 1, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for ([k = "", v = false] of map) { >k : Symbol(k, Decl(for-of45.ts, 0, 3)) diff --git a/tests/baselines/reference/for-of48.errors.txt b/tests/baselines/reference/for-of48.errors.txt index f6826e14c61..8a8fd668714 100644 --- a/tests/baselines/reference/for-of48.errors.txt +++ b/tests/baselines/reference/for-of48.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/es6/for-ofStatements/for-of48.ts(4,12): error TS1005: ':' expected. +tests/cases/conformance/es6/for-ofStatements/for-of48.ts(4,10): error TS2322: Type 'boolean' is not assignable to type 'number'. ==== tests/cases/conformance/es6/for-ofStatements/for-of48.ts (1 errors) ==== @@ -6,8 +6,8 @@ tests/cases/conformance/es6/for-ofStatements/for-of48.ts(4,12): error TS1005: ': var array = [{ x: "", y: true }] enum E { x } for ({x, y = E.x} of array) { - ~ -!!! error TS1005: ':' expected. + ~ +!!! error TS2322: Type 'boolean' is not assignable to type 'number'. x; y; } \ No newline at end of file diff --git a/tests/baselines/reference/for-of48.js b/tests/baselines/reference/for-of48.js index 2a5e4e32b94..65e23076fd9 100644 --- a/tests/baselines/reference/for-of48.js +++ b/tests/baselines/reference/for-of48.js @@ -14,7 +14,7 @@ var E; (function (E) { E[E["x"] = 0] = "x"; })(E || (E = {})); -for ({ x, y: = E.x } of array) { +for ({ x, y = E.x } of array) { x; y; } diff --git a/tests/baselines/reference/for-of50.symbols b/tests/baselines/reference/for-of50.symbols index 7fb77790ef7..435390f2a6e 100644 --- a/tests/baselines/reference/for-of50.symbols +++ b/tests/baselines/reference/for-of50.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of50.ts === var map = new Map([["", true]]); >map : Symbol(map, Decl(for-of50.ts, 0, 3)) ->Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for (const [k, v] of map) { >k : Symbol(k, Decl(for-of50.ts, 1, 12)) diff --git a/tests/baselines/reference/for-of57.symbols b/tests/baselines/reference/for-of57.symbols index 9aadb415e8f..191377bdd47 100644 --- a/tests/baselines/reference/for-of57.symbols +++ b/tests/baselines/reference/for-of57.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/for-ofStatements/for-of57.ts === var iter: Iterable; >iter : Symbol(iter, Decl(for-of57.ts, 0, 3)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) for (let num of iter) { } >num : Symbol(num, Decl(for-of57.ts, 1, 8)) diff --git a/tests/baselines/reference/forStatements.symbols b/tests/baselines/reference/forStatements.symbols index 6f7c6d6cdbe..e72d55e5813 100644 --- a/tests/baselines/reference/forStatements.symbols +++ b/tests/baselines/reference/forStatements.symbols @@ -51,9 +51,9 @@ module M { export function F2(x: number): string { return x.toString(); } >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, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(forStatements.ts, 21, 23)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } for(var aNumber: number = 9.9;;){} @@ -64,13 +64,13 @@ for(var aString: string = 'this is a string';;){} for(var aDate: Date = new Date(12);;){} >aDate : Symbol(aDate, Decl(forStatements.ts, 26, 7)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for(var anObject: Object = new Object();;){} >anObject : Symbol(anObject, Decl(forStatements.ts, 27, 7)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>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, 29, 7)) diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols index 6a98fbf133e..1f131bb9701 100644 --- a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols +++ b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols @@ -102,7 +102,7 @@ for (var a: string[] = []; ;) { } for (var a = new Array(); ;) { } >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, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for (var a: typeof a; ;) { } >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/funcdecl.symbols b/tests/baselines/reference/funcdecl.symbols index 2538e3a9a04..b91ec3814cf 100644 --- a/tests/baselines/reference/funcdecl.symbols +++ b/tests/baselines/reference/funcdecl.symbols @@ -40,7 +40,7 @@ function withMultiParams(a : number, b, c: Object) { >a : Symbol(a, Decl(funcdecl.ts, 19, 25)) >b : Symbol(b, Decl(funcdecl.ts, 19, 36)) >c : Symbol(c, Decl(funcdecl.ts, 19, 39)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) return a; >a : Symbol(a, Decl(funcdecl.ts, 19, 25)) diff --git a/tests/baselines/reference/functionConstraintSatisfaction.symbols b/tests/baselines/reference/functionConstraintSatisfaction.symbols index eb71bb78e25..969ac928374 100644 --- a/tests/baselines/reference/functionConstraintSatisfaction.symbols +++ b/tests/baselines/reference/functionConstraintSatisfaction.symbols @@ -4,7 +4,7 @@ function foo(x: T): T { return x; } >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0)) >T : Symbol(T, Decl(functionConstraintSatisfaction.ts, 2, 13)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 2, 33)) >T : Symbol(T, Decl(functionConstraintSatisfaction.ts, 2, 13)) >T : Symbol(T, Decl(functionConstraintSatisfaction.ts, 2, 13)) @@ -39,7 +39,7 @@ var c: { (): string; (x): string }; var r = foo(new Function()); >r : Symbol(r, Decl(functionConstraintSatisfaction.ts, 17, 3)) >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r1 = foo((x) => x); >r1 : Symbol(r1, Decl(functionConstraintSatisfaction.ts, 18, 3)) @@ -154,7 +154,7 @@ var r11 = foo((x: U) => x); >r11 : Symbol(r11, Decl(functionConstraintSatisfaction.ts, 42, 3)) >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 0, 0)) >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 42, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 42, 31)) >U : Symbol(U, Decl(functionConstraintSatisfaction.ts, 42, 15)) >x : Symbol(x, Decl(functionConstraintSatisfaction.ts, 42, 31)) @@ -192,7 +192,7 @@ var r16 = foo(c2); interface F2 extends Function { foo: string; } >F2 : Symbol(F2, Decl(functionConstraintSatisfaction.ts, 47, 18)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >foo : Symbol(foo, Decl(functionConstraintSatisfaction.ts, 49, 31)) var f2: F2; diff --git a/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.symbols b/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.symbols index cf504147346..4809c88d7fa 100644 --- a/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.symbols +++ b/tests/baselines/reference/functionDeclarationWithArgumentOfTypeFunctionTypeArray.symbols @@ -5,8 +5,8 @@ function foo(args: { (x): number }[]) { >x : Symbol(x, Decl(functionDeclarationWithArgumentOfTypeFunctionTypeArray.ts, 0, 22)) return args.length; ->args.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>args.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >args : Symbol(args, Decl(functionDeclarationWithArgumentOfTypeFunctionTypeArray.ts, 0, 13)) ->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols b/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols index db66aa5618b..5211ee999bf 100644 --- a/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols +++ b/tests/baselines/reference/functionExpressionAndLambdaMatchesFunction.symbols @@ -6,7 +6,7 @@ class CDoc { function doSomething(a: Function) { >doSomething : Symbol(doSomething, Decl(functionExpressionAndLambdaMatchesFunction.ts, 1, 23)) >a : Symbol(a, Decl(functionExpressionAndLambdaMatchesFunction.ts, 2, 29)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } doSomething(() => undefined); >doSomething : Symbol(doSomething, Decl(functionExpressionAndLambdaMatchesFunction.ts, 1, 23)) diff --git a/tests/baselines/reference/functionExpressionContextualTyping1.symbols b/tests/baselines/reference/functionExpressionContextualTyping1.symbols index 6182e4bb9a8..736fa86b9ca 100644 --- a/tests/baselines/reference/functionExpressionContextualTyping1.symbols +++ b/tests/baselines/reference/functionExpressionContextualTyping1.symbols @@ -18,9 +18,9 @@ var a0: (n: number, s: string) => number = (num, str) => { >str : Symbol(str, Decl(functionExpressionContextualTyping1.ts, 8, 48)) num.toExponential(); ->num.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>num.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) >num : Symbol(num, Decl(functionExpressionContextualTyping1.ts, 8, 44)) ->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) return 0; } @@ -37,7 +37,7 @@ var a1: (c: Class) => number = (a1) => { >a1 : Symbol(a1, Decl(functionExpressionContextualTyping1.ts, 17, 3)) >c : Symbol(c, Decl(functionExpressionContextualTyping1.ts, 17, 9)) >Class : Symbol(Class, Decl(functionExpressionContextualTyping1.ts, 11, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a1 : Symbol(a1, Decl(functionExpressionContextualTyping1.ts, 17, 40)) a1.foo(); diff --git a/tests/baselines/reference/functionImplementations.symbols b/tests/baselines/reference/functionImplementations.symbols index f9205f37650..3932261b27c 100644 --- a/tests/baselines/reference/functionImplementations.symbols +++ b/tests/baselines/reference/functionImplementations.symbols @@ -279,9 +279,9 @@ var f7: (x: number) => string | number = x => { // should be (x: number) => numb >x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) return x.toString(); ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>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, 134, 3)) diff --git a/tests/baselines/reference/functionOnlyHasThrow.symbols b/tests/baselines/reference/functionOnlyHasThrow.symbols index fc8d60a58be..43846067381 100644 --- a/tests/baselines/reference/functionOnlyHasThrow.symbols +++ b/tests/baselines/reference/functionOnlyHasThrow.symbols @@ -3,5 +3,5 @@ function clone():number { >clone : Symbol(clone, Decl(functionOnlyHasThrow.ts, 0, 0)) throw new Error("To be implemented"); ->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/functionOverloads7.types b/tests/baselines/reference/functionOverloads7.types index c57f042b354..7160068126f 100644 --- a/tests/baselines/reference/functionOverloads7.types +++ b/tests/baselines/reference/functionOverloads7.types @@ -21,7 +21,7 @@ class foo { >foo : any >this.bar() : any >this.bar : { (): any; (foo: string): any; } ->this : foo +>this : this >bar : { (): any; (foo: string): any; } foo = this.bar("test"); @@ -29,7 +29,7 @@ class foo { >foo : any >this.bar("test") : any >this.bar : { (): any; (foo: string): any; } ->this : foo +>this : this >bar : { (): any; (foo: string): any; } >"test" : string } diff --git a/tests/baselines/reference/functionOverloadsOnGenericArity2.symbols b/tests/baselines/reference/functionOverloadsOnGenericArity2.symbols index 93a56c86035..0dda3ba81a8 100644 --- a/tests/baselines/reference/functionOverloadsOnGenericArity2.symbols +++ b/tests/baselines/reference/functionOverloadsOnGenericArity2.symbols @@ -16,5 +16,5 @@ interface I { >U : Symbol(U, Decl(functionOverloadsOnGenericArity2.ts, 3, 9)) >T : Symbol(T, Decl(functionOverloadsOnGenericArity2.ts, 3, 11)) >p : Symbol(p, Decl(functionOverloadsOnGenericArity2.ts, 3, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/functionSubtypingOfVarArgs.symbols b/tests/baselines/reference/functionSubtypingOfVarArgs.symbols index 334766dc10c..3aa266ec030 100644 --- a/tests/baselines/reference/functionSubtypingOfVarArgs.symbols +++ b/tests/baselines/reference/functionSubtypingOfVarArgs.symbols @@ -11,11 +11,11 @@ class EventBase { >args : Symbol(args, Decl(functionSubtypingOfVarArgs.ts, 3, 19)) this._listeners.push(listener); ->this._listeners.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>this._listeners.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >this._listeners : Symbol(_listeners, Decl(functionSubtypingOfVarArgs.ts, 0, 17)) >this : Symbol(EventBase, Decl(functionSubtypingOfVarArgs.ts, 0, 0)) >_listeners : Symbol(_listeners, Decl(functionSubtypingOfVarArgs.ts, 0, 17)) ->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >listener : Symbol(listener, Decl(functionSubtypingOfVarArgs.ts, 3, 8)) } } diff --git a/tests/baselines/reference/functionSubtypingOfVarArgs.types b/tests/baselines/reference/functionSubtypingOfVarArgs.types index ebd706e94cf..ec48ff26c66 100644 --- a/tests/baselines/reference/functionSubtypingOfVarArgs.types +++ b/tests/baselines/reference/functionSubtypingOfVarArgs.types @@ -15,7 +15,7 @@ class EventBase { >this._listeners.push(listener) : number >this._listeners.push : (...items: any[]) => number >this._listeners : any[] ->this : EventBase +>this : this >_listeners : any[] >push : (...items: any[]) => number >listener : (...args: any[]) => void diff --git a/tests/baselines/reference/functionSubtypingOfVarArgs2.symbols b/tests/baselines/reference/functionSubtypingOfVarArgs2.symbols index 227264f9617..c2f77199e28 100644 --- a/tests/baselines/reference/functionSubtypingOfVarArgs2.symbols +++ b/tests/baselines/reference/functionSubtypingOfVarArgs2.symbols @@ -12,11 +12,11 @@ class EventBase { >args : Symbol(args, Decl(functionSubtypingOfVarArgs2.ts, 3, 19)) this._listeners.push(listener); ->this._listeners.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>this._listeners.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >this._listeners : Symbol(_listeners, Decl(functionSubtypingOfVarArgs2.ts, 0, 17)) >this : Symbol(EventBase, Decl(functionSubtypingOfVarArgs2.ts, 0, 0)) >_listeners : Symbol(_listeners, Decl(functionSubtypingOfVarArgs2.ts, 0, 17)) ->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >listener : Symbol(listener, Decl(functionSubtypingOfVarArgs2.ts, 3, 8)) } } diff --git a/tests/baselines/reference/functionSubtypingOfVarArgs2.types b/tests/baselines/reference/functionSubtypingOfVarArgs2.types index 5e2b14ffc7a..3aa5b7a7a00 100644 --- a/tests/baselines/reference/functionSubtypingOfVarArgs2.types +++ b/tests/baselines/reference/functionSubtypingOfVarArgs2.types @@ -16,7 +16,7 @@ class EventBase { >this._listeners.push(listener) : number >this._listeners.push : (...items: ((...args: any[]) => void)[]) => number >this._listeners : ((...args: any[]) => void)[] ->this : EventBase +>this : this >_listeners : ((...args: any[]) => void)[] >push : (...items: ((...args: any[]) => void)[]) => number >listener : (...args: any[]) => void diff --git a/tests/baselines/reference/functionType.symbols b/tests/baselines/reference/functionType.symbols index f972b6fc8a1..30a5a7cc447 100644 --- a/tests/baselines/reference/functionType.symbols +++ b/tests/baselines/reference/functionType.symbols @@ -3,12 +3,12 @@ function salt() {} >salt : Symbol(salt, Decl(functionType.ts, 0, 0)) salt.apply("hello", []); ->salt.apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20)) +>salt.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) >salt : Symbol(salt, Decl(functionType.ts, 0, 0)) ->apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20)) +>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) (new Function("return 5"))(); ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/functionsInClassExpressions.js b/tests/baselines/reference/functionsInClassExpressions.js new file mode 100644 index 00000000000..debd8138831 --- /dev/null +++ b/tests/baselines/reference/functionsInClassExpressions.js @@ -0,0 +1,25 @@ +//// [functionsInClassExpressions.ts] +let Foo = class { + constructor() { + this.bar++; + } + bar = 0; + inc = () => { + this.bar++; + } + m() { return this.bar; } +} + +//// [functionsInClassExpressions.js] +var Foo = (function () { + function class_1() { + var _this = this; + this.bar = 0; + this.inc = function () { + _this.bar++; + }; + this.bar++; + } + class_1.prototype.m = function () { return this.bar; }; + return class_1; +})(); diff --git a/tests/baselines/reference/functionsInClassExpressions.symbols b/tests/baselines/reference/functionsInClassExpressions.symbols new file mode 100644 index 00000000000..a1da3a3175c --- /dev/null +++ b/tests/baselines/reference/functionsInClassExpressions.symbols @@ -0,0 +1,27 @@ +=== tests/cases/compiler/functionsInClassExpressions.ts === +let Foo = class { +>Foo : Symbol(Foo, Decl(functionsInClassExpressions.ts, 0, 3)) + + constructor() { + this.bar++; +>this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) +>this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9)) +>bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) + } + bar = 0; +>bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) + + inc = () => { +>inc : Symbol((Anonymous class).inc, Decl(functionsInClassExpressions.ts, 4, 12)) + + this.bar++; +>this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) +>this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9)) +>bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) + } + m() { return this.bar; } +>m : Symbol((Anonymous class).m, Decl(functionsInClassExpressions.ts, 7, 5)) +>this.bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) +>this : Symbol((Anonymous class), Decl(functionsInClassExpressions.ts, 0, 9)) +>bar : Symbol((Anonymous class).bar, Decl(functionsInClassExpressions.ts, 3, 5)) +} diff --git a/tests/baselines/reference/functionsInClassExpressions.types b/tests/baselines/reference/functionsInClassExpressions.types new file mode 100644 index 00000000000..ee4b5696cc1 --- /dev/null +++ b/tests/baselines/reference/functionsInClassExpressions.types @@ -0,0 +1,32 @@ +=== tests/cases/compiler/functionsInClassExpressions.ts === +let Foo = class { +>Foo : typeof (Anonymous class) +>class { constructor() { this.bar++; } bar = 0; inc = () => { this.bar++; } m() { return this.bar; }} : typeof (Anonymous class) + + constructor() { + this.bar++; +>this.bar++ : number +>this.bar : number +>this : this +>bar : number + } + bar = 0; +>bar : number +>0 : number + + inc = () => { +>inc : () => void +>() => { this.bar++; } : () => void + + this.bar++; +>this.bar++ : number +>this.bar : number +>this : this +>bar : number + } + m() { return this.bar; } +>m : () => number +>this.bar : number +>this : this +>bar : number +} diff --git a/tests/baselines/reference/functionsWithModifiersInBlocks1.errors.txt b/tests/baselines/reference/functionsWithModifiersInBlocks1.errors.txt index f6240f5e697..e3137740937 100644 --- a/tests/baselines/reference/functionsWithModifiersInBlocks1.errors.txt +++ b/tests/baselines/reference/functionsWithModifiersInBlocks1.errors.txt @@ -1,11 +1,11 @@ tests/cases/compiler/functionsWithModifiersInBlocks1.ts(2,4): error TS1184: Modifiers cannot appear here. tests/cases/compiler/functionsWithModifiersInBlocks1.ts(2,21): error TS2393: Duplicate function implementation. -tests/cases/compiler/functionsWithModifiersInBlocks1.ts(2,25): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/functionsWithModifiersInBlocks1.ts(2,25): error TS1183: An implementation cannot be declared in ambient contexts. tests/cases/compiler/functionsWithModifiersInBlocks1.ts(3,4): error TS1184: Modifiers cannot appear here. tests/cases/compiler/functionsWithModifiersInBlocks1.ts(3,20): error TS2393: Duplicate function implementation. tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,4): error TS1184: Modifiers cannot appear here. tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,28): error TS2393: Duplicate function implementation. -tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,32): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,32): error TS1183: An implementation cannot be declared in ambient contexts. ==== tests/cases/compiler/functionsWithModifiersInBlocks1.ts (8 errors) ==== @@ -16,7 +16,7 @@ tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,32): error TS1184: An ~ !!! error TS2393: Duplicate function implementation. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export function f() { } ~~~~~~ !!! error TS1184: Modifiers cannot appear here. @@ -28,5 +28,5 @@ tests/cases/compiler/functionsWithModifiersInBlocks1.ts(4,32): error TS1184: An ~ !!! error TS2393: Duplicate function implementation. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } \ No newline at end of file diff --git a/tests/baselines/reference/fuzzy.errors.txt b/tests/baselines/reference/fuzzy.errors.txt index 699841f8870..72ac4c816f9 100644 --- a/tests/baselines/reference/fuzzy.errors.txt +++ b/tests/baselines/reference/fuzzy.errors.txt @@ -1,10 +1,11 @@ tests/cases/compiler/fuzzy.ts(13,18): error TS2420: Class 'C' incorrectly implements interface 'I'. Property 'alsoWorks' is missing in type 'C'. -tests/cases/compiler/fuzzy.ts(21,20): error TS2322: Type '{ anything: number; oneI: C; }' is not assignable to type 'R'. +tests/cases/compiler/fuzzy.ts(21,20): error TS2322: Type '{ anything: number; oneI: this; }' is not assignable to type 'R'. Types of property 'oneI' are incompatible. - Type 'C' is not assignable to type 'I'. -tests/cases/compiler/fuzzy.ts(25,20): error TS2352: Neither type '{ oneI: C; }' nor type 'R' is assignable to the other. - Property 'anything' is missing in type '{ oneI: C; }'. + Type 'this' is not assignable to type 'I'. + Type 'C' is not assignable to type 'I'. +tests/cases/compiler/fuzzy.ts(25,20): error TS2352: Neither type '{ oneI: this; }' nor type 'R' is assignable to the other. + Property 'anything' is missing in type '{ oneI: this; }'. ==== tests/cases/compiler/fuzzy.ts (3 errors) ==== @@ -33,16 +34,17 @@ tests/cases/compiler/fuzzy.ts(25,20): error TS2352: Neither type '{ oneI: C; }' doesntWork():R { return { anything:1, oneI:this }; ~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2322: Type '{ anything: number; oneI: C; }' is not assignable to type 'R'. +!!! error TS2322: Type '{ anything: number; oneI: this; }' is not assignable to type 'R'. !!! error TS2322: Types of property 'oneI' are incompatible. -!!! error TS2322: Type 'C' is not assignable to type 'I'. +!!! error TS2322: Type 'this' is not assignable to type 'I'. +!!! error TS2322: Type 'C' is not assignable to type 'I'. } worksToo():R { return ({ oneI: this }); ~~~~~~~~~~~~~~~~~~~ -!!! error TS2352: Neither type '{ oneI: C; }' nor type 'R' is assignable to the other. -!!! error TS2352: Property 'anything' is missing in type '{ oneI: C; }'. +!!! error TS2352: Neither type '{ oneI: this; }' nor type 'R' is assignable to the other. +!!! error TS2352: Property 'anything' is missing in type '{ oneI: this; }'. } } } diff --git a/tests/baselines/reference/generatedContextualTyping.symbols b/tests/baselines/reference/generatedContextualTyping.symbols index 287b7be66d0..df0bb33e02f 100644 --- a/tests/baselines/reference/generatedContextualTyping.symbols +++ b/tests/baselines/reference/generatedContextualTyping.symbols @@ -74,7 +74,7 @@ var x7: Base[] = [d1, d2]; var x8: Array = [d1, d2]; >x8 : Symbol(x8, Decl(generatedContextualTyping.ts, 12, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -165,7 +165,7 @@ class x19 { member: Base[] = [d1, d2] } class x20 { member: Array = [d1, d2] } >x20 : Symbol(x20, Decl(generatedContextualTyping.ts, 23, 39)) >member : Symbol(member, Decl(generatedContextualTyping.ts, 24, 11)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -260,7 +260,7 @@ class x31 { private member: Base[] = [d1, d2] } class x32 { private member: Array = [d1, d2] } >x32 : Symbol(x32, Decl(generatedContextualTyping.ts, 35, 47)) >member : Symbol(member, Decl(generatedContextualTyping.ts, 36, 11)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -355,7 +355,7 @@ class x43 { public member: Base[] = [d1, d2] } class x44 { public member: Array = [d1, d2] } >x44 : Symbol(x44, Decl(generatedContextualTyping.ts, 47, 46)) >member : Symbol(member, Decl(generatedContextualTyping.ts, 48, 11)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -450,7 +450,7 @@ class x55 { static member: Base[] = [d1, d2] } class x56 { static member: Array = [d1, d2] } >x56 : Symbol(x56, Decl(generatedContextualTyping.ts, 59, 46)) >member : Symbol(x56.member, Decl(generatedContextualTyping.ts, 60, 11)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -545,7 +545,7 @@ class x67 { private static member: Base[] = [d1, d2] } class x68 { private static member: Array = [d1, d2] } >x68 : Symbol(x68, Decl(generatedContextualTyping.ts, 71, 54)) >member : Symbol(x68.member, Decl(generatedContextualTyping.ts, 72, 11)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -640,7 +640,7 @@ class x79 { public static member: Base[] = [d1, d2] } class x80 { public static member: Array = [d1, d2] } >x80 : Symbol(x80, Decl(generatedContextualTyping.ts, 83, 53)) >member : Symbol(x80.member, Decl(generatedContextualTyping.ts, 84, 11)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -735,7 +735,7 @@ class x91 { constructor(parm: Base[] = [d1, d2]) { } } class x92 { constructor(parm: Array = [d1, d2]) { } } >x92 : Symbol(x92, Decl(generatedContextualTyping.ts, 95, 54)) >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 96, 24)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -830,7 +830,7 @@ class x103 { constructor(public parm: Base[] = [d1, d2]) { } } class x104 { constructor(public parm: Array = [d1, d2]) { } } >x104 : Symbol(x104, Decl(generatedContextualTyping.ts, 107, 62)) >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 108, 25)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -925,7 +925,7 @@ class x115 { constructor(private parm: Base[] = [d1, d2]) { } } class x116 { constructor(private parm: Array = [d1, d2]) { } } >x116 : Symbol(x116, Decl(generatedContextualTyping.ts, 119, 63)) >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 120, 25)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -1020,7 +1020,7 @@ function x127(parm: Base[] = [d1, d2]) { } function x128(parm: Array = [d1, d2]) { } >x128 : Symbol(x128, Decl(generatedContextualTyping.ts, 131, 42)) >parm : Symbol(parm, Decl(generatedContextualTyping.ts, 132, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -1107,7 +1107,7 @@ function x139(): Base[] { return [d1, d2]; } function x140(): Array { return [d1, d2]; } >x140 : Symbol(x140, Decl(generatedContextualTyping.ts, 143, 44)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -1206,7 +1206,7 @@ function x151(): Base[] { return [d1, d2]; return [d1, d2]; } function x152(): Array { return [d1, d2]; return [d1, d2]; } >x152 : Symbol(x152, Decl(generatedContextualTyping.ts, 155, 61)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -1303,7 +1303,7 @@ var x163: () => Base[] = () => { return [d1, d2]; }; var x164: () => Array = () => { return [d1, d2]; }; >x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 168, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -1386,7 +1386,7 @@ var x175: () => Base[] = function() { return [d1, d2]; }; var x176: () => Array = function() { return [d1, d2]; }; >x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 180, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -1477,7 +1477,7 @@ module x187 { var t: Base[] = [d1, d2]; } module x188 { var t: Array = [d1, d2]; } >x188 : Symbol(x188, Decl(generatedContextualTyping.ts, 191, 41)) >t : Symbol(t, Decl(generatedContextualTyping.ts, 192, 17)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -1572,7 +1572,7 @@ module x199 { export var t: Base[] = [d1, d2]; } module x200 { export var t: Array = [d1, d2]; } >x200 : Symbol(x200, Decl(generatedContextualTyping.ts, 203, 48)) >t : Symbol(t, Decl(generatedContextualTyping.ts, 204, 24)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -1647,7 +1647,7 @@ var x211 = [d1, d2]; var x212 = >[d1, d2]; >x212 : Symbol(x212, Decl(generatedContextualTyping.ts, 214, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -1715,7 +1715,7 @@ var x221 = (undefined) || [d1, d2]; var x222 = (>undefined) || [d1, d2]; >x222 : Symbol(x222, Decl(generatedContextualTyping.ts, 223, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>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, 4, 19)) @@ -1791,7 +1791,7 @@ var x231: Base[]; x231 = [d1, d2]; var x232: Array; x232 = [d1, d2]; >x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 233, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>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, 233, 3)) >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) @@ -1894,7 +1894,7 @@ var x243: { n: Base[]; } = { n: [d1, d2] }; var x244: { n: Array; } = { n: [d1, d2] }; >x244 : Symbol(x244, Decl(generatedContextualTyping.ts, 245, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 11)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 245, 33)) >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) @@ -1967,7 +1967,7 @@ var x255: Base[][] = [[d1, d2]]; var x256: Array[] = [[d1, d2]]; >x256 : Symbol(x256, Decl(generatedContextualTyping.ts, 254, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -2035,7 +2035,7 @@ var x265: Base[] = [d1, d2] || undefined; var x266: Array = [d1, d2] || undefined; >x266 : Symbol(x266, Decl(generatedContextualTyping.ts, 263, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -2097,7 +2097,7 @@ var x273: Base[] = undefined || [d1, d2]; var x274: Array = undefined || [d1, d2]; >x274 : Symbol(x274, Decl(generatedContextualTyping.ts, 271, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>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, 4, 19)) @@ -2166,7 +2166,7 @@ var x281: Base[] = [d1, d2] || [d1, d2]; var x282: Array = [d1, d2] || [d1, d2]; >x282 : Symbol(x282, Decl(generatedContextualTyping.ts, 279, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -2255,7 +2255,7 @@ var x291: Base[] = true ? [d1, d2] : [d1, d2]; var x292: Array = true ? [d1, d2] : [d1, d2]; >x292 : Symbol(x292, Decl(generatedContextualTyping.ts, 289, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -2359,7 +2359,7 @@ var x303: Base[] = true ? undefined : [d1, d2]; var x304: Array = true ? undefined : [d1, d2]; >x304 : Symbol(x304, Decl(generatedContextualTyping.ts, 301, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>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, 4, 19)) @@ -2454,7 +2454,7 @@ var x315: Base[] = true ? [d1, d2] : undefined; var x316: Array = true ? [d1, d2] : undefined; >x316 : Symbol(x316, Decl(generatedContextualTyping.ts, 313, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 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, 4, 19)) >d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) @@ -2557,7 +2557,7 @@ function x327(n: Base[]) { }; x327([d1, d2]); function x328(n: Array) { }; x328([d1, d2]); >x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 324, 45)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 325, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>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, 324, 45)) >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) @@ -2671,7 +2671,7 @@ var x339 = (n: Base[]) => n; x339([d1, d2]); 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, 1000, 23), Decl(lib.d.ts, 1171, 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, 337, 12)) >x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3)) @@ -2783,7 +2783,7 @@ var x351 = function(n: Base[]) { }; x351([d1, d2]); var x352 = function(n: Array) { }; x352([d1, d2]); >x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>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, 349, 3)) >d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) diff --git a/tests/baselines/reference/generatorES6_6.symbols b/tests/baselines/reference/generatorES6_6.symbols index f424048eeec..96b8b861c8b 100644 --- a/tests/baselines/reference/generatorES6_6.symbols +++ b/tests/baselines/reference/generatorES6_6.symbols @@ -3,9 +3,9 @@ class C { >C : Symbol(C, Decl(generatorES6_6.ts, 0, 0)) *[Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) let a = yield 1; >a : Symbol(a, Decl(generatorES6_6.ts, 2, 7)) diff --git a/tests/baselines/reference/generatorOverloads4.symbols b/tests/baselines/reference/generatorOverloads4.symbols index 233af97ee59..341ba9c4a0d 100644 --- a/tests/baselines/reference/generatorOverloads4.symbols +++ b/tests/baselines/reference/generatorOverloads4.symbols @@ -5,15 +5,15 @@ class C { f(s: string): Iterable; >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32)) >s : Symbol(s, Decl(generatorOverloads4.ts, 1, 6)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) f(s: number): Iterable; >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32)) >s : Symbol(s, Decl(generatorOverloads4.ts, 2, 6)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) *f(s: any): Iterable { } >f : Symbol(f, Decl(generatorOverloads4.ts, 0, 9), Decl(generatorOverloads4.ts, 1, 32), Decl(generatorOverloads4.ts, 2, 32)) >s : Symbol(s, Decl(generatorOverloads4.ts, 3, 7)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/generatorOverloads5.symbols b/tests/baselines/reference/generatorOverloads5.symbols index e3b14d76cd0..07de0c87f51 100644 --- a/tests/baselines/reference/generatorOverloads5.symbols +++ b/tests/baselines/reference/generatorOverloads5.symbols @@ -5,15 +5,15 @@ module M { function f(s: string): Iterable; >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41)) >s : Symbol(s, Decl(generatorOverloads5.ts, 1, 15)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) function f(s: number): Iterable; >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41)) >s : Symbol(s, Decl(generatorOverloads5.ts, 2, 15)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) function* f(s: any): Iterable { } >f : Symbol(f, Decl(generatorOverloads5.ts, 0, 10), Decl(generatorOverloads5.ts, 1, 41), Decl(generatorOverloads5.ts, 2, 41)) >s : Symbol(s, Decl(generatorOverloads5.ts, 3, 16)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/generatorTypeCheck1.symbols b/tests/baselines/reference/generatorTypeCheck1.symbols index 3353182c7db..b9456ccba48 100644 --- a/tests/baselines/reference/generatorTypeCheck1.symbols +++ b/tests/baselines/reference/generatorTypeCheck1.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck1.ts === function* g1(): Iterator { } >g1 : Symbol(g1, Decl(generatorTypeCheck1.ts, 0, 0)) ->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4390, 1)) +>Iterator : Symbol(Iterator, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/generatorTypeCheck10.symbols b/tests/baselines/reference/generatorTypeCheck10.symbols index 9dc3d726f8d..2112a9b1ebc 100644 --- a/tests/baselines/reference/generatorTypeCheck10.symbols +++ b/tests/baselines/reference/generatorTypeCheck10.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck10.ts === function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck10.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --)) return; } diff --git a/tests/baselines/reference/generatorTypeCheck11.symbols b/tests/baselines/reference/generatorTypeCheck11.symbols index fabd19cd199..439b97caa7f 100644 --- a/tests/baselines/reference/generatorTypeCheck11.symbols +++ b/tests/baselines/reference/generatorTypeCheck11.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck11.ts === function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck11.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --)) return 0; } diff --git a/tests/baselines/reference/generatorTypeCheck12.symbols b/tests/baselines/reference/generatorTypeCheck12.symbols index 4fe733933bb..1c7661a06cf 100644 --- a/tests/baselines/reference/generatorTypeCheck12.symbols +++ b/tests/baselines/reference/generatorTypeCheck12.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck12.ts === function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck12.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --)) return ""; } diff --git a/tests/baselines/reference/generatorTypeCheck13.symbols b/tests/baselines/reference/generatorTypeCheck13.symbols index 8a720da6ee5..7d9587e5ac9 100644 --- a/tests/baselines/reference/generatorTypeCheck13.symbols +++ b/tests/baselines/reference/generatorTypeCheck13.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck13.ts === function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck13.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --)) yield 0; return ""; diff --git a/tests/baselines/reference/generatorTypeCheck17.symbols b/tests/baselines/reference/generatorTypeCheck17.symbols index 28c4bb60055..523579dd47b 100644 --- a/tests/baselines/reference/generatorTypeCheck17.symbols +++ b/tests/baselines/reference/generatorTypeCheck17.symbols @@ -10,7 +10,7 @@ class Bar extends Foo { y: string } function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck17.ts, 1, 35)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(generatorTypeCheck17.ts, 0, 0)) yield; diff --git a/tests/baselines/reference/generatorTypeCheck19.symbols b/tests/baselines/reference/generatorTypeCheck19.symbols index 0c6bbbb462e..b74b5f727a6 100644 --- a/tests/baselines/reference/generatorTypeCheck19.symbols +++ b/tests/baselines/reference/generatorTypeCheck19.symbols @@ -10,7 +10,7 @@ class Bar extends Foo { y: string } function* g(): IterableIterator { >g : Symbol(g, Decl(generatorTypeCheck19.ts, 1, 35)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(generatorTypeCheck19.ts, 0, 0)) yield; diff --git a/tests/baselines/reference/generatorTypeCheck2.symbols b/tests/baselines/reference/generatorTypeCheck2.symbols index 99d9a0f0505..5741e089d1b 100644 --- a/tests/baselines/reference/generatorTypeCheck2.symbols +++ b/tests/baselines/reference/generatorTypeCheck2.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck2.ts === function* g1(): Iterable { } >g1 : Symbol(g1, Decl(generatorTypeCheck2.ts, 0, 0)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/generatorTypeCheck26.symbols b/tests/baselines/reference/generatorTypeCheck26.symbols index f2c13cf6199..2f2c27d2810 100644 --- a/tests/baselines/reference/generatorTypeCheck26.symbols +++ b/tests/baselines/reference/generatorTypeCheck26.symbols @@ -1,20 +1,20 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck26.ts === function* g(): IterableIterator<(x: string) => number> { >g : Symbol(g, Decl(generatorTypeCheck26.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck26.ts, 0, 33)) yield x => x.length; >x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck26.ts, 1, 9)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) yield *[x => x.length]; >x : Symbol(x, Decl(generatorTypeCheck26.ts, 2, 12)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck26.ts, 2, 12)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) return x => x.length; >x : Symbol(x, Decl(generatorTypeCheck26.ts, 3, 10)) diff --git a/tests/baselines/reference/generatorTypeCheck27.symbols b/tests/baselines/reference/generatorTypeCheck27.symbols index e05147aa4b5..27c5cbf5db8 100644 --- a/tests/baselines/reference/generatorTypeCheck27.symbols +++ b/tests/baselines/reference/generatorTypeCheck27.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck27.ts === function* g(): IterableIterator<(x: string) => number> { >g : Symbol(g, Decl(generatorTypeCheck27.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck27.ts, 0, 33)) yield * function* () { diff --git a/tests/baselines/reference/generatorTypeCheck28.symbols b/tests/baselines/reference/generatorTypeCheck28.symbols index b157d464292..a7e799679d7 100644 --- a/tests/baselines/reference/generatorTypeCheck28.symbols +++ b/tests/baselines/reference/generatorTypeCheck28.symbols @@ -1,20 +1,20 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck28.ts === function* g(): IterableIterator<(x: string) => number> { >g : Symbol(g, Decl(generatorTypeCheck28.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck28.ts, 0, 33)) yield * { *[Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) yield x => x.length; >x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck28.ts, 3, 17)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } }; } diff --git a/tests/baselines/reference/generatorTypeCheck29.symbols b/tests/baselines/reference/generatorTypeCheck29.symbols index 54a5cc0fdb6..4b332f6c86b 100644 --- a/tests/baselines/reference/generatorTypeCheck29.symbols +++ b/tests/baselines/reference/generatorTypeCheck29.symbols @@ -1,8 +1,8 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck29.ts === function* g2(): Iterator number>> { >g2 : Symbol(g2, Decl(generatorTypeCheck29.ts, 0, 0)) ->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4390, 1)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterator : Symbol(Iterator, Decl(lib.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck29.ts, 0, 35)) yield function* () { diff --git a/tests/baselines/reference/generatorTypeCheck3.symbols b/tests/baselines/reference/generatorTypeCheck3.symbols index 5fdef53c6f3..6e97cd6f280 100644 --- a/tests/baselines/reference/generatorTypeCheck3.symbols +++ b/tests/baselines/reference/generatorTypeCheck3.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck3.ts === function* g1(): IterableIterator { } >g1 : Symbol(g1, Decl(generatorTypeCheck3.ts, 0, 0)) ->IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, 4400, 1)) +>IterableIterator : Symbol(IterableIterator, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/generatorTypeCheck30.symbols b/tests/baselines/reference/generatorTypeCheck30.symbols index d107c4bde19..3c56fde9039 100644 --- a/tests/baselines/reference/generatorTypeCheck30.symbols +++ b/tests/baselines/reference/generatorTypeCheck30.symbols @@ -1,8 +1,8 @@ === tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck30.ts === function* g2(): Iterator number>> { >g2 : Symbol(g2, Decl(generatorTypeCheck30.ts, 0, 0)) ->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4390, 1)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterator : Symbol(Iterator, Decl(lib.d.ts, --, --)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck30.ts, 0, 35)) yield function* () { diff --git a/tests/baselines/reference/generatorTypeCheck39.js b/tests/baselines/reference/generatorTypeCheck39.js index e6d25045a7e..43df3b8e205 100644 --- a/tests/baselines/reference/generatorTypeCheck39.js +++ b/tests/baselines/reference/generatorTypeCheck39.js @@ -11,12 +11,10 @@ function* g() { //// [generatorTypeCheck39.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; function decorator(x) { return y => { }; diff --git a/tests/baselines/reference/generatorTypeCheck45.symbols b/tests/baselines/reference/generatorTypeCheck45.symbols index bb24ffb1eb6..a637f154dc4 100644 --- a/tests/baselines/reference/generatorTypeCheck45.symbols +++ b/tests/baselines/reference/generatorTypeCheck45.symbols @@ -6,7 +6,7 @@ declare function foo(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 27)) >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21)) >fun : Symbol(fun, Decl(generatorTypeCheck45.ts, 0, 32)) ->Iterator : Symbol(Iterator, Decl(lib.d.ts, 4390, 1)) +>Iterator : Symbol(Iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck45.ts, 0, 54)) >T : Symbol(T, Decl(generatorTypeCheck45.ts, 0, 21)) >U : Symbol(U, Decl(generatorTypeCheck45.ts, 0, 23)) @@ -19,9 +19,9 @@ declare function foo(x: T, fun: () => Iterator<(x: T) => U>, fun2: (y: U) foo("", function* () { yield x => x.length }, p => undefined); // T is fixed, should be string >foo : Symbol(foo, Decl(generatorTypeCheck45.ts, 0, 0)) >x : Symbol(x, Decl(generatorTypeCheck45.ts, 2, 28)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck45.ts, 2, 28)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >p : Symbol(p, Decl(generatorTypeCheck45.ts, 2, 45)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/generatorTypeCheck46.symbols b/tests/baselines/reference/generatorTypeCheck46.symbols index a6dd01be70f..abb170b12a7 100644 --- a/tests/baselines/reference/generatorTypeCheck46.symbols +++ b/tests/baselines/reference/generatorTypeCheck46.symbols @@ -6,7 +6,7 @@ declare function foo(x: T, fun: () => Iterable<(x: T) => U>, fun2: (y: U) >x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 27)) >T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21)) >fun : Symbol(fun, Decl(generatorTypeCheck46.ts, 0, 32)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck46.ts, 0, 54)) >T : Symbol(T, Decl(generatorTypeCheck46.ts, 0, 21)) >U : Symbol(U, Decl(generatorTypeCheck46.ts, 0, 23)) @@ -21,15 +21,15 @@ foo("", function* () { yield* { *[Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) yield x => x.length >x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(generatorTypeCheck46.ts, 5, 17)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } } }, p => undefined); // T is fixed, should be string diff --git a/tests/baselines/reference/generatorTypeCheck59.js b/tests/baselines/reference/generatorTypeCheck59.js index 5b3b70386f8..8fd32e7730a 100644 --- a/tests/baselines/reference/generatorTypeCheck59.js +++ b/tests/baselines/reference/generatorTypeCheck59.js @@ -8,20 +8,17 @@ function* g() { //// [generatorTypeCheck59.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; function* g() { class C { m() { } } - Object.defineProperty(C.prototype, "m", - __decorate([ - (yield "") - ], C.prototype, "m", Object.getOwnPropertyDescriptor(C.prototype, "m"))); + __decorate([ + (yield "") + ], C.prototype, "m", null); ; } diff --git a/tests/baselines/reference/generatorTypeCheck61.js b/tests/baselines/reference/generatorTypeCheck61.js index 9e2f067f9fb..b2434ee590c 100644 --- a/tests/baselines/reference/generatorTypeCheck61.js +++ b/tests/baselines/reference/generatorTypeCheck61.js @@ -6,12 +6,10 @@ function * g() { //// [generatorTypeCheck61.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; function* g() { let C = class { diff --git a/tests/baselines/reference/genericArray1.symbols b/tests/baselines/reference/genericArray1.symbols index b403bd2b720..b73872b8d55 100644 --- a/tests/baselines/reference/genericArray1.symbols +++ b/tests/baselines/reference/genericArray1.symbols @@ -13,10 +13,10 @@ interface String{ var lengths = ["a", "b", "c"].map(x => x.length); >lengths : Symbol(lengths, Decl(genericArray1.ts, 12, 3)) ->["a", "b", "c"].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>["a", "b", "c"].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(genericArray1.ts, 12, 34)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(genericArray1.ts, 12, 34)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/genericBaseClassLiteralProperty.types b/tests/baselines/reference/genericBaseClassLiteralProperty.types index 87f1c55c42d..69468f9b679 100644 --- a/tests/baselines/reference/genericBaseClassLiteralProperty.types +++ b/tests/baselines/reference/genericBaseClassLiteralProperty.types @@ -23,14 +23,14 @@ class SubClass extends BaseClass { >x : number >this._getValue1() : number >this._getValue1 : () => number ->this : SubClass +>this : this >_getValue1 : () => number var y : number = this._getValue2(); >y : number >this._getValue2() : number >this._getValue2 : () => number ->this : SubClass +>this : this >_getValue2 : () => number } } diff --git a/tests/baselines/reference/genericBaseClassLiteralProperty2.types b/tests/baselines/reference/genericBaseClassLiteralProperty2.types index 271aa190037..d7d512165f0 100644 --- a/tests/baselines/reference/genericBaseClassLiteralProperty2.types +++ b/tests/baselines/reference/genericBaseClassLiteralProperty2.types @@ -16,7 +16,7 @@ class BaseCollection2 { this._itemsByKey = {}; >this._itemsByKey = {} : { [x: string]: undefined; } >this._itemsByKey : { [key: string]: TItem; } ->this : BaseCollection2 +>this : this >_itemsByKey : { [key: string]: TItem; } >{} : { [x: string]: undefined; } } @@ -36,7 +36,7 @@ class DataView2 extends BaseCollection2 { >this._itemsByKey['dummy'] = item : CollectionItem2 >this._itemsByKey['dummy'] : CollectionItem2 >this._itemsByKey : { [key: string]: CollectionItem2; } ->this : DataView2 +>this : this >_itemsByKey : { [key: string]: CollectionItem2; } >'dummy' : string >item : CollectionItem2 diff --git a/tests/baselines/reference/genericCallWithArrayLiteralArgs.symbols b/tests/baselines/reference/genericCallWithArrayLiteralArgs.symbols index 49ccf7ad595..e7a52c5e264 100644 --- a/tests/baselines/reference/genericCallWithArrayLiteralArgs.symbols +++ b/tests/baselines/reference/genericCallWithArrayLiteralArgs.symbols @@ -40,5 +40,5 @@ var r5 = foo([1, '']); // any[] var r6 = foo([1, '']); // Object[] >r6 : Symbol(r6, Decl(genericCallWithArrayLiteralArgs.ts, 11, 3)) >foo : Symbol(foo, Decl(genericCallWithArrayLiteralArgs.ts, 0, 0)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexers.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexers.symbols index 14a91401efb..3824029dfec 100644 --- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexers.symbols +++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndIndexers.symbols @@ -16,11 +16,11 @@ var a: { [x: string]: Object; >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 7, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [x: number]: Date; >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 8, 5)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) }; var r = foo(a); @@ -31,7 +31,7 @@ var r = foo(a); function other(arg: T) { >other : Symbol(other, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 10, 15)) >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 12, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 12, 31)) >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 12, 15)) @@ -40,7 +40,7 @@ function other(arg: T) { [x: string]: Object; >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 14, 9)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [x: number]: T >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndIndexers.ts, 15, 9)) diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndNumericIndexer.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgsAndNumericIndexer.symbols index 77787e77299..4e7622d3d81 100644 --- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndNumericIndexer.symbols +++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndNumericIndexer.symbols @@ -14,7 +14,7 @@ function foo(x: T) { var a: { [x: number]: Date }; >a : Symbol(a, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 6, 3)) >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 6, 10)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r = foo(a); >r : Symbol(r, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 7, 3)) @@ -41,7 +41,7 @@ function other(arg: T) { function other2(arg: T) { >other2 : Symbol(other2, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 12, 1)) >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 14, 16)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 14, 32)) >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 14, 16)) @@ -63,9 +63,9 @@ function other2(arg: T) { function other3(arg: T) { >other3 : Symbol(other3, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 18, 1)) >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 20, 16)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >U : Symbol(U, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 20, 31)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 20, 48)) >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndNumericIndexer.ts, 20, 16)) diff --git a/tests/baselines/reference/genericCallWithObjectTypeArgsAndStringIndexer.symbols b/tests/baselines/reference/genericCallWithObjectTypeArgsAndStringIndexer.symbols index 62b7c82b8e3..932cedf148e 100644 --- a/tests/baselines/reference/genericCallWithObjectTypeArgsAndStringIndexer.symbols +++ b/tests/baselines/reference/genericCallWithObjectTypeArgsAndStringIndexer.symbols @@ -14,7 +14,7 @@ function foo(x: T) { var a: { [x: string]: Date }; >a : Symbol(a, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 6, 3)) >x : Symbol(x, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 6, 10)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r = foo(a); >r : Symbol(r, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 7, 3)) @@ -41,7 +41,7 @@ function other(arg: T) { function other2(arg: T) { >other2 : Symbol(other2, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 12, 1)) >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 14, 16)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 14, 32)) >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 14, 16)) @@ -57,16 +57,16 @@ function other2(arg: T) { var d: Date = r2['hm']; // ok >d : Symbol(d, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 17, 7)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >r2 : Symbol(r2, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 16, 7)) } function other3(arg: T) { >other3 : Symbol(other3, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 18, 1)) >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 20, 16)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >U : Symbol(U, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 20, 31)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >arg : Symbol(arg, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 20, 48)) >T : Symbol(T, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 20, 16)) @@ -82,7 +82,7 @@ function other3(arg: T) { var d: Date = r2['hm']; // ok >d : Symbol(d, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 23, 7)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >r2 : Symbol(r2, Decl(genericCallWithObjectTypeArgsAndStringIndexer.ts, 22, 7)) // BUG 821629 diff --git a/tests/baselines/reference/genericClassWithStaticFactory.symbols b/tests/baselines/reference/genericClassWithStaticFactory.symbols index 37ee9c638e9..47b7f5f736b 100644 --- a/tests/baselines/reference/genericClassWithStaticFactory.symbols +++ b/tests/baselines/reference/genericClassWithStaticFactory.symbols @@ -52,23 +52,23 @@ module Editor { >data : Symbol(data, Decl(genericClassWithStaticFactory.ts, 12, 19)) this.prev.next = entry; ->this.prev.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>this.prev.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) >prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 13, 15)) entry.next = this; ->entry.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>entry.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 13, 15)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) entry.prev = this.prev; ->entry.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>entry.prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 13, 15)) ->prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >this.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) >prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) @@ -102,16 +102,16 @@ module Editor { for (i = 0; !(entry.isHead); i++) { >i : Symbol(i, Decl(genericClassWithStaticFactory.ts, 24, 15)) ->entry.isHead : Symbol(isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) +>entry.isHead : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 23, 15)) ->isHead : Symbol(isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) +>isHead : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) >i : Symbol(i, Decl(genericClassWithStaticFactory.ts, 24, 15)) entry = entry.next; >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 23, 15)) ->entry.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>entry.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 23, 15)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) } return (i); @@ -138,11 +138,11 @@ module Editor { >isEmpty : Symbol(isEmpty, Decl(genericClassWithStaticFactory.ts, 32, 9)) { return this.next.data; ->this.next.data : Symbol(data, Decl(genericClassWithStaticFactory.ts, 7, 43)) +>this.next.data : Symbol(List.data, Decl(genericClassWithStaticFactory.ts, 7, 43)) >this.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) >next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) ->data : Symbol(data, Decl(genericClassWithStaticFactory.ts, 7, 43)) +>data : Symbol(List.data, Decl(genericClassWithStaticFactory.ts, 7, 43)) } else { return null; @@ -156,22 +156,22 @@ module Editor { >T : Symbol(T, Decl(genericClassWithStaticFactory.ts, 2, 22)) entry.isHead = false; ->entry.isHead : Symbol(isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) +>entry.isHead : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 48, 25)) ->isHead : Symbol(isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) +>isHead : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) entry.next = this.next; ->entry.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>entry.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 48, 25)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) >next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) entry.prev = this; ->entry.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>entry.prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 48, 25)) ->prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) this.next = entry; @@ -181,11 +181,11 @@ module Editor { >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 48, 25)) entry.next.prev = entry; // entry.next.prev does not show intellisense, but entry.prev.prev does ->entry.next.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) ->entry.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>entry.next.prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>entry.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 48, 25)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) ->prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 48, 25)) } @@ -204,28 +204,28 @@ module Editor { >data : Symbol(data, Decl(genericClassWithStaticFactory.ts, 56, 20)) entry.data = data; ->entry.data : Symbol(data, Decl(genericClassWithStaticFactory.ts, 7, 43)) +>entry.data : Symbol(List.data, Decl(genericClassWithStaticFactory.ts, 7, 43)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 57, 15)) ->data : Symbol(data, Decl(genericClassWithStaticFactory.ts, 7, 43)) +>data : Symbol(List.data, Decl(genericClassWithStaticFactory.ts, 7, 43)) >data : Symbol(data, Decl(genericClassWithStaticFactory.ts, 56, 20)) entry.isHead = false; ->entry.isHead : Symbol(isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) +>entry.isHead : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 57, 15)) ->isHead : Symbol(isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) +>isHead : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) entry.next = this.next; ->entry.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>entry.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 57, 15)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) >next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) entry.prev = this; ->entry.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>entry.prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 57, 15)) ->prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) this.next = entry; @@ -235,11 +235,11 @@ module Editor { >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 57, 15)) entry.next.prev = entry; // entry.next.prev does not show intellisense, but entry.prev.prev does ->entry.next.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) ->entry.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>entry.next.prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>entry.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 57, 15)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) ->prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 57, 15)) } @@ -252,11 +252,11 @@ module Editor { >T : Symbol(T, Decl(genericClassWithStaticFactory.ts, 2, 22)) if (this.next.isHead) { ->this.next.isHead : Symbol(isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) +>this.next.isHead : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) >this.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) >next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) ->isHead : Symbol(isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) +>isHead : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) return null; } @@ -282,28 +282,28 @@ module Editor { >T : Symbol(T, Decl(genericClassWithStaticFactory.ts, 2, 22)) entry.isHead = false; ->entry.isHead : Symbol(isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) +>entry.isHead : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 75, 27)) ->isHead : Symbol(isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) +>isHead : Symbol(List.isHead, Decl(genericClassWithStaticFactory.ts, 7, 20)) this.prev.next = entry; ->this.prev.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>this.prev.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) >prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 75, 27)) entry.next = this; ->entry.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>entry.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 75, 27)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) entry.prev = this.prev; ->entry.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>entry.prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 75, 27)) ->prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >this.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) >prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) @@ -337,17 +337,17 @@ module Editor { >data : Symbol(data, Decl(genericClassWithStaticFactory.ts, 84, 27)) entry.next = this.next; ->entry.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>entry.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 85, 15)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) >next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) entry.prev = this; ->entry.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>entry.prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 85, 15)) ->prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) this.next = entry; @@ -357,11 +357,11 @@ module Editor { >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 85, 15)) entry.next.prev = entry;// entry.next.prev does not show intellisense, but entry.prev.prev does ->entry.next.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) ->entry.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>entry.next.prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>entry.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 85, 15)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) ->prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 85, 15)) return entry; @@ -377,23 +377,23 @@ module Editor { >T : Symbol(T, Decl(genericClassWithStaticFactory.ts, 2, 22)) this.prev.next = entry; ->this.prev.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>this.prev.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) >prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 93, 33)) entry.next = this; ->entry.next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>entry.next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 93, 33)) ->next : Symbol(next, Decl(genericClassWithStaticFactory.ts, 2, 26)) +>next : Symbol(List.next, Decl(genericClassWithStaticFactory.ts, 2, 26)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) entry.prev = this.prev; ->entry.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>entry.prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >entry : Symbol(entry, Decl(genericClassWithStaticFactory.ts, 93, 33)) ->prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) +>prev : Symbol(List.prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >this.prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) >this : Symbol(List, Decl(genericClassWithStaticFactory.ts, 0, 15)) >prev : Symbol(prev, Decl(genericClassWithStaticFactory.ts, 3, 29)) diff --git a/tests/baselines/reference/genericClassWithStaticFactory.types b/tests/baselines/reference/genericClassWithStaticFactory.types index 34d0c4aeaae..2daad9003eb 100644 --- a/tests/baselines/reference/genericClassWithStaticFactory.types +++ b/tests/baselines/reference/genericClassWithStaticFactory.types @@ -29,7 +29,7 @@ module Editor { this.listFactory = new ListFactory(); >this.listFactory = new ListFactory() : ListFactory >this.listFactory : ListFactory ->this : List +>this : this >listFactory : ListFactory >new ListFactory() : ListFactory >ListFactory : typeof ListFactory @@ -49,7 +49,7 @@ module Editor { >this.listFactory.MakeEntry(data) : List >this.listFactory.MakeEntry : (data: T) => List >this.listFactory : ListFactory ->this : List +>this : this >listFactory : ListFactory >MakeEntry : (data: T) => List >data : T @@ -58,17 +58,17 @@ module Editor { >this.prev.next = entry : List >this.prev.next : List >this.prev : List ->this : List +>this : this >prev : List >next : List >entry : List entry.next = this; ->entry.next = this : List +>entry.next = this : this >entry.next : List >entry : List >next : List ->this : List +>this : this entry.prev = this.prev; >entry.prev = this.prev : List @@ -76,13 +76,13 @@ module Editor { >entry : List >prev : List >this.prev : List ->this : List +>this : this >prev : List this.prev = entry; >this.prev = entry : List >this.prev : List ->this : List +>this : this >prev : List >entry : List @@ -105,7 +105,7 @@ module Editor { >entry = this.next : List >entry : List >this.next : List ->this : List +>this : this >next : List for (i = 0; !(entry.isHead); i++) { @@ -140,9 +140,9 @@ module Editor { >(this.next == this) : boolean >this.next == this : boolean >this.next : List ->this : List +>this : this >next : List ->this : List +>this : this } public first(): T { @@ -152,13 +152,13 @@ module Editor { if (this.isEmpty()) >this.isEmpty() : boolean >this.isEmpty : () => boolean ->this : List +>this : this >isEmpty : () => boolean { return this.next.data; >this.next.data : T >this.next : List ->this : List +>this : this >next : List >data : T } @@ -187,20 +187,20 @@ module Editor { >entry : List >next : List >this.next : List ->this : List +>this : this >next : List entry.prev = this; ->entry.prev = this : List +>entry.prev = this : this >entry.prev : List >entry : List >prev : List ->this : List +>this : this this.next = entry; >this.next = entry : List >this.next : List ->this : List +>this : this >next : List >entry : List @@ -224,7 +224,7 @@ module Editor { >this.listFactory.MakeEntry(data) : List >this.listFactory.MakeEntry : (data: T) => List >this.listFactory : ListFactory ->this : List +>this : this >listFactory : ListFactory >MakeEntry : (data: T) => List >data : T @@ -249,20 +249,20 @@ module Editor { >entry : List >next : List >this.next : List ->this : List +>this : this >next : List entry.prev = this; ->entry.prev = this : List +>entry.prev = this : this >entry.prev : List >entry : List >prev : List ->this : List +>this : this this.next = entry; >this.next = entry : List >this.next : List ->this : List +>this : this >next : List >entry : List @@ -287,7 +287,7 @@ module Editor { if (this.next.isHead) { >this.next.isHead : boolean >this.next : List ->this : List +>this : this >next : List >isHead : boolean @@ -299,11 +299,11 @@ module Editor { >this.listFactory.RemoveEntry(this.next) : List >this.listFactory.RemoveEntry : (entry: List) => List >this.listFactory : ListFactory ->this : List +>this : this >listFactory : ListFactory >RemoveEntry : (entry: List) => List >this.next : List ->this : List +>this : this >next : List } } @@ -327,17 +327,17 @@ module Editor { >this.prev.next = entry : List >this.prev.next : List >this.prev : List ->this : List +>this : this >prev : List >next : List >entry : List entry.next = this; ->entry.next = this : List +>entry.next = this : this >entry.next : List >entry : List >next : List ->this : List +>this : this entry.prev = this.prev; >entry.prev = this.prev : List @@ -345,13 +345,13 @@ module Editor { >entry : List >prev : List >this.prev : List ->this : List +>this : this >prev : List this.prev = entry; >this.prev = entry : List >this.prev : List ->this : List +>this : this >prev : List >entry : List @@ -373,7 +373,7 @@ module Editor { >this.listFactory.MakeEntry(data) : List >this.listFactory.MakeEntry : (data: T) => List >this.listFactory : ListFactory ->this : List +>this : this >listFactory : ListFactory >MakeEntry : (data: T) => List >data : T @@ -384,20 +384,20 @@ module Editor { >entry : List >next : List >this.next : List ->this : List +>this : this >next : List entry.prev = this; ->entry.prev = this : List +>entry.prev = this : this >entry.prev : List >entry : List >prev : List ->this : List +>this : this this.next = entry; >this.next = entry : List >this.next : List ->this : List +>this : this >next : List >entry : List @@ -426,17 +426,17 @@ module Editor { >this.prev.next = entry : List >this.prev.next : List >this.prev : List ->this : List +>this : this >prev : List >next : List >entry : List entry.next = this; ->entry.next = this : List +>entry.next = this : this >entry.next : List >entry : List >next : List ->this : List +>this : this entry.prev = this.prev; >entry.prev = this.prev : List @@ -444,13 +444,13 @@ module Editor { >entry : List >prev : List >this.prev : List ->this : List +>this : this >prev : List this.prev = entry; >this.prev = entry : List >this.prev : List ->this : List +>this : this >prev : List >entry : List @@ -470,7 +470,7 @@ module Editor { >this.listFactory.MakeEntry(data) : List >this.listFactory.MakeEntry : (data: T) => List >this.listFactory : ListFactory ->this : List +>this : this >listFactory : ListFactory >MakeEntry : (data: T) => List >data : T @@ -478,7 +478,7 @@ module Editor { return this.insertEntryBefore(entry); >this.insertEntryBefore(entry) : List >this.insertEntryBefore : (entry: List) => List ->this : List +>this : this >insertEntryBefore : (entry: List) => List >entry : List } diff --git a/tests/baselines/reference/genericClasses4.types b/tests/baselines/reference/genericClasses4.types index ac3d05be84d..3a2ae3b997c 100644 --- a/tests/baselines/reference/genericClasses4.types +++ b/tests/baselines/reference/genericClasses4.types @@ -26,7 +26,7 @@ class Vec2_T >f(this.x) : B >f : (a: A) => B >this.x : A ->this : Vec2_T +>this : this >x : A var y:B = f(this.y); @@ -35,7 +35,7 @@ class Vec2_T >f(this.y) : B >f : (a: A) => B >this.y : A ->this : Vec2_T +>this : this >y : A var retval: Vec2_T = new Vec2_T(x, y); @@ -69,7 +69,7 @@ class Vec2_T >f : Vec2_T<(a: A) => B> >x : (a: A) => B >this.x : A ->this : Vec2_T +>this : this >x : A var y:B = f.y(this.y); @@ -80,7 +80,7 @@ class Vec2_T >f : Vec2_T<(a: A) => B> >y : (a: A) => B >this.y : A ->this : Vec2_T +>this : this >y : A var retval: Vec2_T = new Vec2_T(x, y); diff --git a/tests/baselines/reference/genericClassesInModule2.types b/tests/baselines/reference/genericClassesInModule2.types index 5da8c43097f..18c83d9d725 100644 --- a/tests/baselines/reference/genericClassesInModule2.types +++ b/tests/baselines/reference/genericClassesInModule2.types @@ -10,10 +10,10 @@ export class A{ >T1 : T1 var child = new B(this); ->child : B> ->new B(this) : B> +>child : B +>new B(this) : B >B : typeof B ->this : A +>this : this } AAA( callback: (self: A) => void) { >AAA : (callback: (self: A) => void) => void @@ -23,10 +23,10 @@ export class A{ >T1 : T1 var child = new B(this); ->child : B> ->new B(this) : B> +>child : B +>new B(this) : B >B : typeof B ->this : A +>this : this } } diff --git a/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.symbols b/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.symbols index 3ce4f709b7d..68df4a89b36 100644 --- a/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.symbols +++ b/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.symbols @@ -11,7 +11,7 @@ declare module EndGate { } interface Number extends EndGate.ICloneable { } ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11), Decl(genericConstraintOnExtendedBuiltinTypes.ts, 4, 1)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(genericConstraintOnExtendedBuiltinTypes.ts, 4, 1)) >EndGate.ICloneable : Symbol(EndGate.ICloneable, Decl(genericConstraintOnExtendedBuiltinTypes.ts, 0, 24)) >EndGate : Symbol(EndGate, Decl(genericConstraintOnExtendedBuiltinTypes.ts, 0, 0), Decl(genericConstraintOnExtendedBuiltinTypes.ts, 6, 47), Decl(genericConstraintOnExtendedBuiltinTypes.ts, 17, 1)) >ICloneable : Symbol(EndGate.ICloneable, Decl(genericConstraintOnExtendedBuiltinTypes.ts, 0, 24)) diff --git a/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.types b/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.types index 9a4b209bc97..f0396074b94 100644 --- a/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.types +++ b/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.types @@ -37,7 +37,7 @@ module EndGate.Tweening { this._from = from.Clone(); >this._from = from.Clone() : any >this._from : T ->this : Tween +>this : this >_from : T >from.Clone() : any >from.Clone : () => any diff --git a/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.symbols b/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.symbols index be96d92c357..c5e9f0a79f5 100644 --- a/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.symbols +++ b/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.symbols @@ -11,7 +11,7 @@ module EndGate { } interface Number extends EndGate.ICloneable { } ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11), Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 4, 1)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 4, 1)) >EndGate.ICloneable : Symbol(EndGate.ICloneable, Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 0, 16)) >EndGate : Symbol(EndGate, Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 0, 0), Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 6, 47), Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 16, 1)) >ICloneable : Symbol(EndGate.ICloneable, Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 0, 16)) @@ -51,7 +51,7 @@ module EndGate.Tweening { export class NumberTween extends Tween{ >NumberTween : Symbol(NumberTween, Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 18, 25)) >Tween : Symbol(Tween, Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 8, 25)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11), Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 4, 1)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 4, 1)) constructor(from: number) { >from : Symbol(from, Decl(genericConstraintOnExtendedBuiltinTypes2.ts, 20, 20)) diff --git a/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.types b/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.types index ba42e42ae0c..3745a5f6a17 100644 --- a/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.types +++ b/tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.types @@ -36,7 +36,7 @@ module EndGate.Tweening { this._from = from.Clone(); >this._from = from.Clone() : any >this._from : T ->this : Tween +>this : this >_from : T >from.Clone() : any >from.Clone : () => any diff --git a/tests/baselines/reference/genericContextualTypingSpecialization.symbols b/tests/baselines/reference/genericContextualTypingSpecialization.symbols index 05312d889c9..b244ab496be 100644 --- a/tests/baselines/reference/genericContextualTypingSpecialization.symbols +++ b/tests/baselines/reference/genericContextualTypingSpecialization.symbols @@ -3,9 +3,9 @@ var b: number[]; >b : Symbol(b, Decl(genericContextualTypingSpecialization.ts, 0, 3)) b.reduce((c, d) => c + d, 0); // should not error on '+' ->b.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120)) +>b.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(genericContextualTypingSpecialization.ts, 0, 3)) ->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120)) +>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >c : Symbol(c, Decl(genericContextualTypingSpecialization.ts, 1, 18)) >d : Symbol(d, Decl(genericContextualTypingSpecialization.ts, 1, 20)) >c : Symbol(c, Decl(genericContextualTypingSpecialization.ts, 1, 18)) diff --git a/tests/baselines/reference/genericFunctionSpecializations1.symbols b/tests/baselines/reference/genericFunctionSpecializations1.symbols index e3c21ea418b..aaf607cbd47 100644 --- a/tests/baselines/reference/genericFunctionSpecializations1.symbols +++ b/tests/baselines/reference/genericFunctionSpecializations1.symbols @@ -18,7 +18,7 @@ function foo4(test: string); // valid function foo4(test: T) { } >foo4 : Symbol(foo4, Decl(genericFunctionSpecializations1.ts, 1, 29), Decl(genericFunctionSpecializations1.ts, 3, 31)) >T : Symbol(T, Decl(genericFunctionSpecializations1.ts, 4, 14)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >test : Symbol(test, Decl(genericFunctionSpecializations1.ts, 4, 32)) >T : Symbol(T, Decl(genericFunctionSpecializations1.ts, 4, 14)) diff --git a/tests/baselines/reference/genericFunctions2.symbols b/tests/baselines/reference/genericFunctions2.symbols index 59068cbd8dd..246f59c8e8a 100644 --- a/tests/baselines/reference/genericFunctions2.symbols +++ b/tests/baselines/reference/genericFunctions2.symbols @@ -19,8 +19,8 @@ var lengths = map(myItems, x => x.length); >map : Symbol(map, Decl(genericFunctions2.ts, 0, 0)) >myItems : Symbol(myItems, Decl(genericFunctions2.ts, 2, 3)) >x : Symbol(x, Decl(genericFunctions2.ts, 3, 26)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(genericFunctions2.ts, 3, 26)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/genericFunctionsWithOptionalParameters1.symbols b/tests/baselines/reference/genericFunctionsWithOptionalParameters1.symbols index fa04763f2ab..fd79d736ffd 100644 --- a/tests/baselines/reference/genericFunctionsWithOptionalParameters1.symbols +++ b/tests/baselines/reference/genericFunctionsWithOptionalParameters1.symbols @@ -7,7 +7,7 @@ interface Utils { >T : Symbol(T, Decl(genericFunctionsWithOptionalParameters1.ts, 1, 8)) >S : Symbol(S, Decl(genericFunctionsWithOptionalParameters1.ts, 1, 10)) >c : Symbol(c, Decl(genericFunctionsWithOptionalParameters1.ts, 1, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(genericFunctionsWithOptionalParameters1.ts, 1, 8)) >folder : Symbol(folder, Decl(genericFunctionsWithOptionalParameters1.ts, 1, 27)) >s : Symbol(s, Decl(genericFunctionsWithOptionalParameters1.ts, 1, 38)) diff --git a/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols b/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols index 2fe7e295a0d..d033f7b66bb 100644 --- a/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols +++ b/tests/baselines/reference/genericFunctionsWithOptionalParameters3.symbols @@ -63,7 +63,7 @@ var r3 = utils.mapReduce(c, (x) => { return 1 }, (y) => { return new Date() }); >c : Symbol(c, Decl(genericFunctionsWithOptionalParameters3.ts, 8, 3)) >x : Symbol(x, Decl(genericFunctionsWithOptionalParameters3.ts, 9, 29)) >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 9, 50)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r4 = utils.mapReduce(c, (x: string) => { return 1 }, (y: number) => { return new Date() }); >r4 : Symbol(r4, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 3)) @@ -73,7 +73,7 @@ var r4 = utils.mapReduce(c, (x: string) => { return 1 }, (y: number) => { return >c : Symbol(c, Decl(genericFunctionsWithOptionalParameters3.ts, 8, 3)) >x : Symbol(x, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 29)) >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 10, 58)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var f1 = (x: string) => { return 1 }; >f1 : Symbol(f1, Decl(genericFunctionsWithOptionalParameters3.ts, 11, 3)) @@ -82,7 +82,7 @@ var f1 = (x: string) => { return 1 }; var f2 = (y: number) => { return new Date() }; >f2 : Symbol(f2, Decl(genericFunctionsWithOptionalParameters3.ts, 12, 3)) >y : Symbol(y, Decl(genericFunctionsWithOptionalParameters3.ts, 12, 10)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r5 = utils.mapReduce(c, f1, f2); >r5 : Symbol(r5, Decl(genericFunctionsWithOptionalParameters3.ts, 13, 3)) diff --git a/tests/baselines/reference/genericInference1.symbols b/tests/baselines/reference/genericInference1.symbols index 6980668c6eb..8beecf27254 100644 --- a/tests/baselines/reference/genericInference1.symbols +++ b/tests/baselines/reference/genericInference1.symbols @@ -1,9 +1,9 @@ === tests/cases/compiler/genericInference1.ts === ['a', 'b', 'c'].map(x => x.length); ->['a', 'b', 'c'].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>['a', 'b', 'c'].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(genericInference1.ts, 0, 20)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(genericInference1.ts, 0, 20)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/genericInference2.symbols b/tests/baselines/reference/genericInference2.symbols index 83b371005f7..52b80747cb9 100644 --- a/tests/baselines/reference/genericInference2.symbols +++ b/tests/baselines/reference/genericInference2.symbols @@ -49,11 +49,11 @@ }; var x_v = o.name().length; // should be 'number' >x_v : Symbol(x_v, Decl(genericInference2.ts, 14, 7)) ->o.name().length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>o.name().length : Symbol(String.length, Decl(lib.d.ts, --, --)) >o.name : Symbol(name, Decl(genericInference2.ts, 10, 13)) >o : Symbol(o, Decl(genericInference2.ts, 10, 7)) >name : Symbol(name, Decl(genericInference2.ts, 10, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) var age_v = o.age(); // should be 'number' >age_v : Symbol(age_v, Decl(genericInference2.ts, 15, 7)) diff --git a/tests/baselines/reference/genericInstanceOf.types b/tests/baselines/reference/genericInstanceOf.types index 726fa38fbf8..3c08c35e44a 100644 --- a/tests/baselines/reference/genericInstanceOf.types +++ b/tests/baselines/reference/genericInstanceOf.types @@ -21,10 +21,10 @@ class C { if (this.a instanceof this.b) { >this.a instanceof this.b : boolean >this.a : T ->this : C +>this : this >a : T >this.b : F ->this : C +>this : this >b : F } } diff --git a/tests/baselines/reference/genericMethodOverspecialization.symbols b/tests/baselines/reference/genericMethodOverspecialization.symbols index 651aced0fcd..808addf068c 100644 --- a/tests/baselines/reference/genericMethodOverspecialization.symbols +++ b/tests/baselines/reference/genericMethodOverspecialization.symbols @@ -27,9 +27,9 @@ interface Document { var elements = names.map(function (name) { >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3)) ->names.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>names.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >names : Symbol(names, Decl(genericMethodOverspecialization.ts, 0, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >name : Symbol(name, Decl(genericMethodOverspecialization.ts, 12, 35)) return document.getElementById(name); @@ -43,9 +43,9 @@ var elements = names.map(function (name) { var xxx = elements.filter(function (e) { >xxx : Symbol(xxx, Decl(genericMethodOverspecialization.ts, 17, 3)) ->elements.filter : Symbol(Array.filter, Decl(lib.d.ts, 1122, 87)) +>elements.filter : Symbol(Array.filter, Decl(lib.d.ts, --, --)) >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3)) ->filter : Symbol(Array.filter, Decl(lib.d.ts, 1122, 87)) +>filter : Symbol(Array.filter, Decl(lib.d.ts, --, --)) >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 17, 36)) return !e.isDisabled; @@ -57,9 +57,9 @@ var xxx = elements.filter(function (e) { var widths:number[] = elements.map(function (e) { // should not error >widths : Symbol(widths, Decl(genericMethodOverspecialization.ts, 21, 3)) ->elements.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>elements.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >elements : Symbol(elements, Decl(genericMethodOverspecialization.ts, 12, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >e : Symbol(e, Decl(genericMethodOverspecialization.ts, 21, 45)) return e.clientWidth; diff --git a/tests/baselines/reference/genericTypeParameterEquivalence2.symbols b/tests/baselines/reference/genericTypeParameterEquivalence2.symbols index 056b4ce96ab..cd558fdd10a 100644 --- a/tests/baselines/reference/genericTypeParameterEquivalence2.symbols +++ b/tests/baselines/reference/genericTypeParameterEquivalence2.symbols @@ -24,9 +24,9 @@ function compose(f: (b: B) => C, g: (a:A) => B): (a:A) => C { return f(g.apply(null, a)); >f : Symbol(f, Decl(genericTypeParameterEquivalence2.ts, 1, 26)) ->g.apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20)) +>g.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) >g : Symbol(g, Decl(genericTypeParameterEquivalence2.ts, 1, 41)) ->apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20)) +>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(genericTypeParameterEquivalence2.ts, 2, 21)) }; @@ -46,9 +46,9 @@ function forEach(list: A[], f: (a: A, n?: number) => void ): void { for (var i = 0; i < list.length; ++i) { >i : Symbol(i, Decl(genericTypeParameterEquivalence2.ts, 9, 12)) >i : Symbol(i, Decl(genericTypeParameterEquivalence2.ts, 9, 12)) ->list.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>list.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >list : Symbol(list, Decl(genericTypeParameterEquivalence2.ts, 8, 20)) ->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >i : Symbol(i, Decl(genericTypeParameterEquivalence2.ts, 9, 12)) f(list[i], i); @@ -83,9 +83,9 @@ function filter(f: (a: A) => boolean, ar: A[]): A[] { >el : Symbol(el, Decl(genericTypeParameterEquivalence2.ts, 17, 17)) ret.push(el); ->ret.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>ret.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >ret : Symbol(ret, Decl(genericTypeParameterEquivalence2.ts, 16, 7)) ->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >el : Symbol(el, Decl(genericTypeParameterEquivalence2.ts, 17, 17)) } } ); @@ -102,9 +102,9 @@ function length2(ar: A[]): number { >A : Symbol(A, Decl(genericTypeParameterEquivalence2.ts, 27, 17)) return ar.length; ->ar.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>ar.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >ar : Symbol(ar, Decl(genericTypeParameterEquivalence2.ts, 27, 20)) ->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) } // curry1 :: ((a,b)->c) -> (a->(b->c)) diff --git a/tests/baselines/reference/genericTypeWithCallableMembers.types b/tests/baselines/reference/genericTypeWithCallableMembers.types index e0068d5ff2b..8f62f077d54 100644 --- a/tests/baselines/reference/genericTypeWithCallableMembers.types +++ b/tests/baselines/reference/genericTypeWithCallableMembers.types @@ -24,14 +24,14 @@ class C { >x : Constructable >new this.data() : Constructable >this.data : T ->this : C +>this : this >data : T var x2 = new this.data2(); // was error, shouldn't be >x2 : Constructable >new this.data2() : Constructable >this.data2 : Constructable ->this : C +>this : this >data2 : Constructable } } diff --git a/tests/baselines/reference/genericWithCallSignatures1.types b/tests/baselines/reference/genericWithCallSignatures1.types index b55b4bbc64b..b4a12129027 100644 --- a/tests/baselines/reference/genericWithCallSignatures1.types +++ b/tests/baselines/reference/genericWithCallSignatures1.types @@ -15,7 +15,7 @@ class MyClass { > this.callableThing() : string >this.callableThing() : string >this.callableThing : CallableExtention ->this : MyClass +>this : this >callableThing : CallableExtention } } diff --git a/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.types b/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.types index 3e281f6072a..337993dc2a6 100644 --- a/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.types +++ b/tests/baselines/reference/genericWithIndexerOfTypeParameterType1.types @@ -15,7 +15,7 @@ class LazyArray { return this.objects; >this.objects : { [objectId: string]: T; } ->this : LazyArray +>this : this >objects : { [objectId: string]: T; } } } diff --git a/tests/baselines/reference/getterSetterNonAccessor.symbols b/tests/baselines/reference/getterSetterNonAccessor.symbols index 10ffc55480c..f10542c0a0c 100644 --- a/tests/baselines/reference/getterSetterNonAccessor.symbols +++ b/tests/baselines/reference/getterSetterNonAccessor.symbols @@ -7,10 +7,10 @@ function setFunc(v){} >v : Symbol(v, Decl(getterSetterNonAccessor.ts, 1, 17)) Object.defineProperty({}, "0", ({ ->Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) ->defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60)) ->PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66)) +>Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, --, --)) +>PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, --, --)) get: getFunc, >get : Symbol(get, Decl(getterSetterNonAccessor.ts, 3, 53)) diff --git a/tests/baselines/reference/giant.errors.txt b/tests/baselines/reference/giant.errors.txt index 1d623870d63..2c7e6f505bd 100644 --- a/tests/baselines/reference/giant.errors.txt +++ b/tests/baselines/reference/giant.errors.txt @@ -44,7 +44,7 @@ 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 TS1184: An implementation cannot be declared in ambient contexts. +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'. @@ -68,39 +68,39 @@ 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 TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(238,35): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(240,24): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(243,21): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(244,22): error TS1184: An implementation cannot be declared in ambient contexts. +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(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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared 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'. @@ -147,7 +147,7 @@ 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 TS1184: An implementation cannot be declared in ambient contexts. +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'. @@ -171,98 +171,98 @@ 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 TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(496,35): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(498,24): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(501,21): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(502,22): error TS1184: An implementation cannot be declared in ambient contexts. +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(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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(532,31): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(534,20): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(537,17): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(538,18): error TS1184: An implementation cannot be declared 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(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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(561,21): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(563,21): error TS1184: An implementation cannot be declared 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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared 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(615,16): error TS1038: A 'declare' modifier cannot be used in an already ambient context. 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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(623,24): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(626,21): error TS1184: An implementation cannot be declared in ambient contexts. -tests/cases/compiler/giant.ts(628,21): error TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared in ambient contexts. +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 TS1184: An implementation cannot be declared 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 (265 errors) ==== @@ -513,7 +513,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be export declare var eaV; export declare function eaF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export declare class eaC { }; export declare module eaM { }; } @@ -640,31 +640,31 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be export declare var eaV; export declare function eaF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export declare class eaC { }; export declare module eaM { }; } export declare var eaV; export declare function eaF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export declare class eaC { constructor () { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public pV; private rV; public pF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. private rF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public pgF() { } ~~~ !!! error TS2300: Duplicate identifier 'pgF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public get pgF() ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -674,7 +674,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~ !!! error TS2300: Duplicate identifier 'psF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public set psF(param:any) ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -684,7 +684,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~ !!! error TS2300: Duplicate identifier 'rgF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. private get rgF() ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -694,7 +694,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~ !!! error TS2300: Duplicate identifier 'rsF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. private set rsF(param:any) ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -703,12 +703,12 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be static tV; static tF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static tsF(param:any) { } ~~~ !!! error TS2300: Duplicate identifier 'tsF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static set tsF(param:any) ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -718,7 +718,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~ !!! error TS2300: Duplicate identifier 'tgF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static get tgF() ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -729,7 +729,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be var V; function F() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. ~ !!! error TS1036: Statements are not allowed in ambient contexts. class C { } @@ -738,7 +738,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be export var eV; export function eF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export class eC { } export interface eI { } export module eM { } @@ -977,7 +977,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be export declare var eaV; export declare function eaF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export declare class eaC { }; export declare module eaM { }; } @@ -1104,31 +1104,31 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be export declare var eaV; export declare function eaF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export declare class eaC { }; export declare module eaM { }; } export declare var eaV; export declare function eaF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export declare class eaC { constructor () { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public pV; private rV; public pF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. private rF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public pgF() { } ~~~ !!! error TS2300: Duplicate identifier 'pgF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public get pgF() ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -1138,7 +1138,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~ !!! error TS2300: Duplicate identifier 'psF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public set psF(param:any) ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -1148,7 +1148,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~ !!! error TS2300: Duplicate identifier 'rgF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. private get rgF() ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -1158,7 +1158,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~ !!! error TS2300: Duplicate identifier 'rsF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. private set rsF(param:any) ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -1167,12 +1167,12 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be static tV; static tF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static tsF(param:any) { } ~~~ !!! error TS2300: Duplicate identifier 'tsF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static set tsF(param:any) ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -1182,7 +1182,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~ !!! error TS2300: Duplicate identifier 'tgF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static get tgF() ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -1193,7 +1193,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be var V; function F() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. ~ !!! error TS1036: Statements are not allowed in ambient contexts. class C { } @@ -1202,7 +1202,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be export var eV; export function eF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export class eC { } export interface eI { } export module eM { } @@ -1211,24 +1211,24 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be export declare var eaV; export declare function eaF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export declare class eaC { constructor () { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public pV; private rV; public pF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. private rF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public pgF() { } ~~~ !!! error TS2300: Duplicate identifier 'pgF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public get pgF() ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -1238,7 +1238,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~ !!! error TS2300: Duplicate identifier 'psF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public set psF(param:any) ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -1248,7 +1248,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~ !!! error TS2300: Duplicate identifier 'rgF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. private get rgF() ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -1258,7 +1258,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~ !!! error TS2300: Duplicate identifier 'rsF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. private set rsF(param:any) ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -1267,12 +1267,12 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be static tV; static tF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static tsF(param:any) { } ~~~ !!! error TS2300: Duplicate identifier 'tsF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static set tsF(param:any) ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -1282,7 +1282,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~ !!! error TS2300: Duplicate identifier 'tgF'. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static get tgF() ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. @@ -1293,22 +1293,22 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be var V; function F() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. ~ !!! error TS1036: Statements are not allowed in ambient contexts. class C { constructor () { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public pV; private rV; public pF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static tV; static tF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } interface I { //Call Signature @@ -1363,7 +1363,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be var V; function F() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. ~ !!! error TS1036: Statements are not allowed in ambient contexts. class C { } @@ -1372,7 +1372,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be export var eV; export function eF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export class eC { } export interface eI { } export module eM { } @@ -1383,7 +1383,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be ~~~~~~~ !!! error TS1038: A 'declare' modifier cannot be used in an already ambient context. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export declare class eaC { } ~~~~~~~ !!! error TS1038: A 'declare' modifier cannot be used in an already ambient context. @@ -1394,20 +1394,20 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be export var eV; export function eF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export class eC { constructor () { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. public pV; private rV; public pF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. static tV static tF() { } ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } export interface eI { //Call Signature @@ -1463,7 +1463,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be var V; function F() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. ~ !!! error TS1036: Statements are not allowed in ambient contexts. class C { } @@ -1471,7 +1471,7 @@ tests/cases/compiler/giant.ts(676,30): error TS1184: An implementation cannot be export var eV; export function eF() { }; ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. export class eC { } export interface eI { } export module eM { } diff --git a/tests/baselines/reference/globalThis.symbols b/tests/baselines/reference/globalThis.symbols index 77b65bbfa2b..6ca1054f1af 100644 --- a/tests/baselines/reference/globalThis.symbols +++ b/tests/baselines/reference/globalThis.symbols @@ -1,7 +1,7 @@ === tests/cases/compiler/globalThis.ts === var __e = Math.E; // should not generate 'this.Math.E' >__e : Symbol(__e, Decl(globalThis.ts, 0, 3)) ->Math.E : Symbol(Math.E, Decl(lib.d.ts, 524, 16)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->E : Symbol(Math.E, Decl(lib.d.ts, 524, 16)) +>Math.E : Symbol(Math.E, Decl(lib.d.ts, --, --)) +>Math : Symbol(Math, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>E : Symbol(Math.E, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/heterogeneousArrayLiterals.symbols b/tests/baselines/reference/heterogeneousArrayLiterals.symbols index c7a73d56414..c1d98b5873a 100644 --- a/tests/baselines/reference/heterogeneousArrayLiterals.symbols +++ b/tests/baselines/reference/heterogeneousArrayLiterals.symbols @@ -15,7 +15,7 @@ var d = [{}, 1]; // {}[] var e = [{}, Object]; // {}[] >e : Symbol(e, Decl(heterogeneousArrayLiterals.ts, 6, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var f = [[], [1]]; // number[][] >f : Symbol(f, Decl(heterogeneousArrayLiterals.ts, 8, 3)) diff --git a/tests/baselines/reference/ifDoWhileStatements.symbols b/tests/baselines/reference/ifDoWhileStatements.symbols index 36a990010ef..e2b375cb54b 100644 --- a/tests/baselines/reference/ifDoWhileStatements.symbols +++ b/tests/baselines/reference/ifDoWhileStatements.symbols @@ -67,9 +67,9 @@ module M { export function F2(x: number): string { return x.toString(); } >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, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(ifDoWhileStatements.ts, 27, 23)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } module N { @@ -85,9 +85,9 @@ module N { export function F2(x: number): string { return x.toString(); } >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, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(ifDoWhileStatements.ts, 35, 23)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } // literals diff --git a/tests/baselines/reference/implementArrayInterface.symbols b/tests/baselines/reference/implementArrayInterface.symbols index 97d106157fe..5a671d41de3 100644 --- a/tests/baselines/reference/implementArrayInterface.symbols +++ b/tests/baselines/reference/implementArrayInterface.symbols @@ -2,7 +2,7 @@ declare class MyArray implements Array { >MyArray : Symbol(MyArray, Decl(implementArrayInterface.ts, 0, 0)) >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(implementArrayInterface.ts, 0, 22)) toString(): string; diff --git a/tests/baselines/reference/implementsInClassExpression.js b/tests/baselines/reference/implementsInClassExpression.js new file mode 100644 index 00000000000..9ac092289f5 --- /dev/null +++ b/tests/baselines/reference/implementsInClassExpression.js @@ -0,0 +1,16 @@ +//// [implementsInClassExpression.ts] +interface Foo { + doThing(): void; +} + +let cls = class implements Foo { + doThing() { } +} + +//// [implementsInClassExpression.js] +var cls = (function () { + function class_1() { + } + class_1.prototype.doThing = function () { }; + return class_1; +})(); diff --git a/tests/baselines/reference/implementsInClassExpression.symbols b/tests/baselines/reference/implementsInClassExpression.symbols new file mode 100644 index 00000000000..f65c3456320 --- /dev/null +++ b/tests/baselines/reference/implementsInClassExpression.symbols @@ -0,0 +1,15 @@ +=== tests/cases/compiler/implementsInClassExpression.ts === +interface Foo { +>Foo : Symbol(Foo, Decl(implementsInClassExpression.ts, 0, 0)) + + doThing(): void; +>doThing : Symbol(doThing, Decl(implementsInClassExpression.ts, 0, 15)) +} + +let cls = class implements Foo { +>cls : Symbol(cls, Decl(implementsInClassExpression.ts, 4, 3)) +>Foo : Symbol(Foo, Decl(implementsInClassExpression.ts, 0, 0)) + + doThing() { } +>doThing : Symbol((Anonymous class).doThing, Decl(implementsInClassExpression.ts, 4, 32)) +} diff --git a/tests/baselines/reference/implementsInClassExpression.types b/tests/baselines/reference/implementsInClassExpression.types new file mode 100644 index 00000000000..d3647c30ff1 --- /dev/null +++ b/tests/baselines/reference/implementsInClassExpression.types @@ -0,0 +1,16 @@ +=== tests/cases/compiler/implementsInClassExpression.ts === +interface Foo { +>Foo : Foo + + doThing(): void; +>doThing : () => void +} + +let cls = class implements Foo { +>cls : typeof (Anonymous class) +>class implements Foo { doThing() { }} : typeof (Anonymous class) +>Foo : Foo + + doThing() { } +>doThing : () => void +} diff --git a/tests/baselines/reference/implicitAnyInCatch.types b/tests/baselines/reference/implicitAnyInCatch.types index b0fbd4e7f12..cd0dd2d2423 100644 --- a/tests/baselines/reference/implicitAnyInCatch.types +++ b/tests/baselines/reference/implicitAnyInCatch.types @@ -23,7 +23,7 @@ class C { for (var x in this) { >x : any ->this : C +>this : this } } } diff --git a/tests/baselines/reference/importDeclRefereingExternalModuleWithNoResolve.errors.txt b/tests/baselines/reference/importDeclRefereingExternalModuleWithNoResolve.errors.txt index e46ff8bea13..74f532d0c1e 100644 --- a/tests/baselines/reference/importDeclRefereingExternalModuleWithNoResolve.errors.txt +++ b/tests/baselines/reference/importDeclRefereingExternalModuleWithNoResolve.errors.txt @@ -1,6 +1,6 @@ tests/cases/compiler/importDeclRefereingExternalModuleWithNoResolve.ts(1,1): error TS1148: Cannot compile modules unless the '--module' flag is provided. tests/cases/compiler/importDeclRefereingExternalModuleWithNoResolve.ts(1,20): error TS2307: Cannot find module 'externalModule'. -tests/cases/compiler/importDeclRefereingExternalModuleWithNoResolve.ts(2,16): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/importDeclRefereingExternalModuleWithNoResolve.ts(2,16): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/importDeclRefereingExternalModuleWithNoResolve.ts(3,26): error TS2307: Cannot find module 'externalModule'. @@ -12,7 +12,7 @@ tests/cases/compiler/importDeclRefereingExternalModuleWithNoResolve.ts(3,26): er !!! error TS2307: Cannot find module 'externalModule'. declare module "m1" { ~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. import im2 = require("externalModule"); ~~~~~~~~~~~~~~~~ !!! error TS2307: Cannot find module 'externalModule'. diff --git a/tests/baselines/reference/importsInAmbientModules1.js b/tests/baselines/reference/importsInAmbientModules1.js new file mode 100644 index 00000000000..4c888f2dfe5 --- /dev/null +++ b/tests/baselines/reference/importsInAmbientModules1.js @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/importsInAmbientModules1.ts] //// + +//// [external.d.ts] + +export var x: number + +//// [main.ts] + +declare module "M" { + import {x} from "external" +} + +//// [main.js] diff --git a/tests/baselines/reference/importsInAmbientModules1.symbols b/tests/baselines/reference/importsInAmbientModules1.symbols new file mode 100644 index 00000000000..d220ba2bf45 --- /dev/null +++ b/tests/baselines/reference/importsInAmbientModules1.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/external.d.ts === + +export var x: number +>x : Symbol(x, Decl(external.d.ts, 1, 10)) + +=== tests/cases/compiler/main.ts === + +declare module "M" { + import {x} from "external" +>x : Symbol(x, Decl(main.ts, 2, 12)) +} diff --git a/tests/baselines/reference/importsInAmbientModules1.types b/tests/baselines/reference/importsInAmbientModules1.types new file mode 100644 index 00000000000..634de9f1f0f --- /dev/null +++ b/tests/baselines/reference/importsInAmbientModules1.types @@ -0,0 +1,11 @@ +=== 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 new file mode 100644 index 00000000000..84d5dd84f10 --- /dev/null +++ b/tests/baselines/reference/importsInAmbientModules2.js @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/importsInAmbientModules2.ts] //// + +//// [external.d.ts] + +export default class C {} + +//// [main.ts] + +declare module "M" { + import C from "external" +} + +//// [main.js] diff --git a/tests/baselines/reference/importsInAmbientModules2.symbols b/tests/baselines/reference/importsInAmbientModules2.symbols new file mode 100644 index 00000000000..02333798e8b --- /dev/null +++ b/tests/baselines/reference/importsInAmbientModules2.symbols @@ -0,0 +1,11 @@ +=== 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)) +} diff --git a/tests/baselines/reference/importsInAmbientModules2.types b/tests/baselines/reference/importsInAmbientModules2.types new file mode 100644 index 00000000000..d6c4eddc07c --- /dev/null +++ b/tests/baselines/reference/importsInAmbientModules2.types @@ -0,0 +1,11 @@ +=== 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 new file mode 100644 index 00000000000..2a8e09b53e1 --- /dev/null +++ b/tests/baselines/reference/importsInAmbientModules3.js @@ -0,0 +1,13 @@ +//// [tests/cases/compiler/importsInAmbientModules3.ts] //// + +//// [external.d.ts] + +export default class C {} + +//// [main.ts] + +declare module "M" { + import C = require("external"); +} + +//// [main.js] diff --git a/tests/baselines/reference/importsInAmbientModules3.symbols b/tests/baselines/reference/importsInAmbientModules3.symbols new file mode 100644 index 00000000000..15b2c7173dc --- /dev/null +++ b/tests/baselines/reference/importsInAmbientModules3.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/main.ts === + +declare module "M" { + import C = require("external"); +>C : Symbol(C, Decl(main.ts, 1, 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 new file mode 100644 index 00000000000..6c613687b08 --- /dev/null +++ b/tests/baselines/reference/importsInAmbientModules3.types @@ -0,0 +1,11 @@ +=== 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/indexer3.symbols b/tests/baselines/reference/indexer3.symbols index 1de91806faa..fa6f905def6 100644 --- a/tests/baselines/reference/indexer3.symbols +++ b/tests/baselines/reference/indexer3.symbols @@ -2,10 +2,10 @@ var dateMap: { [x: string]: Date; } = {} >dateMap : Symbol(dateMap, Decl(indexer3.ts, 0, 3)) >x : Symbol(x, Decl(indexer3.ts, 0, 16)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r: Date = dateMap["hello"] // result type includes indexer using BCT >r : Symbol(r, Decl(indexer3.ts, 1, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >dateMap : Symbol(dateMap, Decl(indexer3.ts, 0, 3)) diff --git a/tests/baselines/reference/indexersInClassType.symbols b/tests/baselines/reference/indexersInClassType.symbols index e459888cc0d..0852463c37d 100644 --- a/tests/baselines/reference/indexersInClassType.symbols +++ b/tests/baselines/reference/indexersInClassType.symbols @@ -4,14 +4,14 @@ class C { [x: number]: Date; >x : Symbol(x, Decl(indexersInClassType.ts, 1, 5)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [x: string]: Object; >x : Symbol(x, Decl(indexersInClassType.ts, 2, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) 1: Date; ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) 'a': {} diff --git a/tests/baselines/reference/indexersInClassType.types b/tests/baselines/reference/indexersInClassType.types index 8e06bdfbfd3..496526776d9 100644 --- a/tests/baselines/reference/indexersInClassType.types +++ b/tests/baselines/reference/indexersInClassType.types @@ -16,10 +16,10 @@ class C { 'a': {} fn() { ->fn : () => C +>fn : () => this return this; ->this : C +>this : this } } diff --git a/tests/baselines/reference/inferSecondaryParameter.symbols b/tests/baselines/reference/inferSecondaryParameter.symbols index c2527ed14b3..5522770c02f 100644 --- a/tests/baselines/reference/inferSecondaryParameter.symbols +++ b/tests/baselines/reference/inferSecondaryParameter.symbols @@ -6,7 +6,7 @@ interface Ib { m(test: string, fn: Function); } >m : Symbol(m, Decl(inferSecondaryParameter.ts, 2, 14)) >test : Symbol(test, Decl(inferSecondaryParameter.ts, 2, 17)) >fn : Symbol(fn, Decl(inferSecondaryParameter.ts, 2, 30)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var b: Ib = { m: function (test: string, fn: Function) { } }; >b : Symbol(b, Decl(inferSecondaryParameter.ts, 4, 3)) @@ -14,7 +14,7 @@ var b: Ib = { m: function (test: string, fn: Function) { } }; >m : Symbol(m, Decl(inferSecondaryParameter.ts, 4, 13)) >test : Symbol(test, Decl(inferSecondaryParameter.ts, 4, 27)) >fn : Symbol(fn, Decl(inferSecondaryParameter.ts, 4, 40)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) b.m("test", function (bug) { >b.m : Symbol(Ib.m, Decl(inferSecondaryParameter.ts, 2, 14)) diff --git a/tests/baselines/reference/inferenceFromParameterlessLambda.symbols b/tests/baselines/reference/inferenceFromParameterlessLambda.symbols index 6170a4d1149..3e17cdfb2a4 100644 --- a/tests/baselines/reference/inferenceFromParameterlessLambda.symbols +++ b/tests/baselines/reference/inferenceFromParameterlessLambda.symbols @@ -28,7 +28,7 @@ interface Take { foo(n => n.length, () => 'hi'); >foo : Symbol(foo, Decl(inferenceFromParameterlessLambda.ts, 0, 0)) >n : Symbol(n, Decl(inferenceFromParameterlessLambda.ts, 8, 4)) ->n.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>n.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(inferenceFromParameterlessLambda.ts, 8, 4)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols index 3fee48fc837..07812704840 100644 --- a/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols +++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod1.symbols @@ -30,9 +30,9 @@ foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } } >foo : Symbol(foo, Decl(inferentialTypingObjectLiteralMethod1.ts, 2, 1)) >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 9)) >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 17)) ->p1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>p1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 17)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 46)) >p2 : Symbol(p2, Decl(inferentialTypingObjectLiteralMethod1.ts, 4, 54)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols index fc8d39858b6..2f4aa942b91 100644 --- a/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols +++ b/tests/baselines/reference/inferentialTypingObjectLiteralMethod2.symbols @@ -30,9 +30,9 @@ foo("", { method(p1) { return p1.length } }, { method(p2) { return undefined } } >foo : Symbol(foo, Decl(inferentialTypingObjectLiteralMethod2.ts, 2, 1)) >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 9)) >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 17)) ->p1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>p1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >p1 : Symbol(p1, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 17)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >method : Symbol(method, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 46)) >p2 : Symbol(p2, Decl(inferentialTypingObjectLiteralMethod2.ts, 4, 54)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType1.symbols b/tests/baselines/reference/inferentialTypingUsingApparentType1.symbols index 4babc614183..e8d66f2bbcb 100644 --- a/tests/baselines/reference/inferentialTypingUsingApparentType1.symbols +++ b/tests/baselines/reference/inferentialTypingUsingApparentType1.symbols @@ -14,7 +14,7 @@ function foo number>(x: T): T { foo(x => x.length); >foo : Symbol(foo, Decl(inferentialTypingUsingApparentType1.ts, 0, 0)) >x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 4, 4)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(inferentialTypingUsingApparentType1.ts, 4, 4)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/inferentialTypingUsingApparentType2.symbols b/tests/baselines/reference/inferentialTypingUsingApparentType2.symbols index 3c47eb4c697..e1525c50012 100644 --- a/tests/baselines/reference/inferentialTypingUsingApparentType2.symbols +++ b/tests/baselines/reference/inferentialTypingUsingApparentType2.symbols @@ -16,7 +16,7 @@ foo({ m(x) { return x.length } }); >foo : Symbol(foo, Decl(inferentialTypingUsingApparentType2.ts, 0, 0)) >m : Symbol(m, Decl(inferentialTypingUsingApparentType2.ts, 4, 5)) >x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 4, 8)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(inferentialTypingUsingApparentType2.ts, 4, 8)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols b/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols index 5fcc91d816e..c6ac17b0ccb 100644 --- a/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols +++ b/tests/baselines/reference/inferentialTypingWithFunctionType2.symbols @@ -11,7 +11,7 @@ function identity(a: A): A { } var x = [1, 2, 3].map(identity)[0]; >x : Symbol(x, Decl(inferentialTypingWithFunctionType2.ts, 3, 3)) ->[1, 2, 3].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>[1, 2, 3].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >identity : Symbol(identity, Decl(inferentialTypingWithFunctionType2.ts, 0, 0)) diff --git a/tests/baselines/reference/inheritance1.errors.txt b/tests/baselines/reference/inheritance1.errors.txt index f33dd120e76..d980b884ebf 100644 --- a/tests/baselines/reference/inheritance1.errors.txt +++ b/tests/baselines/reference/inheritance1.errors.txt @@ -7,9 +7,11 @@ tests/cases/compiler/inheritance1.ts(31,1): error TS2322: Type 'Control' is not tests/cases/compiler/inheritance1.ts(37,1): error TS2322: Type 'Control' is not assignable to type 'TextBox'. Property 'select' is missing in type 'Control'. tests/cases/compiler/inheritance1.ts(40,1): error TS2322: Type 'ImageBase' is not assignable to type 'SelectableControl'. + Property 'select' is missing in type 'ImageBase'. tests/cases/compiler/inheritance1.ts(46,1): error TS2322: Type 'Image1' is not assignable to type 'SelectableControl'. Property 'select' is missing in type 'Image1'. tests/cases/compiler/inheritance1.ts(52,1): error TS2322: Type 'Locations' is not assignable to type 'SelectableControl'. + Property 'state' is missing in type 'Locations'. tests/cases/compiler/inheritance1.ts(53,1): error TS2322: Type 'Locations' is not assignable to type 'Control'. Property 'state' is missing in type 'Locations'. tests/cases/compiler/inheritance1.ts(55,1): error TS2322: Type 'Control' is not assignable to type 'Locations'. @@ -77,6 +79,7 @@ tests/cases/compiler/inheritance1.ts(61,1): error TS2322: Type 'Control' is not sc = i; ~~ !!! error TS2322: Type 'ImageBase' is not assignable to type 'SelectableControl'. +!!! error TS2322: Property 'select' is missing in type 'ImageBase'. c = i; i = sc; i = c; @@ -94,6 +97,7 @@ tests/cases/compiler/inheritance1.ts(61,1): error TS2322: Type 'Control' is not sc = l; ~~ !!! error TS2322: Type 'Locations' is not assignable to type 'SelectableControl'. +!!! error TS2322: Property 'state' is missing in type 'Locations'. c = l; ~ !!! error TS2322: Type 'Locations' is not assignable to type 'Control'. diff --git a/tests/baselines/reference/inheritanceOfGenericConstructorMethod1.symbols b/tests/baselines/reference/inheritanceOfGenericConstructorMethod1.symbols index 9c65c2e3655..108170e8895 100644 --- a/tests/baselines/reference/inheritanceOfGenericConstructorMethod1.symbols +++ b/tests/baselines/reference/inheritanceOfGenericConstructorMethod1.symbols @@ -12,7 +12,7 @@ class B extends A {} var a = new A(); >a : Symbol(a, Decl(inheritanceOfGenericConstructorMethod1.ts, 2, 3)) >A : Symbol(A, Decl(inheritanceOfGenericConstructorMethod1.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var b1 = new B(); // no error >b1 : Symbol(b1, Decl(inheritanceOfGenericConstructorMethod1.ts, 3, 3)) @@ -21,12 +21,12 @@ var b1 = new B(); // no error var b2: B = new B(); // no error >b2 : Symbol(b2, Decl(inheritanceOfGenericConstructorMethod1.ts, 4, 3)) >B : Symbol(B, Decl(inheritanceOfGenericConstructorMethod1.ts, 0, 14)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >B : Symbol(B, Decl(inheritanceOfGenericConstructorMethod1.ts, 0, 14)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var b3 = new B(); // error, could not select overload for 'new' expression >b3 : Symbol(b3, Decl(inheritanceOfGenericConstructorMethod1.ts, 5, 3)) >B : Symbol(B, Decl(inheritanceOfGenericConstructorMethod1.ts, 0, 14)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols b/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols index a76a4aad7fa..b4e6eac2183 100644 --- a/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols +++ b/tests/baselines/reference/inheritedFunctionAssignmentCompatibility.symbols @@ -1,7 +1,7 @@ === tests/cases/compiler/inheritedFunctionAssignmentCompatibility.ts === interface IResultCallback extends Function { } >IResultCallback : Symbol(IResultCallback, Decl(inheritedFunctionAssignmentCompatibility.ts, 0, 0)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function fn(cb: IResultCallback) { } >fn : Symbol(fn, Decl(inheritedFunctionAssignmentCompatibility.ts, 0, 46)) diff --git a/tests/baselines/reference/inheritedGenericCallSignature.symbols b/tests/baselines/reference/inheritedGenericCallSignature.symbols index 49170401165..f70e4c7d75f 100644 --- a/tests/baselines/reference/inheritedGenericCallSignature.symbols +++ b/tests/baselines/reference/inheritedGenericCallSignature.symbols @@ -13,7 +13,7 @@ interface I1 { interface Object {} ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11), Decl(inheritedGenericCallSignature.ts, 5, 1)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(inheritedGenericCallSignature.ts, 5, 1)) @@ -34,7 +34,7 @@ interface I2 extends I1 { var x: I2; >x : Symbol(x, Decl(inheritedGenericCallSignature.ts, 20, 3)) >I2 : Symbol(I2, Decl(inheritedGenericCallSignature.ts, 8, 19)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) @@ -44,7 +44,7 @@ var y = x(undefined); >undefined : Symbol(undefined) y.length; // should not error ->y.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>y.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(inheritedGenericCallSignature.ts, 24, 3)) ->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.symbols b/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.symbols index 1b1c6b21beb..1a204dd9f32 100644 --- a/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.symbols +++ b/tests/baselines/reference/inheritedOverloadedSpecializedSignatures.symbols @@ -20,9 +20,9 @@ var b:B; // Should not error b('foo').charAt(0); ->b('foo').charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>b('foo').charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(inheritedOverloadedSpecializedSignatures.ts, 8, 3)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) interface A { >A : Symbol(A, Decl(inheritedOverloadedSpecializedSignatures.ts, 0, 0), Decl(inheritedOverloadedSpecializedSignatures.ts, 10, 19), Decl(inheritedOverloadedSpecializedSignatures.ts, 19, 1)) diff --git a/tests/baselines/reference/initializersInAmbientEnums.js b/tests/baselines/reference/initializersInAmbientEnums.js new file mode 100644 index 00000000000..21e13ade9c4 --- /dev/null +++ b/tests/baselines/reference/initializersInAmbientEnums.js @@ -0,0 +1,8 @@ +//// [initializersInAmbientEnums.ts] +declare enum E { + a = 10, + b = a, + e = 10 << 2 * 8, +} + +//// [initializersInAmbientEnums.js] diff --git a/tests/baselines/reference/initializersInAmbientEnums.symbols b/tests/baselines/reference/initializersInAmbientEnums.symbols new file mode 100644 index 00000000000..fc4f01b9096 --- /dev/null +++ b/tests/baselines/reference/initializersInAmbientEnums.symbols @@ -0,0 +1,14 @@ +=== tests/cases/compiler/initializersInAmbientEnums.ts === +declare enum E { +>E : Symbol(E, Decl(initializersInAmbientEnums.ts, 0, 0)) + + a = 10, +>a : Symbol(E.a, Decl(initializersInAmbientEnums.ts, 0, 16)) + + b = a, +>b : Symbol(E.b, Decl(initializersInAmbientEnums.ts, 1, 11)) +>a : Symbol(E.a, Decl(initializersInAmbientEnums.ts, 0, 16)) + + e = 10 << 2 * 8, +>e : Symbol(E.e, Decl(initializersInAmbientEnums.ts, 2, 10)) +} diff --git a/tests/baselines/reference/initializersInAmbientEnums.types b/tests/baselines/reference/initializersInAmbientEnums.types new file mode 100644 index 00000000000..40996e9b40a --- /dev/null +++ b/tests/baselines/reference/initializersInAmbientEnums.types @@ -0,0 +1,20 @@ +=== tests/cases/compiler/initializersInAmbientEnums.ts === +declare enum E { +>E : E + + a = 10, +>a : E +>10 : number + + b = a, +>b : E +>a : E + + e = 10 << 2 * 8, +>e : E +>10 << 2 * 8 : number +>10 : number +>2 * 8 : number +>2 : number +>8 : number +} diff --git a/tests/baselines/reference/initializersInDeclarations.errors.txt b/tests/baselines/reference/initializersInDeclarations.errors.txt index 9840181e092..a3eeecfe253 100644 --- a/tests/baselines/reference/initializersInDeclarations.errors.txt +++ b/tests/baselines/reference/initializersInDeclarations.errors.txt @@ -1,6 +1,6 @@ tests/cases/conformance/externalModules/initializersInDeclarations.ts(5,9): error TS1039: Initializers are not allowed in ambient contexts. tests/cases/conformance/externalModules/initializersInDeclarations.ts(6,16): error TS1039: Initializers are not allowed in ambient contexts. -tests/cases/conformance/externalModules/initializersInDeclarations.ts(7,16): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/externalModules/initializersInDeclarations.ts(7,16): error TS1183: An implementation cannot be declared in ambient contexts. tests/cases/conformance/externalModules/initializersInDeclarations.ts(12,15): error TS1039: Initializers are not allowed in ambient contexts. tests/cases/conformance/externalModules/initializersInDeclarations.ts(13,15): error TS1039: Initializers are not allowed in ambient contexts. tests/cases/conformance/externalModules/initializersInDeclarations.ts(16,2): error TS1036: Statements are not allowed in ambient contexts. @@ -20,7 +20,7 @@ tests/cases/conformance/externalModules/initializersInDeclarations.ts(18,16): er !!! error TS1039: Initializers are not allowed in ambient contexts. fn(): boolean { ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. return false; } } diff --git a/tests/baselines/reference/innerBoundLambdaEmit.symbols b/tests/baselines/reference/innerBoundLambdaEmit.symbols index 689aa7d075b..48bbe1fad4b 100644 --- a/tests/baselines/reference/innerBoundLambdaEmit.symbols +++ b/tests/baselines/reference/innerBoundLambdaEmit.symbols @@ -9,8 +9,8 @@ module M { >bar : Symbol(bar, Decl(innerBoundLambdaEmit.ts, 3, 7)) } interface Array { ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11), Decl(innerBoundLambdaEmit.ts, 4, 1)) ->T : Symbol(T, Decl(lib.d.ts, 1007, 16), Decl(innerBoundLambdaEmit.ts, 5, 16)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(innerBoundLambdaEmit.ts, 4, 1)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(innerBoundLambdaEmit.ts, 5, 16)) toFoo(): M.Foo >toFoo : Symbol(toFoo, Decl(innerBoundLambdaEmit.ts, 5, 20)) diff --git a/tests/baselines/reference/innerTypeParameterShadowingOuterOne.symbols b/tests/baselines/reference/innerTypeParameterShadowingOuterOne.symbols index b890c6c9ecf..36502a9988d 100644 --- a/tests/baselines/reference/innerTypeParameterShadowingOuterOne.symbols +++ b/tests/baselines/reference/innerTypeParameterShadowingOuterOne.symbols @@ -5,63 +5,63 @@ function f() { >f : Symbol(f, Decl(innerTypeParameterShadowingOuterOne.ts, 0, 0)) >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 3, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function g() { >g : Symbol(g, Decl(innerTypeParameterShadowingOuterOne.ts, 3, 30)) >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 4, 15)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var x: T; >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 5, 11)) >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 4, 15)) x.toFixed(); ->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 5, 11)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } var x: T; >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 8, 7)) >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 3, 11)) x.getDate(); ->x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 8, 7)) ->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) } function f2() { >f2 : Symbol(f2, Decl(innerTypeParameterShadowingOuterOne.ts, 10, 1)) >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 12, 12)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne.ts, 12, 27)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function g() { >g : Symbol(g, Decl(innerTypeParameterShadowingOuterOne.ts, 12, 47)) >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne.ts, 13, 15)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne.ts, 13, 32)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var x: U; >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 14, 11)) >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne.ts, 13, 32)) x.toFixed(); ->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 14, 11)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } var x: U; >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 17, 7)) >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne.ts, 12, 27)) x.getDate(); ->x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne.ts, 17, 7)) ->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) } //function f2() { // function g() { diff --git a/tests/baselines/reference/innerTypeParameterShadowingOuterOne2.symbols b/tests/baselines/reference/innerTypeParameterShadowingOuterOne2.symbols index 13afcb3e123..e19ab7aad28 100644 --- a/tests/baselines/reference/innerTypeParameterShadowingOuterOne2.symbols +++ b/tests/baselines/reference/innerTypeParameterShadowingOuterOne2.symbols @@ -5,21 +5,21 @@ class C { >C : Symbol(C, Decl(innerTypeParameterShadowingOuterOne2.ts, 0, 0)) >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 3, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) g() { >g : Symbol(g, Decl(innerTypeParameterShadowingOuterOne2.ts, 3, 25)) >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 4, 6)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var x: T; >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne2.ts, 5, 11)) >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 4, 6)) x.toFixed(); ->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne2.ts, 5, 11)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } h() { @@ -30,34 +30,34 @@ class C { >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 3, 8)) x.getDate(); ->x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne2.ts, 10, 11)) ->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) } } class C2 { >C2 : Symbol(C2, Decl(innerTypeParameterShadowingOuterOne2.ts, 13, 1)) >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 15, 9)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne2.ts, 15, 24)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) g() { >g : Symbol(g, Decl(innerTypeParameterShadowingOuterOne2.ts, 15, 42)) >T : Symbol(T, Decl(innerTypeParameterShadowingOuterOne2.ts, 16, 6)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne2.ts, 16, 23)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var x: U; >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne2.ts, 17, 11)) >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne2.ts, 16, 23)) x.toFixed(); ->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne2.ts, 17, 11)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } h() { @@ -68,9 +68,9 @@ class C2 { >U : Symbol(U, Decl(innerTypeParameterShadowingOuterOne2.ts, 15, 24)) x.getDate(); ->x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(innerTypeParameterShadowingOuterOne2.ts, 22, 11)) ->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) } } //class C2 { diff --git a/tests/baselines/reference/instanceAndStaticDeclarations1.symbols b/tests/baselines/reference/instanceAndStaticDeclarations1.symbols index 518d899eabf..8e9d4a320a0 100644 --- a/tests/baselines/reference/instanceAndStaticDeclarations1.symbols +++ b/tests/baselines/reference/instanceAndStaticDeclarations1.symbols @@ -18,23 +18,23 @@ class Point { >this.x : Symbol(x, Decl(instanceAndStaticDeclarations1.ts, 3, 16)) >this : Symbol(Point, Decl(instanceAndStaticDeclarations1.ts, 0, 0)) >x : Symbol(x, Decl(instanceAndStaticDeclarations1.ts, 3, 16)) ->p.x : Symbol(x, Decl(instanceAndStaticDeclarations1.ts, 3, 16)) +>p.x : Symbol(Point.x, Decl(instanceAndStaticDeclarations1.ts, 3, 16)) >p : Symbol(p, Decl(instanceAndStaticDeclarations1.ts, 4, 20)) ->x : Symbol(x, Decl(instanceAndStaticDeclarations1.ts, 3, 16)) +>x : Symbol(Point.x, Decl(instanceAndStaticDeclarations1.ts, 3, 16)) var dy = this.y - p.y; >dy : Symbol(dy, Decl(instanceAndStaticDeclarations1.ts, 6, 11)) >this.y : Symbol(y, Decl(instanceAndStaticDeclarations1.ts, 3, 33)) >this : Symbol(Point, Decl(instanceAndStaticDeclarations1.ts, 0, 0)) >y : Symbol(y, Decl(instanceAndStaticDeclarations1.ts, 3, 33)) ->p.y : Symbol(y, Decl(instanceAndStaticDeclarations1.ts, 3, 33)) +>p.y : Symbol(Point.y, Decl(instanceAndStaticDeclarations1.ts, 3, 33)) >p : Symbol(p, Decl(instanceAndStaticDeclarations1.ts, 4, 20)) ->y : Symbol(y, Decl(instanceAndStaticDeclarations1.ts, 3, 33)) +>y : Symbol(Point.y, Decl(instanceAndStaticDeclarations1.ts, 3, 33)) return Math.sqrt(dx * dx + dy * dy); ->Math.sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, 620, 27)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, 620, 27)) +>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, --, --)) >dx : Symbol(dx, Decl(instanceAndStaticDeclarations1.ts, 5, 11)) >dx : Symbol(dx, Decl(instanceAndStaticDeclarations1.ts, 5, 11)) >dy : Symbol(dy, Decl(instanceAndStaticDeclarations1.ts, 6, 11)) @@ -50,8 +50,8 @@ class Point { >Point : Symbol(Point, Decl(instanceAndStaticDeclarations1.ts, 0, 0)) >p2 : Symbol(p2, Decl(instanceAndStaticDeclarations1.ts, 10, 30)) >Point : Symbol(Point, Decl(instanceAndStaticDeclarations1.ts, 0, 0)) ->p1.distance : Symbol(distance, Decl(instanceAndStaticDeclarations1.ts, 3, 55)) +>p1.distance : Symbol(Point.distance, Decl(instanceAndStaticDeclarations1.ts, 3, 55)) >p1 : Symbol(p1, Decl(instanceAndStaticDeclarations1.ts, 10, 20)) ->distance : Symbol(distance, Decl(instanceAndStaticDeclarations1.ts, 3, 55)) +>distance : Symbol(Point.distance, Decl(instanceAndStaticDeclarations1.ts, 3, 55)) >p2 : Symbol(p2, Decl(instanceAndStaticDeclarations1.ts, 10, 30)) } diff --git a/tests/baselines/reference/instanceAndStaticDeclarations1.types b/tests/baselines/reference/instanceAndStaticDeclarations1.types index 9d6ba692735..cbed990690d 100644 --- a/tests/baselines/reference/instanceAndStaticDeclarations1.types +++ b/tests/baselines/reference/instanceAndStaticDeclarations1.types @@ -17,7 +17,7 @@ class Point { >dx : number >this.x - p.x : number >this.x : number ->this : Point +>this : this >x : number >p.x : number >p : Point @@ -27,7 +27,7 @@ class Point { >dy : number >this.y - p.y : number >this.y : number ->this : Point +>this : this >y : number >p.y : number >p : Point diff --git a/tests/baselines/reference/instanceOfAssignability.symbols b/tests/baselines/reference/instanceOfAssignability.symbols index b01f29a5faf..1bf39df2dd2 100644 --- a/tests/baselines/reference/instanceOfAssignability.symbols +++ b/tests/baselines/reference/instanceOfAssignability.symbols @@ -48,12 +48,12 @@ class Giraffe extends Mammal { neck; } function fn1(x: Array|Array|boolean) { >fn1 : Symbol(fn1, Decl(instanceOfAssignability.ts, 19, 38)) >x : Symbol(x, Decl(instanceOfAssignability.ts, 21, 13)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) if(x instanceof Array) { >x : Symbol(x, Decl(instanceOfAssignability.ts, 21, 13)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) // 1.5: y: Array|Array // Want: y: Array|Array @@ -154,12 +154,12 @@ function fn6(x: Animal|Mammal) { function fn7(x: Array|Array) { >fn7 : Symbol(fn7, Decl(instanceOfAssignability.ts, 67, 1)) >x : Symbol(x, Decl(instanceOfAssignability.ts, 69, 13)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) if(x instanceof Array) { >x : Symbol(x, Decl(instanceOfAssignability.ts, 69, 13)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) // 1.5: y: Array|Array // Want: y: Array|Array diff --git a/tests/baselines/reference/instanceofOperatorWithLHSIsObject.symbols b/tests/baselines/reference/instanceofOperatorWithLHSIsObject.symbols index 44859d83f72..481e241d69d 100644 --- a/tests/baselines/reference/instanceofOperatorWithLHSIsObject.symbols +++ b/tests/baselines/reference/instanceofOperatorWithLHSIsObject.symbols @@ -7,14 +7,14 @@ var x1: any; var x2: Function; >x2 : Symbol(x2, Decl(instanceofOperatorWithLHSIsObject.ts, 3, 3)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a: {}; >a : Symbol(a, Decl(instanceofOperatorWithLHSIsObject.ts, 5, 3)) var b: Object; >b : Symbol(b, Decl(instanceofOperatorWithLHSIsObject.ts, 6, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var c: C; >c : Symbol(c, Decl(instanceofOperatorWithLHSIsObject.ts, 7, 3)) diff --git a/tests/baselines/reference/instanceofOperatorWithRHSIsSubtypeOfFunction.symbols b/tests/baselines/reference/instanceofOperatorWithRHSIsSubtypeOfFunction.symbols index e15f4b7ea45..5d02ff54ae2 100644 --- a/tests/baselines/reference/instanceofOperatorWithRHSIsSubtypeOfFunction.symbols +++ b/tests/baselines/reference/instanceofOperatorWithRHSIsSubtypeOfFunction.symbols @@ -1,14 +1,14 @@ === tests/cases/conformance/expressions/binaryOperators/instanceofOperator/instanceofOperatorWithRHSIsSubtypeOfFunction.ts === interface I extends Function { } >I : Symbol(I, Decl(instanceofOperatorWithRHSIsSubtypeOfFunction.ts, 0, 0)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var x: any; >x : Symbol(x, Decl(instanceofOperatorWithRHSIsSubtypeOfFunction.ts, 2, 3)) var f1: Function; >f1 : Symbol(f1, Decl(instanceofOperatorWithRHSIsSubtypeOfFunction.ts, 3, 3)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var f2: I; >f2 : Symbol(f2, Decl(instanceofOperatorWithRHSIsSubtypeOfFunction.ts, 4, 3)) diff --git a/tests/baselines/reference/interfaceContextualType.types b/tests/baselines/reference/interfaceContextualType.types index 4b932a71538..e827f9a9d9b 100644 --- a/tests/baselines/reference/interfaceContextualType.types +++ b/tests/baselines/reference/interfaceContextualType.types @@ -29,7 +29,7 @@ class Bug { this.values = {}; >this.values = {} : { [x: string]: undefined; } >this.values : IMap ->this : Bug +>this : this >values : IMap >{} : { [x: string]: undefined; } @@ -37,7 +37,7 @@ class Bug { >this.values['comments'] = { italic: true } : { italic: boolean; } >this.values['comments'] : IOptions >this.values : IMap ->this : Bug +>this : this >values : IMap >'comments' : string >{ italic: true } : { italic: boolean; } @@ -50,7 +50,7 @@ class Bug { this.values = { >this.values = { comments: { italic: true } } : { [x: string]: { italic: boolean; }; comments: { italic: boolean; }; } >this.values : IMap ->this : Bug +>this : this >values : IMap >{ comments: { italic: true } } : { [x: string]: { italic: boolean; }; comments: { italic: boolean; }; } diff --git a/tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.symbols b/tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.symbols index 6b45cd1daad..8e5f0413299 100644 --- a/tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.symbols +++ b/tests/baselines/reference/interfaceDoesNotDependOnBaseTypes.symbols @@ -7,14 +7,14 @@ if (typeof x !== "string") { >x : Symbol(x, Decl(interfaceDoesNotDependOnBaseTypes.ts, 0, 3)) x.push(""); ->x.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(interfaceDoesNotDependOnBaseTypes.ts, 0, 3)) ->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) x.push([""]); ->x.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>x.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(interfaceDoesNotDependOnBaseTypes.ts, 0, 3)) ->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) } type StringTree = string | StringTreeArray; @@ -23,6 +23,6 @@ type StringTree = string | StringTreeArray; interface StringTreeArray extends Array { } >StringTreeArray : Symbol(StringTreeArray, Decl(interfaceDoesNotDependOnBaseTypes.ts, 6, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >StringTree : Symbol(StringTree, Decl(interfaceDoesNotDependOnBaseTypes.ts, 4, 1)) diff --git a/tests/baselines/reference/interfaceWithOverloadedCallAndConstructSignatures.symbols b/tests/baselines/reference/interfaceWithOverloadedCallAndConstructSignatures.symbols index 28dcb55238b..f544aac424d 100644 --- a/tests/baselines/reference/interfaceWithOverloadedCallAndConstructSignatures.symbols +++ b/tests/baselines/reference/interfaceWithOverloadedCallAndConstructSignatures.symbols @@ -9,7 +9,7 @@ interface Foo { new (): any; new (x: string): Object; >x : Symbol(x, Decl(interfaceWithOverloadedCallAndConstructSignatures.ts, 5, 9)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var f: Foo; diff --git a/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols b/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols index 46c8e92261f..f248bba02f0 100644 --- a/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols +++ b/tests/baselines/reference/interfaceWithPropertyOfEveryType.symbols @@ -39,7 +39,7 @@ interface Foo { g: Object; >g : Symbol(g, Decl(interfaceWithPropertyOfEveryType.ts, 13, 16)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) h: (x: number) => number; >h : Symbol(h, Decl(interfaceWithPropertyOfEveryType.ts, 14, 14)) diff --git a/tests/baselines/reference/interfaceWithSpecializedCallAndConstructSignatures.symbols b/tests/baselines/reference/interfaceWithSpecializedCallAndConstructSignatures.symbols index 40ec7863a04..1d4a024294f 100644 --- a/tests/baselines/reference/interfaceWithSpecializedCallAndConstructSignatures.symbols +++ b/tests/baselines/reference/interfaceWithSpecializedCallAndConstructSignatures.symbols @@ -13,7 +13,7 @@ interface Foo { new (x: string): Object; >x : Symbol(x, Decl(interfaceWithSpecializedCallAndConstructSignatures.ts, 5, 9)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var f: Foo; diff --git a/tests/baselines/reference/invalidSplice.symbols b/tests/baselines/reference/invalidSplice.symbols index dc028776cb3..5aceb66a227 100644 --- a/tests/baselines/reference/invalidSplice.symbols +++ b/tests/baselines/reference/invalidSplice.symbols @@ -1,6 +1,6 @@ === tests/cases/compiler/invalidSplice.ts === var arr = [].splice(0,3,4,5); >arr : Symbol(arr, Decl(invalidSplice.ts, 0, 3)) ->[].splice : Symbol(Array.splice, Decl(lib.d.ts, 1060, 50), Decl(lib.d.ts, 1066, 31)) ->splice : Symbol(Array.splice, Decl(lib.d.ts, 1060, 50), Decl(lib.d.ts, 1066, 31)) +>[].splice : Symbol(Array.splice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>splice : Symbol(Array.splice, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/isArray.symbols b/tests/baselines/reference/isArray.symbols index 75351b377be..b60123e6b2e 100644 --- a/tests/baselines/reference/isArray.symbols +++ b/tests/baselines/reference/isArray.symbols @@ -4,19 +4,19 @@ var maybeArray: number | number[]; if (Array.isArray(maybeArray)) { ->Array.isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, 1166, 28)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) ->isArray : Symbol(ArrayConstructor.isArray, Decl(lib.d.ts, 1166, 28)) +>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, --, --)) >maybeArray : Symbol(maybeArray, Decl(isArray.ts, 0, 3)) maybeArray.length; // OK ->maybeArray.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>maybeArray.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >maybeArray : Symbol(maybeArray, Decl(isArray.ts, 0, 3)) ->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) } else { maybeArray.toFixed(); // OK ->maybeArray.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>maybeArray.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >maybeArray : Symbol(maybeArray, Decl(isArray.ts, 0, 3)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols b/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols index 659a1330616..2af21772cfb 100644 --- a/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols +++ b/tests/baselines/reference/isDeclarationVisibleNodeKinds.symbols @@ -127,7 +127,7 @@ module schema { 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)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>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)) diff --git a/tests/baselines/reference/isolatedModulesPlainFile-UMD.js b/tests/baselines/reference/isolatedModulesPlainFile-UMD.js index 0ed6e83a37f..b4f8cf436ec 100644 --- a/tests/baselines/reference/isolatedModulesPlainFile-UMD.js +++ b/tests/baselines/reference/isolatedModulesPlainFile-UMD.js @@ -5,13 +5,13 @@ run(1); //// [isolatedModulesPlainFile-UMD.js] -(function (deps, factory) { +(function (factory) { if (typeof module === 'object' && typeof module.exports === 'object') { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === 'function' && define.amd) { - define(deps, factory); + define(["require", "exports"], factory); } -})(["require", "exports"], function (require, exports) { +})(function (require, exports) { run(1); }); diff --git a/tests/baselines/reference/iterableArrayPattern1.symbols b/tests/baselines/reference/iterableArrayPattern1.symbols index fae627e9c95..2877a2233da 100644 --- a/tests/baselines/reference/iterableArrayPattern1.symbols +++ b/tests/baselines/reference/iterableArrayPattern1.symbols @@ -13,7 +13,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iterableArrayPattern1.ts, 3, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) done: false >done : Symbol(done, Decl(iterableArrayPattern1.ts, 4, 28)) @@ -22,9 +22,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(SymbolIterator, Decl(iterableArrayPattern1.ts, 0, 32)) diff --git a/tests/baselines/reference/iterableArrayPattern1.types b/tests/baselines/reference/iterableArrayPattern1.types index 2cfd2354f31..a2c9807d26a 100644 --- a/tests/baselines/reference/iterableArrayPattern1.types +++ b/tests/baselines/reference/iterableArrayPattern1.types @@ -32,6 +32,6 @@ class SymbolIterator { >iterator : symbol return this; ->this : SymbolIterator +>this : this } } diff --git a/tests/baselines/reference/iterableArrayPattern11.symbols b/tests/baselines/reference/iterableArrayPattern11.symbols index fefeaced83f..6181edbf1fd 100644 --- a/tests/baselines/reference/iterableArrayPattern11.symbols +++ b/tests/baselines/reference/iterableArrayPattern11.symbols @@ -36,9 +36,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern11.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern11.types b/tests/baselines/reference/iterableArrayPattern11.types index 3118e748d6f..5ec182ec397 100644 --- a/tests/baselines/reference/iterableArrayPattern11.types +++ b/tests/baselines/reference/iterableArrayPattern11.types @@ -48,6 +48,6 @@ class FooIterator { >iterator : symbol return this; ->this : FooIterator +>this : this } } diff --git a/tests/baselines/reference/iterableArrayPattern12.symbols b/tests/baselines/reference/iterableArrayPattern12.symbols index fd00059449a..e4b4baf3bd5 100644 --- a/tests/baselines/reference/iterableArrayPattern12.symbols +++ b/tests/baselines/reference/iterableArrayPattern12.symbols @@ -36,9 +36,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern12.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern12.types b/tests/baselines/reference/iterableArrayPattern12.types index b32c2ff7dc8..89af4d47d01 100644 --- a/tests/baselines/reference/iterableArrayPattern12.types +++ b/tests/baselines/reference/iterableArrayPattern12.types @@ -48,6 +48,6 @@ class FooIterator { >iterator : symbol return this; ->this : FooIterator +>this : this } } diff --git a/tests/baselines/reference/iterableArrayPattern13.symbols b/tests/baselines/reference/iterableArrayPattern13.symbols index 8271e564f9e..02f219e7092 100644 --- a/tests/baselines/reference/iterableArrayPattern13.symbols +++ b/tests/baselines/reference/iterableArrayPattern13.symbols @@ -35,9 +35,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern13.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern13.types b/tests/baselines/reference/iterableArrayPattern13.types index 556a871f5a8..e8873a74b72 100644 --- a/tests/baselines/reference/iterableArrayPattern13.types +++ b/tests/baselines/reference/iterableArrayPattern13.types @@ -46,6 +46,6 @@ class FooIterator { >iterator : symbol return this; ->this : FooIterator +>this : this } } diff --git a/tests/baselines/reference/iterableArrayPattern2.symbols b/tests/baselines/reference/iterableArrayPattern2.symbols index d4f2949e24f..dad1262cee9 100644 --- a/tests/baselines/reference/iterableArrayPattern2.symbols +++ b/tests/baselines/reference/iterableArrayPattern2.symbols @@ -13,7 +13,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iterableArrayPattern2.ts, 3, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) done: false >done : Symbol(done, Decl(iterableArrayPattern2.ts, 4, 28)) @@ -22,9 +22,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(SymbolIterator, Decl(iterableArrayPattern2.ts, 0, 35)) diff --git a/tests/baselines/reference/iterableArrayPattern2.types b/tests/baselines/reference/iterableArrayPattern2.types index bd58cb86b79..48f44443591 100644 --- a/tests/baselines/reference/iterableArrayPattern2.types +++ b/tests/baselines/reference/iterableArrayPattern2.types @@ -32,6 +32,6 @@ class SymbolIterator { >iterator : symbol return this; ->this : SymbolIterator +>this : this } } diff --git a/tests/baselines/reference/iterableArrayPattern3.symbols b/tests/baselines/reference/iterableArrayPattern3.symbols index 9e38c52ad70..e0372862b9e 100644 --- a/tests/baselines/reference/iterableArrayPattern3.symbols +++ b/tests/baselines/reference/iterableArrayPattern3.symbols @@ -37,9 +37,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern3.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern3.types b/tests/baselines/reference/iterableArrayPattern3.types index fed5c7f07d3..dd001d46376 100644 --- a/tests/baselines/reference/iterableArrayPattern3.types +++ b/tests/baselines/reference/iterableArrayPattern3.types @@ -49,6 +49,6 @@ class FooIterator { >iterator : symbol return this; ->this : FooIterator +>this : this } } diff --git a/tests/baselines/reference/iterableArrayPattern30.symbols b/tests/baselines/reference/iterableArrayPattern30.symbols index 5a991f0d5b3..393d9fbca51 100644 --- a/tests/baselines/reference/iterableArrayPattern30.symbols +++ b/tests/baselines/reference/iterableArrayPattern30.symbols @@ -4,5 +4,5 @@ const [[k1, v1], [k2, v2]] = new Map([["", true], ["hello", true]]) >v1 : Symbol(v1, Decl(iterableArrayPattern30.ts, 0, 11)) >k2 : Symbol(k2, Decl(iterableArrayPattern30.ts, 0, 18)) >v2 : Symbol(v2, Decl(iterableArrayPattern30.ts, 0, 21)) ->Map : Symbol(Map, Decl(lib.d.ts, 4635, 1), Decl(lib.d.ts, 4658, 11)) +>Map : Symbol(Map, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/iterableArrayPattern4.symbols b/tests/baselines/reference/iterableArrayPattern4.symbols index d3a7f4fb1d7..fb1cce1b8f9 100644 --- a/tests/baselines/reference/iterableArrayPattern4.symbols +++ b/tests/baselines/reference/iterableArrayPattern4.symbols @@ -37,9 +37,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern4.ts, 3, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern4.types b/tests/baselines/reference/iterableArrayPattern4.types index 8f05a454b53..2d6531494a4 100644 --- a/tests/baselines/reference/iterableArrayPattern4.types +++ b/tests/baselines/reference/iterableArrayPattern4.types @@ -50,6 +50,6 @@ class FooIterator { >iterator : symbol return this; ->this : FooIterator +>this : this } } diff --git a/tests/baselines/reference/iterableArrayPattern9.symbols b/tests/baselines/reference/iterableArrayPattern9.symbols index efb88d2e608..07d580fcea1 100644 --- a/tests/baselines/reference/iterableArrayPattern9.symbols +++ b/tests/baselines/reference/iterableArrayPattern9.symbols @@ -32,9 +32,9 @@ class FooIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(FooIterator, Decl(iterableArrayPattern9.ts, 2, 27)) diff --git a/tests/baselines/reference/iterableArrayPattern9.types b/tests/baselines/reference/iterableArrayPattern9.types index 03cfa31b621..e9e342e7775 100644 --- a/tests/baselines/reference/iterableArrayPattern9.types +++ b/tests/baselines/reference/iterableArrayPattern9.types @@ -42,6 +42,6 @@ class FooIterator { >iterator : symbol return this; ->this : FooIterator +>this : this } } diff --git a/tests/baselines/reference/iterableContextualTyping1.symbols b/tests/baselines/reference/iterableContextualTyping1.symbols index f23d571d072..5af4fdbcd78 100644 --- a/tests/baselines/reference/iterableContextualTyping1.symbols +++ b/tests/baselines/reference/iterableContextualTyping1.symbols @@ -1,10 +1,10 @@ === tests/cases/conformance/expressions/contextualTyping/iterableContextualTyping1.ts === var iter: Iterable<(x: string) => number> = [s => s.length]; >iter : Symbol(iter, Decl(iterableContextualTyping1.ts, 0, 3)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(iterableContextualTyping1.ts, 0, 20)) >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45)) ->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>s.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(iterableContextualTyping1.ts, 0, 45)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/iteratorSpreadInArray.symbols b/tests/baselines/reference/iteratorSpreadInArray.symbols index 03099b124c9..d24abca314b 100644 --- a/tests/baselines/reference/iteratorSpreadInArray.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray.symbols @@ -12,7 +12,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray.ts, 5, 28)) @@ -21,9 +21,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray.ts, 0, 36)) diff --git a/tests/baselines/reference/iteratorSpreadInArray.types b/tests/baselines/reference/iteratorSpreadInArray.types index 2c4a1d207ef..780acf32fab 100644 --- a/tests/baselines/reference/iteratorSpreadInArray.types +++ b/tests/baselines/reference/iteratorSpreadInArray.types @@ -33,6 +33,6 @@ class SymbolIterator { >iterator : symbol return this; ->this : SymbolIterator +>this : this } } diff --git a/tests/baselines/reference/iteratorSpreadInArray11.symbols b/tests/baselines/reference/iteratorSpreadInArray11.symbols index a46d22a481a..f982bf2deab 100644 --- a/tests/baselines/reference/iteratorSpreadInArray11.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray11.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/spread/iteratorSpreadInArray11.ts === var iter: Iterable; >iter : Symbol(iter, Decl(iteratorSpreadInArray11.ts, 0, 3)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) var array = [...iter]; >array : Symbol(array, Decl(iteratorSpreadInArray11.ts, 1, 3)) diff --git a/tests/baselines/reference/iteratorSpreadInArray2.symbols b/tests/baselines/reference/iteratorSpreadInArray2.symbols index 906e8288af0..029d83d2111 100644 --- a/tests/baselines/reference/iteratorSpreadInArray2.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray2.symbols @@ -13,7 +13,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray2.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray2.ts, 5, 28)) @@ -22,9 +22,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray2.ts, 0, 59)) @@ -48,9 +48,9 @@ class NumberIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(NumberIterator, Decl(iteratorSpreadInArray2.ts, 13, 1)) diff --git a/tests/baselines/reference/iteratorSpreadInArray2.types b/tests/baselines/reference/iteratorSpreadInArray2.types index a59c2cf6c67..f2e64e5282e 100644 --- a/tests/baselines/reference/iteratorSpreadInArray2.types +++ b/tests/baselines/reference/iteratorSpreadInArray2.types @@ -36,7 +36,7 @@ class SymbolIterator { >iterator : symbol return this; ->this : SymbolIterator +>this : this } } @@ -66,6 +66,6 @@ class NumberIterator { >iterator : symbol return this; ->this : NumberIterator +>this : this } } diff --git a/tests/baselines/reference/iteratorSpreadInArray3.symbols b/tests/baselines/reference/iteratorSpreadInArray3.symbols index e25374c80a8..05f90d44174 100644 --- a/tests/baselines/reference/iteratorSpreadInArray3.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray3.symbols @@ -12,7 +12,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray3.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray3.ts, 5, 28)) @@ -21,9 +21,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray3.ts, 0, 47)) diff --git a/tests/baselines/reference/iteratorSpreadInArray3.types b/tests/baselines/reference/iteratorSpreadInArray3.types index 0374f28b6b9..a59da81e157 100644 --- a/tests/baselines/reference/iteratorSpreadInArray3.types +++ b/tests/baselines/reference/iteratorSpreadInArray3.types @@ -37,6 +37,6 @@ class SymbolIterator { >iterator : symbol return this; ->this : SymbolIterator +>this : this } } diff --git a/tests/baselines/reference/iteratorSpreadInArray4.symbols b/tests/baselines/reference/iteratorSpreadInArray4.symbols index 1856d1bb682..e7ace40c4de 100644 --- a/tests/baselines/reference/iteratorSpreadInArray4.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray4.symbols @@ -12,7 +12,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray4.ts, 4, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray4.ts, 5, 28)) @@ -21,9 +21,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray4.ts, 0, 42)) diff --git a/tests/baselines/reference/iteratorSpreadInArray4.types b/tests/baselines/reference/iteratorSpreadInArray4.types index d9a304421ba..0e16758acf4 100644 --- a/tests/baselines/reference/iteratorSpreadInArray4.types +++ b/tests/baselines/reference/iteratorSpreadInArray4.types @@ -35,6 +35,6 @@ class SymbolIterator { >iterator : symbol return this; ->this : SymbolIterator +>this : this } } diff --git a/tests/baselines/reference/iteratorSpreadInArray7.symbols b/tests/baselines/reference/iteratorSpreadInArray7.symbols index c68550b7fa7..e498e68b9eb 100644 --- a/tests/baselines/reference/iteratorSpreadInArray7.symbols +++ b/tests/baselines/reference/iteratorSpreadInArray7.symbols @@ -3,9 +3,9 @@ var array: symbol[]; >array : Symbol(array, Decl(iteratorSpreadInArray7.ts, 0, 3)) array.concat([...new SymbolIterator]); ->array.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>array.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >array : Symbol(array, Decl(iteratorSpreadInArray7.ts, 0, 3)) ->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >SymbolIterator : Symbol(SymbolIterator, Decl(iteratorSpreadInArray7.ts, 1, 38)) class SymbolIterator { @@ -17,7 +17,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInArray7.ts, 5, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) done: false >done : Symbol(done, Decl(iteratorSpreadInArray7.ts, 6, 28)) @@ -26,9 +26,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInArray7.ts, 1, 38)) diff --git a/tests/baselines/reference/iteratorSpreadInArray7.types b/tests/baselines/reference/iteratorSpreadInArray7.types index f207a56f3d5..6a279838060 100644 --- a/tests/baselines/reference/iteratorSpreadInArray7.types +++ b/tests/baselines/reference/iteratorSpreadInArray7.types @@ -39,6 +39,6 @@ class SymbolIterator { >iterator : symbol return this; ->this : SymbolIterator +>this : this } } diff --git a/tests/baselines/reference/iteratorSpreadInCall11.symbols b/tests/baselines/reference/iteratorSpreadInCall11.symbols index 874a034631d..e504283a3bd 100644 --- a/tests/baselines/reference/iteratorSpreadInCall11.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall11.symbols @@ -19,7 +19,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall11.ts, 6, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall11.ts, 7, 28)) @@ -28,9 +28,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall11.ts, 2, 42)) diff --git a/tests/baselines/reference/iteratorSpreadInCall11.types b/tests/baselines/reference/iteratorSpreadInCall11.types index edce8b10355..dd440a1b4ac 100644 --- a/tests/baselines/reference/iteratorSpreadInCall11.types +++ b/tests/baselines/reference/iteratorSpreadInCall11.types @@ -42,6 +42,6 @@ class SymbolIterator { >iterator : symbol return this; ->this : SymbolIterator +>this : this } } diff --git a/tests/baselines/reference/iteratorSpreadInCall12.symbols b/tests/baselines/reference/iteratorSpreadInCall12.symbols index 0f84a0e1cbb..4b7f553e969 100644 --- a/tests/baselines/reference/iteratorSpreadInCall12.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall12.symbols @@ -22,7 +22,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall12.ts, 8, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall12.ts, 9, 28)) @@ -31,9 +31,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall12.ts, 4, 1)) @@ -57,9 +57,9 @@ class StringIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(StringIterator, Decl(iteratorSpreadInCall12.ts, 17, 1)) diff --git a/tests/baselines/reference/iteratorSpreadInCall12.types b/tests/baselines/reference/iteratorSpreadInCall12.types index 4307daa78b0..5e3e7bcdbc4 100644 --- a/tests/baselines/reference/iteratorSpreadInCall12.types +++ b/tests/baselines/reference/iteratorSpreadInCall12.types @@ -49,7 +49,7 @@ class SymbolIterator { >iterator : symbol return this; ->this : SymbolIterator +>this : this } } @@ -79,6 +79,6 @@ class StringIterator { >iterator : symbol return this; ->this : StringIterator +>this : this } } diff --git a/tests/baselines/reference/iteratorSpreadInCall3.symbols b/tests/baselines/reference/iteratorSpreadInCall3.symbols index 6f329329431..402b156002f 100644 --- a/tests/baselines/reference/iteratorSpreadInCall3.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall3.symbols @@ -16,7 +16,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall3.ts, 5, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall3.ts, 6, 28)) @@ -25,9 +25,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall3.ts, 2, 32)) diff --git a/tests/baselines/reference/iteratorSpreadInCall3.types b/tests/baselines/reference/iteratorSpreadInCall3.types index b566c3866ff..54857755b55 100644 --- a/tests/baselines/reference/iteratorSpreadInCall3.types +++ b/tests/baselines/reference/iteratorSpreadInCall3.types @@ -37,6 +37,6 @@ class SymbolIterator { >iterator : symbol return this; ->this : SymbolIterator +>this : this } } diff --git a/tests/baselines/reference/iteratorSpreadInCall5.symbols b/tests/baselines/reference/iteratorSpreadInCall5.symbols index 01a0112b026..855b434f07c 100644 --- a/tests/baselines/reference/iteratorSpreadInCall5.symbols +++ b/tests/baselines/reference/iteratorSpreadInCall5.symbols @@ -17,7 +17,7 @@ class SymbolIterator { return { value: Symbol(), >value : Symbol(value, Decl(iteratorSpreadInCall5.ts, 5, 16)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) done: false >done : Symbol(done, Decl(iteratorSpreadInCall5.ts, 6, 28)) @@ -26,9 +26,9 @@ class SymbolIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(SymbolIterator, Decl(iteratorSpreadInCall5.ts, 2, 43)) @@ -52,9 +52,9 @@ class StringIterator { } [Symbol.iterator]() { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) return this; >this : Symbol(StringIterator, Decl(iteratorSpreadInCall5.ts, 14, 1)) diff --git a/tests/baselines/reference/iteratorSpreadInCall5.types b/tests/baselines/reference/iteratorSpreadInCall5.types index 631ad940554..043536ab4c0 100644 --- a/tests/baselines/reference/iteratorSpreadInCall5.types +++ b/tests/baselines/reference/iteratorSpreadInCall5.types @@ -40,7 +40,7 @@ class SymbolIterator { >iterator : symbol return this; ->this : SymbolIterator +>this : this } } @@ -70,6 +70,6 @@ class StringIterator { >iterator : symbol return this; ->this : StringIterator +>this : this } } diff --git a/tests/baselines/reference/jsxReactTestSuite.symbols b/tests/baselines/reference/jsxReactTestSuite.symbols index 1fe64cbfdd7..b86054ac560 100644 --- a/tests/baselines/reference/jsxReactTestSuite.symbols +++ b/tests/baselines/reference/jsxReactTestSuite.symbols @@ -145,6 +145,7 @@ var x = Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) >y : Symbol(unknown) ={2 } z />; @@ -167,25 +168,31 @@ var x = ; >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, 2, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) >y : Symbol(unknown) ; >Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) +>x : Symbol(x, Decl(jsxReactTestSuite.tsx, 10, 11), Decl(jsxReactTestSuite.tsx, 35, 3)) >y : Symbol(unknown) >z : Symbol(unknown) ; >Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) >x : Symbol(unknown) +>y : Symbol(y, Decl(jsxReactTestSuite.tsx, 9, 11)) ; >Component : Symbol(Component, Decl(jsxReactTestSuite.tsx, 2, 11)) >x : Symbol(unknown) >y : Symbol(unknown) +>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)) diff --git a/tests/baselines/reference/letDeclarations-access.symbols b/tests/baselines/reference/letDeclarations-access.symbols index dfc9ea4c533..060ebc80b80 100644 --- a/tests/baselines/reference/letDeclarations-access.symbols +++ b/tests/baselines/reference/letDeclarations-access.symbols @@ -81,7 +81,7 @@ x; >x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) x.toString(); ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(letDeclarations-access.ts, 1, 3)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/library_ArraySlice.symbols b/tests/baselines/reference/library_ArraySlice.symbols index 02c58859d40..f29defbc3f9 100644 --- a/tests/baselines/reference/library_ArraySlice.symbols +++ b/tests/baselines/reference/library_ArraySlice.symbols @@ -1,23 +1,23 @@ === tests/cases/compiler/library_ArraySlice.ts === // Array.prototype.slice can have zero, one, or two arguments Array.prototype.slice(); ->Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15)) ->Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) ->prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41)) ->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15)) +>Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) +>Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --)) +>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) Array.prototype.slice(0); ->Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15)) ->Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) ->prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41)) ->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15)) +>Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) +>Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --)) +>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) Array.prototype.slice(0, 1); ->Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15)) ->Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) ->prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41)) ->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15)) +>Array.prototype.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) +>Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --)) +>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/library_DatePrototypeProperties.symbols b/tests/baselines/reference/library_DatePrototypeProperties.symbols index c6d0b7e87fb..8aa5f81f2f5 100644 --- a/tests/baselines/reference/library_DatePrototypeProperties.symbols +++ b/tests/baselines/reference/library_DatePrototypeProperties.symbols @@ -2,310 +2,310 @@ // Properties of the Date prototype object as per ES5 spec // http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.5 Date.prototype.constructor; ->Date.prototype.constructor : Symbol(Object.constructor, Decl(lib.d.ts, 94, 18)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->constructor : Symbol(Object.constructor, Decl(lib.d.ts, 94, 18)) +>Date.prototype.constructor : Symbol(Object.constructor, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>constructor : Symbol(Object.constructor, Decl(lib.d.ts, --, --)) Date.prototype.toString(); ->Date.prototype.toString : Symbol(Date.toString, Decl(lib.d.ts, 636, 16)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->toString : Symbol(Date.toString, Decl(lib.d.ts, 636, 16)) +>Date.prototype.toString : Symbol(Date.toString, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>toString : Symbol(Date.toString, Decl(lib.d.ts, --, --)) Date.prototype.toDateString(); ->Date.prototype.toDateString : Symbol(Date.toDateString, Decl(lib.d.ts, 638, 23)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->toDateString : Symbol(Date.toDateString, Decl(lib.d.ts, 638, 23)) +>Date.prototype.toDateString : Symbol(Date.toDateString, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>toDateString : Symbol(Date.toDateString, Decl(lib.d.ts, --, --)) Date.prototype.toTimeString(); ->Date.prototype.toTimeString : Symbol(Date.toTimeString, Decl(lib.d.ts, 640, 27)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->toTimeString : Symbol(Date.toTimeString, Decl(lib.d.ts, 640, 27)) +>Date.prototype.toTimeString : Symbol(Date.toTimeString, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>toTimeString : Symbol(Date.toTimeString, Decl(lib.d.ts, --, --)) Date.prototype.toLocaleString(); ->Date.prototype.toLocaleString : Symbol(Date.toLocaleString, Decl(lib.d.ts, 642, 27)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->toLocaleString : Symbol(Date.toLocaleString, Decl(lib.d.ts, 642, 27)) +>Date.prototype.toLocaleString : Symbol(Date.toLocaleString, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>toLocaleString : Symbol(Date.toLocaleString, Decl(lib.d.ts, --, --)) Date.prototype.toLocaleDateString(); ->Date.prototype.toLocaleDateString : Symbol(Date.toLocaleDateString, Decl(lib.d.ts, 644, 29)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->toLocaleDateString : Symbol(Date.toLocaleDateString, Decl(lib.d.ts, 644, 29)) +>Date.prototype.toLocaleDateString : Symbol(Date.toLocaleDateString, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>toLocaleDateString : Symbol(Date.toLocaleDateString, Decl(lib.d.ts, --, --)) Date.prototype.toLocaleTimeString(); ->Date.prototype.toLocaleTimeString : Symbol(Date.toLocaleTimeString, Decl(lib.d.ts, 646, 33)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->toLocaleTimeString : Symbol(Date.toLocaleTimeString, Decl(lib.d.ts, 646, 33)) +>Date.prototype.toLocaleTimeString : Symbol(Date.toLocaleTimeString, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>toLocaleTimeString : Symbol(Date.toLocaleTimeString, Decl(lib.d.ts, --, --)) Date.prototype.valueOf(); ->Date.prototype.valueOf : Symbol(Date.valueOf, Decl(lib.d.ts, 648, 33)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->valueOf : Symbol(Date.valueOf, Decl(lib.d.ts, 648, 33)) +>Date.prototype.valueOf : Symbol(Date.valueOf, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>valueOf : Symbol(Date.valueOf, Decl(lib.d.ts, --, --)) Date.prototype.getTime(); ->Date.prototype.getTime : Symbol(Date.getTime, Decl(lib.d.ts, 650, 22)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getTime : Symbol(Date.getTime, Decl(lib.d.ts, 650, 22)) +>Date.prototype.getTime : Symbol(Date.getTime, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getTime : Symbol(Date.getTime, Decl(lib.d.ts, --, --)) Date.prototype.getFullYear(); ->Date.prototype.getFullYear : Symbol(Date.getFullYear, Decl(lib.d.ts, 652, 22)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getFullYear : Symbol(Date.getFullYear, Decl(lib.d.ts, 652, 22)) +>Date.prototype.getFullYear : Symbol(Date.getFullYear, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getFullYear : Symbol(Date.getFullYear, Decl(lib.d.ts, --, --)) Date.prototype.getUTCFullYear(); ->Date.prototype.getUTCFullYear : Symbol(Date.getUTCFullYear, Decl(lib.d.ts, 654, 26)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getUTCFullYear : Symbol(Date.getUTCFullYear, Decl(lib.d.ts, 654, 26)) +>Date.prototype.getUTCFullYear : Symbol(Date.getUTCFullYear, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getUTCFullYear : Symbol(Date.getUTCFullYear, Decl(lib.d.ts, --, --)) Date.prototype.getMonth(); ->Date.prototype.getMonth : Symbol(Date.getMonth, Decl(lib.d.ts, 656, 29)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getMonth : Symbol(Date.getMonth, Decl(lib.d.ts, 656, 29)) +>Date.prototype.getMonth : Symbol(Date.getMonth, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getMonth : Symbol(Date.getMonth, Decl(lib.d.ts, --, --)) Date.prototype.getUTCMonth(); ->Date.prototype.getUTCMonth : Symbol(Date.getUTCMonth, Decl(lib.d.ts, 658, 23)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getUTCMonth : Symbol(Date.getUTCMonth, Decl(lib.d.ts, 658, 23)) +>Date.prototype.getUTCMonth : Symbol(Date.getUTCMonth, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getUTCMonth : Symbol(Date.getUTCMonth, Decl(lib.d.ts, --, --)) Date.prototype.getDate(); ->Date.prototype.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>Date.prototype.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) Date.prototype.getUTCDate(); ->Date.prototype.getUTCDate : Symbol(Date.getUTCDate, Decl(lib.d.ts, 662, 22)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getUTCDate : Symbol(Date.getUTCDate, Decl(lib.d.ts, 662, 22)) +>Date.prototype.getUTCDate : Symbol(Date.getUTCDate, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getUTCDate : Symbol(Date.getUTCDate, Decl(lib.d.ts, --, --)) Date.prototype.getDay(); ->Date.prototype.getDay : Symbol(Date.getDay, Decl(lib.d.ts, 664, 25)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getDay : Symbol(Date.getDay, Decl(lib.d.ts, 664, 25)) +>Date.prototype.getDay : Symbol(Date.getDay, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getDay : Symbol(Date.getDay, Decl(lib.d.ts, --, --)) Date.prototype.getUTCDay(); ->Date.prototype.getUTCDay : Symbol(Date.getUTCDay, Decl(lib.d.ts, 666, 21)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getUTCDay : Symbol(Date.getUTCDay, Decl(lib.d.ts, 666, 21)) +>Date.prototype.getUTCDay : Symbol(Date.getUTCDay, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getUTCDay : Symbol(Date.getUTCDay, Decl(lib.d.ts, --, --)) Date.prototype.getHours(); ->Date.prototype.getHours : Symbol(Date.getHours, Decl(lib.d.ts, 668, 24)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getHours : Symbol(Date.getHours, Decl(lib.d.ts, 668, 24)) +>Date.prototype.getHours : Symbol(Date.getHours, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getHours : Symbol(Date.getHours, Decl(lib.d.ts, --, --)) Date.prototype.getUTCHours(); ->Date.prototype.getUTCHours : Symbol(Date.getUTCHours, Decl(lib.d.ts, 670, 23)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getUTCHours : Symbol(Date.getUTCHours, Decl(lib.d.ts, 670, 23)) +>Date.prototype.getUTCHours : Symbol(Date.getUTCHours, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getUTCHours : Symbol(Date.getUTCHours, Decl(lib.d.ts, --, --)) Date.prototype.getMinutes(); ->Date.prototype.getMinutes : Symbol(Date.getMinutes, Decl(lib.d.ts, 672, 26)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getMinutes : Symbol(Date.getMinutes, Decl(lib.d.ts, 672, 26)) +>Date.prototype.getMinutes : Symbol(Date.getMinutes, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getMinutes : Symbol(Date.getMinutes, Decl(lib.d.ts, --, --)) Date.prototype.getUTCMinutes(); ->Date.prototype.getUTCMinutes : Symbol(Date.getUTCMinutes, Decl(lib.d.ts, 674, 25)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getUTCMinutes : Symbol(Date.getUTCMinutes, Decl(lib.d.ts, 674, 25)) +>Date.prototype.getUTCMinutes : Symbol(Date.getUTCMinutes, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getUTCMinutes : Symbol(Date.getUTCMinutes, Decl(lib.d.ts, --, --)) Date.prototype.getSeconds(); ->Date.prototype.getSeconds : Symbol(Date.getSeconds, Decl(lib.d.ts, 676, 28)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getSeconds : Symbol(Date.getSeconds, Decl(lib.d.ts, 676, 28)) +>Date.prototype.getSeconds : Symbol(Date.getSeconds, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getSeconds : Symbol(Date.getSeconds, Decl(lib.d.ts, --, --)) Date.prototype.getUTCSeconds(); ->Date.prototype.getUTCSeconds : Symbol(Date.getUTCSeconds, Decl(lib.d.ts, 678, 25)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getUTCSeconds : Symbol(Date.getUTCSeconds, Decl(lib.d.ts, 678, 25)) +>Date.prototype.getUTCSeconds : Symbol(Date.getUTCSeconds, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getUTCSeconds : Symbol(Date.getUTCSeconds, Decl(lib.d.ts, --, --)) Date.prototype.getMilliseconds(); ->Date.prototype.getMilliseconds : Symbol(Date.getMilliseconds, Decl(lib.d.ts, 680, 28)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getMilliseconds : Symbol(Date.getMilliseconds, Decl(lib.d.ts, 680, 28)) +>Date.prototype.getMilliseconds : Symbol(Date.getMilliseconds, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getMilliseconds : Symbol(Date.getMilliseconds, Decl(lib.d.ts, --, --)) Date.prototype.getUTCMilliseconds(); ->Date.prototype.getUTCMilliseconds : Symbol(Date.getUTCMilliseconds, Decl(lib.d.ts, 682, 30)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getUTCMilliseconds : Symbol(Date.getUTCMilliseconds, Decl(lib.d.ts, 682, 30)) +>Date.prototype.getUTCMilliseconds : Symbol(Date.getUTCMilliseconds, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getUTCMilliseconds : Symbol(Date.getUTCMilliseconds, Decl(lib.d.ts, --, --)) Date.prototype.getTimezoneOffset(); ->Date.prototype.getTimezoneOffset : Symbol(Date.getTimezoneOffset, Decl(lib.d.ts, 684, 33)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->getTimezoneOffset : Symbol(Date.getTimezoneOffset, Decl(lib.d.ts, 684, 33)) +>Date.prototype.getTimezoneOffset : Symbol(Date.getTimezoneOffset, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>getTimezoneOffset : Symbol(Date.getTimezoneOffset, Decl(lib.d.ts, --, --)) Date.prototype.setTime(0); ->Date.prototype.setTime : Symbol(Date.setTime, Decl(lib.d.ts, 686, 32)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setTime : Symbol(Date.setTime, Decl(lib.d.ts, 686, 32)) +>Date.prototype.setTime : Symbol(Date.setTime, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setTime : Symbol(Date.setTime, Decl(lib.d.ts, --, --)) Date.prototype.setMilliseconds(0); ->Date.prototype.setMilliseconds : Symbol(Date.setMilliseconds, Decl(lib.d.ts, 691, 34)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setMilliseconds : Symbol(Date.setMilliseconds, Decl(lib.d.ts, 691, 34)) +>Date.prototype.setMilliseconds : Symbol(Date.setMilliseconds, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setMilliseconds : Symbol(Date.setMilliseconds, Decl(lib.d.ts, --, --)) Date.prototype.setUTCMilliseconds(0); ->Date.prototype.setUTCMilliseconds : Symbol(Date.setUTCMilliseconds, Decl(lib.d.ts, 696, 40)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setUTCMilliseconds : Symbol(Date.setUTCMilliseconds, Decl(lib.d.ts, 696, 40)) +>Date.prototype.setUTCMilliseconds : Symbol(Date.setUTCMilliseconds, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setUTCMilliseconds : Symbol(Date.setUTCMilliseconds, Decl(lib.d.ts, --, --)) Date.prototype.setSeconds(0); ->Date.prototype.setSeconds : Symbol(Date.setSeconds, Decl(lib.d.ts, 701, 43)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setSeconds : Symbol(Date.setSeconds, Decl(lib.d.ts, 701, 43)) +>Date.prototype.setSeconds : Symbol(Date.setSeconds, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setSeconds : Symbol(Date.setSeconds, Decl(lib.d.ts, --, --)) Date.prototype.setUTCSeconds(0); ->Date.prototype.setUTCSeconds : Symbol(Date.setUTCSeconds, Decl(lib.d.ts, 708, 49)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setUTCSeconds : Symbol(Date.setUTCSeconds, Decl(lib.d.ts, 708, 49)) +>Date.prototype.setUTCSeconds : Symbol(Date.setUTCSeconds, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setUTCSeconds : Symbol(Date.setUTCSeconds, Decl(lib.d.ts, --, --)) Date.prototype.setMinutes(0); ->Date.prototype.setMinutes : Symbol(Date.setMinutes, Decl(lib.d.ts, 714, 52)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setMinutes : Symbol(Date.setMinutes, Decl(lib.d.ts, 714, 52)) +>Date.prototype.setMinutes : Symbol(Date.setMinutes, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setMinutes : Symbol(Date.setMinutes, Decl(lib.d.ts, --, --)) Date.prototype.setUTCMinutes(0); ->Date.prototype.setUTCMinutes : Symbol(Date.setUTCMinutes, Decl(lib.d.ts, 721, 63)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setUTCMinutes : Symbol(Date.setUTCMinutes, Decl(lib.d.ts, 721, 63)) +>Date.prototype.setUTCMinutes : Symbol(Date.setUTCMinutes, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setUTCMinutes : Symbol(Date.setUTCMinutes, Decl(lib.d.ts, --, --)) Date.prototype.setHours(0); ->Date.prototype.setHours : Symbol(Date.setHours, Decl(lib.d.ts, 728, 66)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setHours : Symbol(Date.setHours, Decl(lib.d.ts, 728, 66)) +>Date.prototype.setHours : Symbol(Date.setHours, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setHours : Symbol(Date.setHours, Decl(lib.d.ts, --, --)) Date.prototype.setUTCHours(0); ->Date.prototype.setUTCHours : Symbol(Date.setUTCHours, Decl(lib.d.ts, 736, 77)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setUTCHours : Symbol(Date.setUTCHours, Decl(lib.d.ts, 736, 77)) +>Date.prototype.setUTCHours : Symbol(Date.setUTCHours, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setUTCHours : Symbol(Date.setUTCHours, Decl(lib.d.ts, --, --)) Date.prototype.setDate(0); ->Date.prototype.setDate : Symbol(Date.setDate, Decl(lib.d.ts, 744, 80)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setDate : Symbol(Date.setDate, Decl(lib.d.ts, 744, 80)) +>Date.prototype.setDate : Symbol(Date.setDate, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setDate : Symbol(Date.setDate, Decl(lib.d.ts, --, --)) Date.prototype.setUTCDate(0); ->Date.prototype.setUTCDate : Symbol(Date.setUTCDate, Decl(lib.d.ts, 749, 34)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setUTCDate : Symbol(Date.setUTCDate, Decl(lib.d.ts, 749, 34)) +>Date.prototype.setUTCDate : Symbol(Date.setUTCDate, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setUTCDate : Symbol(Date.setUTCDate, Decl(lib.d.ts, --, --)) Date.prototype.setMonth(0); ->Date.prototype.setMonth : Symbol(Date.setMonth, Decl(lib.d.ts, 754, 37)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setMonth : Symbol(Date.setMonth, Decl(lib.d.ts, 754, 37)) +>Date.prototype.setMonth : Symbol(Date.setMonth, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setMonth : Symbol(Date.setMonth, Decl(lib.d.ts, --, --)) Date.prototype.setUTCMonth(0); ->Date.prototype.setUTCMonth : Symbol(Date.setUTCMonth, Decl(lib.d.ts, 760, 51)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setUTCMonth : Symbol(Date.setUTCMonth, Decl(lib.d.ts, 760, 51)) +>Date.prototype.setUTCMonth : Symbol(Date.setUTCMonth, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setUTCMonth : Symbol(Date.setUTCMonth, Decl(lib.d.ts, --, --)) Date.prototype.setFullYear(0); ->Date.prototype.setFullYear : Symbol(Date.setFullYear, Decl(lib.d.ts, 766, 54)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setFullYear : Symbol(Date.setFullYear, Decl(lib.d.ts, 766, 54)) +>Date.prototype.setFullYear : Symbol(Date.setFullYear, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setFullYear : Symbol(Date.setFullYear, Decl(lib.d.ts, --, --)) Date.prototype.setUTCFullYear(0); ->Date.prototype.setUTCFullYear : Symbol(Date.setUTCFullYear, Decl(lib.d.ts, 773, 69)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->setUTCFullYear : Symbol(Date.setUTCFullYear, Decl(lib.d.ts, 773, 69)) +>Date.prototype.setUTCFullYear : Symbol(Date.setUTCFullYear, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>setUTCFullYear : Symbol(Date.setUTCFullYear, Decl(lib.d.ts, --, --)) Date.prototype.toUTCString(); ->Date.prototype.toUTCString : Symbol(Date.toUTCString, Decl(lib.d.ts, 780, 72)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->toUTCString : Symbol(Date.toUTCString, Decl(lib.d.ts, 780, 72)) +>Date.prototype.toUTCString : Symbol(Date.toUTCString, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>toUTCString : Symbol(Date.toUTCString, Decl(lib.d.ts, --, --)) Date.prototype.toISOString(); ->Date.prototype.toISOString : Symbol(Date.toISOString, Decl(lib.d.ts, 782, 26)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->toISOString : Symbol(Date.toISOString, Decl(lib.d.ts, 782, 26)) +>Date.prototype.toISOString : Symbol(Date.toISOString, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>toISOString : Symbol(Date.toISOString, Decl(lib.d.ts, --, --)) Date.prototype.toJSON(null); ->Date.prototype.toJSON : Symbol(Date.toJSON, Decl(lib.d.ts, 784, 26)) ->Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, 794, 15)) ->toJSON : Symbol(Date.toJSON, Decl(lib.d.ts, 784, 26)) +>Date.prototype.toJSON : Symbol(Date.toJSON, Decl(lib.d.ts, --, --)) +>Date.prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(DateConstructor.prototype, Decl(lib.d.ts, --, --)) +>toJSON : Symbol(Date.toJSON, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/library_ObjectPrototypeProperties.symbols b/tests/baselines/reference/library_ObjectPrototypeProperties.symbols index eb24374af2a..acbeccc02d0 100644 --- a/tests/baselines/reference/library_ObjectPrototypeProperties.symbols +++ b/tests/baselines/reference/library_ObjectPrototypeProperties.symbols @@ -2,52 +2,52 @@ // Properties of the Object Prototype Object as per ES5 spec // http://www.ecma-international.org/ecma-262/5.1/#sec-15.2.4 Object.prototype.constructor; ->Object.prototype.constructor : Symbol(Object.constructor, Decl(lib.d.ts, 94, 18)) ->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) ->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->constructor : Symbol(Object.constructor, Decl(lib.d.ts, 94, 18)) +>Object.prototype.constructor : Symbol(Object.constructor, Decl(lib.d.ts, --, --)) +>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>constructor : Symbol(Object.constructor, Decl(lib.d.ts, --, --)) Object.prototype.toString(); ->Object.prototype.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) ->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) ->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>Object.prototype.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) +>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) Object.prototype.toLocaleString(); ->Object.prototype.toLocaleString : Symbol(Object.toLocaleString, Decl(lib.d.ts, 99, 23)) ->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) ->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->toLocaleString : Symbol(Object.toLocaleString, Decl(lib.d.ts, 99, 23)) +>Object.prototype.toLocaleString : Symbol(Object.toLocaleString, Decl(lib.d.ts, --, --)) +>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>toLocaleString : Symbol(Object.toLocaleString, Decl(lib.d.ts, --, --)) Object.prototype.valueOf(); ->Object.prototype.valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, 102, 29)) ->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) ->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, 102, 29)) +>Object.prototype.valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, --, --)) +>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>valueOf : Symbol(Object.valueOf, Decl(lib.d.ts, --, --)) Object.prototype.hasOwnProperty("string"); ->Object.prototype.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) ->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) ->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>Object.prototype.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) +>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) Object.prototype.isPrototypeOf(Object); ->Object.prototype.isPrototypeOf : Symbol(Object.isPrototypeOf, Decl(lib.d.ts, 111, 39)) ->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) ->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->isPrototypeOf : Symbol(Object.isPrototypeOf, Decl(lib.d.ts, 111, 39)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object.prototype.isPrototypeOf : Symbol(Object.isPrototypeOf, Decl(lib.d.ts, --, --)) +>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>isPrototypeOf : Symbol(Object.isPrototypeOf, Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) Object.prototype.propertyIsEnumerable("string"); ->Object.prototype.propertyIsEnumerable : Symbol(Object.propertyIsEnumerable, Decl(lib.d.ts, 117, 38)) ->Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) ->prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, 129, 22)) ->propertyIsEnumerable : Symbol(Object.propertyIsEnumerable, Decl(lib.d.ts, 117, 38)) +>Object.prototype.propertyIsEnumerable : Symbol(Object.propertyIsEnumerable, Decl(lib.d.ts, --, --)) +>Object.prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(ObjectConstructor.prototype, Decl(lib.d.ts, --, --)) +>propertyIsEnumerable : Symbol(Object.propertyIsEnumerable, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/library_RegExpExecArraySlice.symbols b/tests/baselines/reference/library_RegExpExecArraySlice.symbols index bc460801fe8..d1ad57ff1d5 100644 --- a/tests/baselines/reference/library_RegExpExecArraySlice.symbols +++ b/tests/baselines/reference/library_RegExpExecArraySlice.symbols @@ -2,20 +2,20 @@ // RegExpExecArray.slice can have zero, one, or two arguments var regExpExecArrayValue: RegExpExecArray; >regExpExecArrayValue : Symbol(regExpExecArrayValue, Decl(library_RegExpExecArraySlice.ts, 1, 3)) ->RegExpExecArray : Symbol(RegExpExecArray, Decl(lib.d.ts, 820, 1)) +>RegExpExecArray : Symbol(RegExpExecArray, Decl(lib.d.ts, --, --)) regExpExecArrayValue.slice(); ->regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15)) +>regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) >regExpExecArrayValue : Symbol(regExpExecArrayValue, Decl(library_RegExpExecArraySlice.ts, 1, 3)) ->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15)) +>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) regExpExecArrayValue.slice(0); ->regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15)) +>regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) >regExpExecArrayValue : Symbol(regExpExecArrayValue, Decl(library_RegExpExecArraySlice.ts, 1, 3)) ->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15)) +>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) regExpExecArrayValue.slice(0,1); ->regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15)) +>regExpExecArrayValue.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) >regExpExecArrayValue : Symbol(regExpExecArrayValue, Decl(library_RegExpExecArraySlice.ts, 1, 3)) ->slice : Symbol(Array.slice, Decl(lib.d.ts, 1048, 15)) +>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/library_StringSlice.symbols b/tests/baselines/reference/library_StringSlice.symbols index 92c80089511..de79b8755ac 100644 --- a/tests/baselines/reference/library_StringSlice.symbols +++ b/tests/baselines/reference/library_StringSlice.symbols @@ -1,23 +1,23 @@ === tests/cases/compiler/library_StringSlice.ts === // String.prototype.slice can have zero, one, or two arguments String.prototype.slice(); ->String.prototype.slice : Symbol(String.slice, Decl(lib.d.ts, 369, 35)) ->String.prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, 435, 26)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) ->prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, 435, 26)) ->slice : Symbol(String.slice, Decl(lib.d.ts, 369, 35)) +>String.prototype.slice : Symbol(String.slice, Decl(lib.d.ts, --, --)) +>String.prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, --, --)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, --, --)) +>slice : Symbol(String.slice, Decl(lib.d.ts, --, --)) String.prototype.slice(0); ->String.prototype.slice : Symbol(String.slice, Decl(lib.d.ts, 369, 35)) ->String.prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, 435, 26)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) ->prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, 435, 26)) ->slice : Symbol(String.slice, Decl(lib.d.ts, 369, 35)) +>String.prototype.slice : Symbol(String.slice, Decl(lib.d.ts, --, --)) +>String.prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, --, --)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, --, --)) +>slice : Symbol(String.slice, Decl(lib.d.ts, --, --)) String.prototype.slice(0,1); ->String.prototype.slice : Symbol(String.slice, Decl(lib.d.ts, 369, 35)) ->String.prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, 435, 26)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) ->prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, 435, 26)) ->slice : Symbol(String.slice, Decl(lib.d.ts, 369, 35)) +>String.prototype.slice : Symbol(String.slice, Decl(lib.d.ts, --, --)) +>String.prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, --, --)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(StringConstructor.prototype, Decl(lib.d.ts, --, --)) +>slice : Symbol(String.slice, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/listFailure.types b/tests/baselines/reference/listFailure.types index 05c3cb5dfad..03725efeca4 100644 --- a/tests/baselines/reference/listFailure.types +++ b/tests/baselines/reference/listFailure.types @@ -30,7 +30,7 @@ module Editor { >this.lines.add(line) : List >this.lines.add : (data: Line) => List >this.lines : List ->this : Buffer +>this : this >lines : List >add : (data: Line) => List >line : Line @@ -94,7 +94,7 @@ module Editor { this.next = ListMakeEntry(data); >this.next = ListMakeEntry(data) : List >this.next : List ->this : List +>this : this >next : List >ListMakeEntry(data) : List >ListMakeEntry : (data: U) => List @@ -102,7 +102,7 @@ module Editor { return this.next; >this.next : List ->this : List +>this : this >next : List } @@ -119,7 +119,7 @@ module Editor { >ListRemoveEntry(this.next) : List >ListRemoveEntry : (entry: List) => List >this.next : List ->this : List +>this : this >next : List } } diff --git a/tests/baselines/reference/localTypes5.symbols b/tests/baselines/reference/localTypes5.symbols index 4ffe53b3e53..41851a617de 100644 --- a/tests/baselines/reference/localTypes5.symbols +++ b/tests/baselines/reference/localTypes5.symbols @@ -22,7 +22,7 @@ function foo() { >Y : Symbol(Y, Decl(localTypes5.ts, 3, 36)) })(); ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } } var x = new X(); diff --git a/tests/baselines/reference/localTypes5.types b/tests/baselines/reference/localTypes5.types index b12e362f754..54e28d35a32 100644 --- a/tests/baselines/reference/localTypes5.types +++ b/tests/baselines/reference/localTypes5.types @@ -36,9 +36,9 @@ function foo() { return x.m(); >x.m() : X.m..Y ->x.m : () => .Y +>x.m : () => X.m..Y >x : X ->m : () => .Y +>m : () => X.m..Y } var x = foo(); >x : foo.X.m..Y diff --git a/tests/baselines/reference/logicalNotOperatorWithStringType.symbols b/tests/baselines/reference/logicalNotOperatorWithStringType.symbols index ff266361321..e91c8b71572 100644 --- a/tests/baselines/reference/logicalNotOperatorWithStringType.symbols +++ b/tests/baselines/reference/logicalNotOperatorWithStringType.symbols @@ -88,9 +88,9 @@ var ResultIsBoolean11 = !(STRING + STRING); var ResultIsBoolean12 = !STRING.charAt(0); >ResultIsBoolean12 : Symbol(ResultIsBoolean12, Decl(logicalNotOperatorWithStringType.ts, 32, 3)) ->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(logicalNotOperatorWithStringType.ts, 1, 3)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) // multiple ! operator var ResultIsBoolean13 = !!STRING; diff --git a/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols b/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols index 6cfbf7ea6b6..a7dfba5f4cb 100644 --- a/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols +++ b/tests/baselines/reference/logicalOrExpressionIsNotContextuallyTyped.symbols @@ -14,7 +14,7 @@ var r = a || ((a) => a.toLowerCase()); >r : Symbol(r, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 3)) >a : Symbol(a, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 6, 3)) >a : Symbol(a, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 15)) ->a.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>a.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(logicalOrExpressionIsNotContextuallyTyped.ts, 9, 15)) ->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/memberAccessOnConstructorType.symbols b/tests/baselines/reference/memberAccessOnConstructorType.symbols index 0e3c707c4f9..c9c06c6f021 100644 --- a/tests/baselines/reference/memberAccessOnConstructorType.symbols +++ b/tests/baselines/reference/memberAccessOnConstructorType.symbols @@ -3,7 +3,7 @@ var f: new () => void; >f : Symbol(f, Decl(memberAccessOnConstructorType.ts, 0, 3)) f.arguments == 0; ->f.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>f.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) >f : Symbol(f, Decl(memberAccessOnConstructorType.ts, 0, 3)) ->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/memberVariableDeclarations1.types b/tests/baselines/reference/memberVariableDeclarations1.types index 9aec8aa12aa..b7ec0fbaba0 100644 --- a/tests/baselines/reference/memberVariableDeclarations1.types +++ b/tests/baselines/reference/memberVariableDeclarations1.types @@ -49,21 +49,21 @@ class Employee2 { this.retired = false; >this.retired = false : boolean >this.retired : boolean ->this : Employee2 +>this : this >retired : boolean >false : boolean this.manager = null; >this.manager = null : null >this.manager : Employee ->this : Employee2 +>this : this >manager : Employee >null : null this.reports = []; >this.reports = [] : undefined[] >this.reports : Employee[] ->this : Employee2 +>this : this >reports : Employee[] >[] : undefined[] } diff --git a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols index f34501f025b..78383c29377 100644 --- a/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols +++ b/tests/baselines/reference/mergedInterfaceFromMultipleFiles1.symbols @@ -11,7 +11,7 @@ interface C extends D { b(): Date; >b : Symbol(b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 4, 23)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var c:C; @@ -38,7 +38,7 @@ var d: number = c.a(); var e: Date = c.b(); >e : Symbol(e, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 12, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >c.b : Symbol(C.b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 4, 23)) >c : Symbol(c, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 8, 3)) >b : Symbol(C.b, Decl(mergedInterfaceFromMultipleFiles1_1.ts, 4, 23)) diff --git a/tests/baselines/reference/mergedInterfacesWithMultipleBases3.symbols b/tests/baselines/reference/mergedInterfacesWithMultipleBases3.symbols index 337ef1dbb1c..1aa65e8825a 100644 --- a/tests/baselines/reference/mergedInterfacesWithMultipleBases3.symbols +++ b/tests/baselines/reference/mergedInterfacesWithMultipleBases3.symbols @@ -69,7 +69,7 @@ class D implements A { b: Date; >b : Symbol(b, Decl(mergedInterfacesWithMultipleBases3.ts, 28, 14)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) c: string; >c : Symbol(c, Decl(mergedInterfacesWithMultipleBases3.ts, 29, 12)) diff --git a/tests/baselines/reference/methodInAmbientClass1.errors.txt b/tests/baselines/reference/methodInAmbientClass1.errors.txt index 05183378a85..2badd839270 100644 --- a/tests/baselines/reference/methodInAmbientClass1.errors.txt +++ b/tests/baselines/reference/methodInAmbientClass1.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/methodInAmbientClass1.ts(2,12): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. -tests/cases/compiler/methodInAmbientClass1.ts(2,20): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/compiler/methodInAmbientClass1.ts(2,20): error TS1183: An implementation cannot be declared in ambient contexts. ==== tests/cases/compiler/methodInAmbientClass1.ts (2 errors) ==== @@ -8,6 +8,6 @@ tests/cases/compiler/methodInAmbientClass1.ts(2,20): error TS1184: An implementa ~~~~~~~ !!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } } \ No newline at end of file diff --git a/tests/baselines/reference/missingDecoratorType.js b/tests/baselines/reference/missingDecoratorType.js index ad6be3a646e..04af1be9d7b 100644 --- a/tests/baselines/reference/missingDecoratorType.js +++ b/tests/baselines/reference/missingDecoratorType.js @@ -24,20 +24,17 @@ class C { //// [a.js] //// [b.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var C = (function () { function C() { } C.prototype.method = function () { }; - Object.defineProperty(C.prototype, "method", - __decorate([ - dec - ], C.prototype, "method", Object.getOwnPropertyDescriptor(C.prototype, "method"))); + __decorate([ + dec + ], C.prototype, "method", null); return C; })(); diff --git a/tests/baselines/reference/missingSelf.types b/tests/baselines/reference/missingSelf.types index 5b46bf85db1..ea275e41a0c 100644 --- a/tests/baselines/reference/missingSelf.types +++ b/tests/baselines/reference/missingSelf.types @@ -6,7 +6,7 @@ class CalcButton >a : () => void >this.onClick() : void >this.onClick : () => void ->this : CalcButton +>this : this >onClick : () => void public onClick() { } @@ -21,7 +21,7 @@ class CalcButton2 >() => this.onClick() : () => void >this.onClick() : void >this.onClick : () => void ->this : CalcButton2 +>this : this >onClick : () => void public onClick() { } diff --git a/tests/baselines/reference/moduleMemberWithoutTypeAnnotation1.types b/tests/baselines/reference/moduleMemberWithoutTypeAnnotation1.types index ebe70d8e6fb..c308f535a7a 100644 --- a/tests/baselines/reference/moduleMemberWithoutTypeAnnotation1.types +++ b/tests/baselines/reference/moduleMemberWithoutTypeAnnotation1.types @@ -71,7 +71,7 @@ module TypeScript { >positionedToken : any >this.findTokenInternal(null, position, 0) : any >this.findTokenInternal : (x: any, y: any, z: any) => any ->this : SyntaxNode +>this : this >findTokenInternal : (x: any, y: any, z: any) => any >null : null >position : number @@ -114,7 +114,7 @@ module TypeScript.Syntax { >new PositionedToken(parent, this, fullStart) : PositionedToken >PositionedToken : typeof PositionedToken >parent : PositionedElement ->this : VariableWidthTokenWithTrailingTrivia +>this : this >fullStart : number } } diff --git a/tests/baselines/reference/modulePrologueAMD.js b/tests/baselines/reference/modulePrologueAMD.js new file mode 100644 index 00000000000..904808b9f6b --- /dev/null +++ b/tests/baselines/reference/modulePrologueAMD.js @@ -0,0 +1,15 @@ +//// [modulePrologueAMD.ts] +"use strict"; + +export class Foo {} + +//// [modulePrologueAMD.js] +define(["require", "exports"], function (require, exports) { + "use strict"; + var Foo = (function () { + function Foo() { + } + return Foo; + })(); + exports.Foo = Foo; +}); diff --git a/tests/baselines/reference/modulePrologueAMD.symbols b/tests/baselines/reference/modulePrologueAMD.symbols new file mode 100644 index 00000000000..d6bb74d951a --- /dev/null +++ b/tests/baselines/reference/modulePrologueAMD.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/modulePrologueAMD.ts === +"use strict"; + +export class Foo {} +>Foo : Symbol(Foo, Decl(modulePrologueAMD.ts, 0, 13)) + diff --git a/tests/baselines/reference/modulePrologueAMD.types b/tests/baselines/reference/modulePrologueAMD.types new file mode 100644 index 00000000000..b57b5a8bf2f --- /dev/null +++ b/tests/baselines/reference/modulePrologueAMD.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/modulePrologueAMD.ts === +"use strict"; +>"use strict" : string + +export class Foo {} +>Foo : Foo + diff --git a/tests/baselines/reference/modulePrologueCommonjs.js b/tests/baselines/reference/modulePrologueCommonjs.js new file mode 100644 index 00000000000..67b704a3650 --- /dev/null +++ b/tests/baselines/reference/modulePrologueCommonjs.js @@ -0,0 +1,13 @@ +//// [modulePrologueCommonjs.ts] +"use strict"; + +export class Foo {} + +//// [modulePrologueCommonjs.js] +"use strict"; +var Foo = (function () { + function Foo() { + } + return Foo; +})(); +exports.Foo = Foo; diff --git a/tests/baselines/reference/modulePrologueCommonjs.symbols b/tests/baselines/reference/modulePrologueCommonjs.symbols new file mode 100644 index 00000000000..01a2da349f2 --- /dev/null +++ b/tests/baselines/reference/modulePrologueCommonjs.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/modulePrologueCommonjs.ts === +"use strict"; + +export class Foo {} +>Foo : Symbol(Foo, Decl(modulePrologueCommonjs.ts, 0, 13)) + diff --git a/tests/baselines/reference/modulePrologueCommonjs.types b/tests/baselines/reference/modulePrologueCommonjs.types new file mode 100644 index 00000000000..5d76532b3e4 --- /dev/null +++ b/tests/baselines/reference/modulePrologueCommonjs.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/modulePrologueCommonjs.ts === +"use strict"; +>"use strict" : string + +export class Foo {} +>Foo : Foo + diff --git a/tests/baselines/reference/modulePrologueES6.js b/tests/baselines/reference/modulePrologueES6.js new file mode 100644 index 00000000000..e34f85c9d8d --- /dev/null +++ b/tests/baselines/reference/modulePrologueES6.js @@ -0,0 +1,9 @@ +//// [modulePrologueES6.ts] +"use strict"; + +export class Foo {} + +//// [modulePrologueES6.js] +"use strict"; +export class Foo { +} diff --git a/tests/baselines/reference/modulePrologueES6.symbols b/tests/baselines/reference/modulePrologueES6.symbols new file mode 100644 index 00000000000..f45180a6998 --- /dev/null +++ b/tests/baselines/reference/modulePrologueES6.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/modulePrologueES6.ts === +"use strict"; + +export class Foo {} +>Foo : Symbol(Foo, Decl(modulePrologueES6.ts, 0, 13)) + diff --git a/tests/baselines/reference/modulePrologueES6.types b/tests/baselines/reference/modulePrologueES6.types new file mode 100644 index 00000000000..5f09a60ac6a --- /dev/null +++ b/tests/baselines/reference/modulePrologueES6.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/modulePrologueES6.ts === +"use strict"; +>"use strict" : string + +export class Foo {} +>Foo : Foo + diff --git a/tests/baselines/reference/modulePrologueSystem.js b/tests/baselines/reference/modulePrologueSystem.js new file mode 100644 index 00000000000..91703d1c7fb --- /dev/null +++ b/tests/baselines/reference/modulePrologueSystem.js @@ -0,0 +1,21 @@ +//// [modulePrologueSystem.ts] +"use strict"; + +export class Foo {} + +//// [modulePrologueSystem.js] +System.register([], function(exports_1) { + "use strict"; + var Foo; + return { + setters:[], + execute: function() { + Foo = (function () { + function Foo() { + } + return Foo; + })(); + exports_1("Foo", Foo); + } + } +}); diff --git a/tests/baselines/reference/modulePrologueSystem.symbols b/tests/baselines/reference/modulePrologueSystem.symbols new file mode 100644 index 00000000000..9e5ed9d452a --- /dev/null +++ b/tests/baselines/reference/modulePrologueSystem.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/modulePrologueSystem.ts === +"use strict"; + +export class Foo {} +>Foo : Symbol(Foo, Decl(modulePrologueSystem.ts, 0, 13)) + diff --git a/tests/baselines/reference/modulePrologueSystem.types b/tests/baselines/reference/modulePrologueSystem.types new file mode 100644 index 00000000000..ac0d52e4a2b --- /dev/null +++ b/tests/baselines/reference/modulePrologueSystem.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/modulePrologueSystem.ts === +"use strict"; +>"use strict" : string + +export class Foo {} +>Foo : Foo + diff --git a/tests/baselines/reference/modulePrologueUmd.js b/tests/baselines/reference/modulePrologueUmd.js new file mode 100644 index 00000000000..65803af6cad --- /dev/null +++ b/tests/baselines/reference/modulePrologueUmd.js @@ -0,0 +1,22 @@ +//// [modulePrologueUmd.ts] +"use strict"; + +export class Foo {} + +//// [modulePrologueUmd.js] +(function (factory) { + if (typeof module === 'object' && typeof module.exports === 'object') { + var v = factory(require, exports); if (v !== undefined) module.exports = v; + } + else if (typeof define === 'function' && define.amd) { + define(["require", "exports"], factory); + } +})(function (require, exports) { + "use strict"; + var Foo = (function () { + function Foo() { + } + return Foo; + })(); + exports.Foo = Foo; +}); diff --git a/tests/baselines/reference/modulePrologueUmd.symbols b/tests/baselines/reference/modulePrologueUmd.symbols new file mode 100644 index 00000000000..3b015b2ea44 --- /dev/null +++ b/tests/baselines/reference/modulePrologueUmd.symbols @@ -0,0 +1,6 @@ +=== tests/cases/compiler/modulePrologueUmd.ts === +"use strict"; + +export class Foo {} +>Foo : Symbol(Foo, Decl(modulePrologueUmd.ts, 0, 13)) + diff --git a/tests/baselines/reference/modulePrologueUmd.types b/tests/baselines/reference/modulePrologueUmd.types new file mode 100644 index 00000000000..2a1064da8e2 --- /dev/null +++ b/tests/baselines/reference/modulePrologueUmd.types @@ -0,0 +1,7 @@ +=== tests/cases/compiler/modulePrologueUmd.ts === +"use strict"; +>"use strict" : string + +export class Foo {} +>Foo : Foo + diff --git a/tests/baselines/reference/multipleDefaultExports01.errors.txt b/tests/baselines/reference/multipleDefaultExports01.errors.txt index 72898d474e8..16aa3b2f7b1 100644 --- a/tests/baselines/reference/multipleDefaultExports01.errors.txt +++ b/tests/baselines/reference/multipleDefaultExports01.errors.txt @@ -1,6 +1,6 @@ -tests/cases/conformance/es6/modules/m1.ts(2,22): error TS2300: Duplicate identifier 'foo'. -tests/cases/conformance/es6/modules/m1.ts(6,25): error TS2300: Duplicate identifier 'bar'. -tests/cases/conformance/es6/modules/m1.ts(11,1): error TS2300: Duplicate identifier 'default'. +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/m2.ts(3,1): error TS2348: Value of type 'typeof foo' is not callable. Did you mean to include 'new'? @@ -8,20 +8,20 @@ tests/cases/conformance/es6/modules/m2.ts(3,1): error TS2348: Value of type 'typ export default class foo { ~~~ -!!! error TS2300: Duplicate identifier 'foo'. +!!! error TS2528: A module cannot have multiple default exports. } export default function bar() { ~~~ -!!! error TS2300: Duplicate identifier 'bar'. +!!! error TS2528: A module cannot have multiple default exports. } var x = 10; export default x; ~~~~~~~~~~~~~~~~~ -!!! error TS2300: Duplicate identifier 'default'. +!!! error TS2528: A module cannot have multiple default exports. ==== tests/cases/conformance/es6/modules/m2.ts (1 errors) ==== import Entity from "./m1" diff --git a/tests/baselines/reference/multipleDefaultExports03.errors.txt b/tests/baselines/reference/multipleDefaultExports03.errors.txt new file mode 100644 index 00000000000..5c4b075b009 --- /dev/null +++ b/tests/baselines/reference/multipleDefaultExports03.errors.txt @@ -0,0 +1,15 @@ +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 (2 errors) ==== + + export default class C { + ~ +!!! error TS2528: A module cannot have multiple default exports. + } + + export default class C { + ~ +!!! error TS2528: A module cannot have multiple default exports. + } \ No newline at end of file diff --git a/tests/baselines/reference/multipleDefaultExports03.js b/tests/baselines/reference/multipleDefaultExports03.js new file mode 100644 index 00000000000..2824c7a5ac1 --- /dev/null +++ b/tests/baselines/reference/multipleDefaultExports03.js @@ -0,0 +1,23 @@ +//// [multipleDefaultExports03.ts] + +export default class C { +} + +export default class C { +} + +//// [multipleDefaultExports03.js] +var C = (function () { + function C() { + } + return C; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = C; +var C = (function () { + function C() { + } + return C; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = C; diff --git a/tests/baselines/reference/multipleDefaultExports04.errors.txt b/tests/baselines/reference/multipleDefaultExports04.errors.txt new file mode 100644 index 00000000000..e67659f6b9f --- /dev/null +++ b/tests/baselines/reference/multipleDefaultExports04.errors.txt @@ -0,0 +1,15 @@ +tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(2,25): error TS2393: Duplicate function implementation. +tests/cases/conformance/es6/modules/multipleDefaultExports04.ts(5,25): error TS2393: Duplicate function implementation. + + +==== tests/cases/conformance/es6/modules/multipleDefaultExports04.ts (2 errors) ==== + + export default function f() { + ~ +!!! error TS2393: Duplicate function implementation. + } + + export default function f() { + ~ +!!! error TS2393: Duplicate function implementation. + } \ No newline at end of file diff --git a/tests/baselines/reference/multipleDefaultExports04.js b/tests/baselines/reference/multipleDefaultExports04.js new file mode 100644 index 00000000000..73582d7389e --- /dev/null +++ b/tests/baselines/reference/multipleDefaultExports04.js @@ -0,0 +1,17 @@ +//// [multipleDefaultExports04.ts] + +export default function f() { +} + +export default function f() { +} + +//// [multipleDefaultExports04.js] +function f() { +} +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = f; +function f() { +} +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = f; diff --git a/tests/baselines/reference/negateOperatorWithStringType.symbols b/tests/baselines/reference/negateOperatorWithStringType.symbols index 00a90bdf743..5ef0afc7e1c 100644 --- a/tests/baselines/reference/negateOperatorWithStringType.symbols +++ b/tests/baselines/reference/negateOperatorWithStringType.symbols @@ -88,9 +88,9 @@ var ResultIsNumber11 = -(STRING + STRING); var ResultIsNumber12 = -STRING.charAt(0); >ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(negateOperatorWithStringType.ts, 32, 3)) ->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(negateOperatorWithStringType.ts, 1, 3)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) // miss assignment operators -""; diff --git a/tests/baselines/reference/nestedSelf.symbols b/tests/baselines/reference/nestedSelf.symbols index 08f41f155d6..a14a9b9d374 100644 --- a/tests/baselines/reference/nestedSelf.symbols +++ b/tests/baselines/reference/nestedSelf.symbols @@ -10,8 +10,8 @@ module M { public foo() { [1,2,3].map((x) => { return this.n * x; })} >foo : Symbol(foo, Decl(nestedSelf.ts, 2, 17)) ->[1,2,3].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>[1,2,3].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(nestedSelf.ts, 3, 31)) >this.n : Symbol(n, Decl(nestedSelf.ts, 1, 17)) >this : Symbol(C, Decl(nestedSelf.ts, 0, 10)) diff --git a/tests/baselines/reference/nestedSelf.types b/tests/baselines/reference/nestedSelf.types index 2c8f3f41dd6..ed7f084246a 100644 --- a/tests/baselines/reference/nestedSelf.types +++ b/tests/baselines/reference/nestedSelf.types @@ -22,7 +22,7 @@ module M { >x : number >this.n * x : number >this.n : number ->this : C +>this : this >n : number >x : number } diff --git a/tests/baselines/reference/newArrays.symbols b/tests/baselines/reference/newArrays.symbols index fd30b2fe25e..663b6380bc7 100644 --- a/tests/baselines/reference/newArrays.symbols +++ b/tests/baselines/reference/newArrays.symbols @@ -25,7 +25,7 @@ module M { >this.fa : Symbol(fa, Decl(newArrays.ts, 2, 12)) >this : Symbol(Gar, Decl(newArrays.ts, 1, 13)) >fa : Symbol(fa, Decl(newArrays.ts, 2, 12)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Foo : Symbol(Foo, Decl(newArrays.ts, 0, 10)) >this.x : Symbol(x, Decl(newArrays.ts, 3, 19)) >this : Symbol(Gar, Decl(newArrays.ts, 1, 13)) diff --git a/tests/baselines/reference/newArrays.types b/tests/baselines/reference/newArrays.types index 4600f5efaf8..3c0928a46ea 100644 --- a/tests/baselines/reference/newArrays.types +++ b/tests/baselines/reference/newArrays.types @@ -26,17 +26,17 @@ module M { this.fa = new Array(this.x * this.y); >this.fa = new Array(this.x * this.y) : Foo[] >this.fa : Foo[] ->this : Gar +>this : this >fa : Foo[] >new Array(this.x * this.y) : Foo[] >Array : ArrayConstructor >Foo : Foo >this.x * this.y : number >this.x : number ->this : Gar +>this : this >x : number >this.y : number ->this : Gar +>this : this >y : number } } diff --git a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols index 9144d725efb..6cee1604cf0 100644 --- a/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols +++ b/tests/baselines/reference/noImplicitAnyInContextuallyTypesFunctionParamter.symbols @@ -4,11 +4,11 @@ var regexMatchList = ['', '']; >regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 3)) regexMatchList.forEach(match => ''.replace(match, '')); ->regexMatchList.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95)) +>regexMatchList.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) >regexMatchList : Symbol(regexMatchList, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 1, 3)) ->forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95)) +>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) >match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 2, 23)) ->''.replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63)) ->replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63)) +>''.replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >match : Symbol(match, Decl(noImplicitAnyInContextuallyTypesFunctionParamter.ts, 2, 23)) diff --git a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols index 7c8f57795b4..96b38408560 100644 --- a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols +++ b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.symbols @@ -74,7 +74,7 @@ var m: MyMap = { "1": 1, "2": 2, "Okay that's enough for today.": NaN ->NaN : Symbol(NaN, Decl(lib.d.ts, 21, 11)) +>NaN : Symbol(NaN, Decl(lib.d.ts, --, --)) }; diff --git a/tests/baselines/reference/nullAssignableToEveryType.symbols b/tests/baselines/reference/nullAssignableToEveryType.symbols index 7179a02c0bc..a01077c8eb4 100644 --- a/tests/baselines/reference/nullAssignableToEveryType.symbols +++ b/tests/baselines/reference/nullAssignableToEveryType.symbols @@ -38,7 +38,7 @@ var d: boolean = null; var e: Date = null; >e : Symbol(e, Decl(nullAssignableToEveryType.ts, 15, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var f: any = null; >f : Symbol(f, Decl(nullAssignableToEveryType.ts, 16, 3)) @@ -48,7 +48,7 @@ var g: void = null; var h: Object = null; >h : Symbol(h, Decl(nullAssignableToEveryType.ts, 18, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var i: {} = null; >i : Symbol(i, Decl(nullAssignableToEveryType.ts, 19, 3)) @@ -58,7 +58,7 @@ var j: () => {} = null; var k: Function = null; >k : Symbol(k, Decl(nullAssignableToEveryType.ts, 21, 3)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var l: (x: number) => string = null; >l : Symbol(l, Decl(nullAssignableToEveryType.ts, 22, 3)) @@ -89,18 +89,18 @@ var o: (x: T) => T = null; var p: Number = null; >p : Symbol(p, Decl(nullAssignableToEveryType.ts, 29, 3)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var q: String = null; >q : Symbol(q, Decl(nullAssignableToEveryType.ts, 30, 3)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo(x: T, y: U, z: V) { >foo : Symbol(foo, Decl(nullAssignableToEveryType.ts, 30, 21)) >T : Symbol(T, Decl(nullAssignableToEveryType.ts, 32, 13)) >U : Symbol(U, Decl(nullAssignableToEveryType.ts, 32, 15)) >V : Symbol(V, Decl(nullAssignableToEveryType.ts, 32, 18)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(nullAssignableToEveryType.ts, 32, 35)) >T : Symbol(T, Decl(nullAssignableToEveryType.ts, 32, 13)) >y : Symbol(y, Decl(nullAssignableToEveryType.ts, 32, 40)) diff --git a/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols b/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols index 7f81995c9be..cb6fab17560 100644 --- a/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols +++ b/tests/baselines/reference/nullIsSubtypeOfEverythingButUndefined.symbols @@ -39,11 +39,11 @@ var r3 = true ? null : true; var r4 = true ? new Date() : null; >r4 : Symbol(r4, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 18, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 19, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r4 = true ? null : new Date(); >r4 : Symbol(r4, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 18, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 19, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r5 = true ? /1/ : null; >r5 : Symbol(r5, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 21, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 22, 3)) @@ -233,11 +233,11 @@ function f18(x: U) { var r19 = true ? new Object() : null; >r19 : Symbol(r19, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 85, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 86, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r19 = true ? null : new Object(); >r19 : Symbol(r19, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 85, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 86, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r20 = true ? {} : null; >r20 : Symbol(r20, Decl(nullIsSubtypeOfEverythingButUndefined.ts, 88, 3), Decl(nullIsSubtypeOfEverythingButUndefined.ts, 89, 3)) diff --git a/tests/baselines/reference/numberPropertyAccess.symbols b/tests/baselines/reference/numberPropertyAccess.symbols index fdfd4c404de..4792c16609a 100644 --- a/tests/baselines/reference/numberPropertyAccess.symbols +++ b/tests/baselines/reference/numberPropertyAccess.symbols @@ -4,23 +4,23 @@ var x = 1; var a = x.toExponential(); >a : Symbol(a, Decl(numberPropertyAccess.ts, 1, 3)) ->x.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>x.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(numberPropertyAccess.ts, 0, 3)) ->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) var b = x.hasOwnProperty('toFixed'); >b : Symbol(b, Decl(numberPropertyAccess.ts, 2, 3)) ->x.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>x.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(numberPropertyAccess.ts, 0, 3)) ->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) var c = x['toExponential'](); >c : Symbol(c, Decl(numberPropertyAccess.ts, 4, 3)) >x : Symbol(x, Decl(numberPropertyAccess.ts, 0, 3)) ->'toExponential' : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>'toExponential' : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) var d = x['hasOwnProperty']('toFixed'); >d : Symbol(d, Decl(numberPropertyAccess.ts, 5, 3)) >x : Symbol(x, Decl(numberPropertyAccess.ts, 0, 3)) ->'hasOwnProperty' : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>'hasOwnProperty' : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/objectIndexer.types b/tests/baselines/reference/objectIndexer.types index 7b42ea51b56..3dcd7bcb77e 100644 --- a/tests/baselines/reference/objectIndexer.types +++ b/tests/baselines/reference/objectIndexer.types @@ -25,7 +25,7 @@ class Emitter { this.listeners = {}; >this.listeners = {} : { [x: string]: undefined; } >this.listeners : IMap ->this : Emitter +>this : this >listeners : IMap >{} : { [x: string]: undefined; } } diff --git a/tests/baselines/reference/objectLitGetterSetter.symbols b/tests/baselines/reference/objectLitGetterSetter.symbols index 512e459c8c0..15f3cdd8a4f 100644 --- a/tests/baselines/reference/objectLitGetterSetter.symbols +++ b/tests/baselines/reference/objectLitGetterSetter.symbols @@ -3,17 +3,17 @@ >obj : Symbol(obj, Decl(objectLitGetterSetter.ts, 0, 15)) Object.defineProperty(obj, "accProperty", ({ ->Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) ->defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, 160, 60)) +>Object.defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, --, --)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>defineProperty : Symbol(ObjectConstructor.defineProperty, Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(objectLitGetterSetter.ts, 0, 15)) ->PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66)) +>PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, --, --)) get: function () { >get : Symbol(get, Decl(objectLitGetterSetter.ts, 1, 76)) eval("public = 1;"); ->eval : Symbol(eval, Decl(lib.d.ts, 22, 29)) +>eval : Symbol(eval, Decl(lib.d.ts, --, --)) return 11; }, diff --git a/tests/baselines/reference/objectMembersOnTypes.symbols b/tests/baselines/reference/objectMembersOnTypes.symbols index 12cc909dcd9..3114d3b9695 100644 --- a/tests/baselines/reference/objectMembersOnTypes.symbols +++ b/tests/baselines/reference/objectMembersOnTypes.symbols @@ -10,25 +10,25 @@ var x: number; >x : Symbol(x, Decl(objectMembersOnTypes.ts, 2, 3)) x.toString(); ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectMembersOnTypes.ts, 2, 3)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) var i: I; >i : Symbol(i, Decl(objectMembersOnTypes.ts, 4, 3)) >I : Symbol(I, Decl(objectMembersOnTypes.ts, 0, 0)) i.toString(); // used to be an error ->i.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>i.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >i : Symbol(i, Decl(objectMembersOnTypes.ts, 4, 3)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) var c: AAA; >c : Symbol(c, Decl(objectMembersOnTypes.ts, 6, 3)) >AAA : Symbol(AAA, Decl(objectMembersOnTypes.ts, 0, 14)) c.toString(); // used to be an error ->c.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>c.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >c : Symbol(c, Decl(objectMembersOnTypes.ts, 6, 3)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/objectTypePropertyAccess.symbols b/tests/baselines/reference/objectTypePropertyAccess.symbols index 519bf589260..2117b9ce35a 100644 --- a/tests/baselines/reference/objectTypePropertyAccess.symbols +++ b/tests/baselines/reference/objectTypePropertyAccess.symbols @@ -13,14 +13,14 @@ var c: C; var r1 = c.toString(); >r1 : Symbol(r1, Decl(objectTypePropertyAccess.ts, 6, 3)) ->c.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>c.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >c : Symbol(c, Decl(objectTypePropertyAccess.ts, 5, 3)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) var r2 = c['toString'](); >r2 : Symbol(r2, Decl(objectTypePropertyAccess.ts, 7, 3)) >c : Symbol(c, Decl(objectTypePropertyAccess.ts, 5, 3)) ->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --)) var r3 = c.foo; >r3 : Symbol(r3, Decl(objectTypePropertyAccess.ts, 8, 3)) @@ -45,14 +45,14 @@ var i: I; var r4 = i.toString(); >r4 : Symbol(r4, Decl(objectTypePropertyAccess.ts, 9, 3), Decl(objectTypePropertyAccess.ts, 15, 3)) ->i.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>i.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >i : Symbol(i, Decl(objectTypePropertyAccess.ts, 14, 3)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) var r5 = i['toString'](); >r5 : Symbol(r5, Decl(objectTypePropertyAccess.ts, 16, 3)) >i : Symbol(i, Decl(objectTypePropertyAccess.ts, 14, 3)) ->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --)) var r6 = i.bar; >r6 : Symbol(r6, Decl(objectTypePropertyAccess.ts, 17, 3)) @@ -74,14 +74,14 @@ var a = { var r8 = a.toString(); >r8 : Symbol(r8, Decl(objectTypePropertyAccess.ts, 24, 3)) ->a.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>a.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(objectTypePropertyAccess.ts, 20, 3)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) var r9 = a['toString'](); >r9 : Symbol(r9, Decl(objectTypePropertyAccess.ts, 25, 3)) >a : Symbol(a, Decl(objectTypePropertyAccess.ts, 20, 3)) ->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --)) var r10 = a.foo; >r10 : Symbol(r10, Decl(objectTypePropertyAccess.ts, 26, 3)) diff --git a/tests/baselines/reference/objectTypeWithCallSignatureAppearsToBeFunctionType.symbols b/tests/baselines/reference/objectTypeWithCallSignatureAppearsToBeFunctionType.symbols index 36127117f43..60b7b08397a 100644 --- a/tests/baselines/reference/objectTypeWithCallSignatureAppearsToBeFunctionType.symbols +++ b/tests/baselines/reference/objectTypeWithCallSignatureAppearsToBeFunctionType.symbols @@ -20,9 +20,9 @@ var r2b: (x: any, y?: any) => any = i.apply; >r2b : Symbol(r2b, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 9, 3)) >x : Symbol(x, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 9, 10)) >y : Symbol(y, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 9, 17)) ->i.apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20)) +>i.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) >i : Symbol(i, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 7, 3)) ->apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20)) +>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) var b: { >b : Symbol(b, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 11, 3)) @@ -38,7 +38,7 @@ var rb4: (x: any, y?: any) => any = b.apply; >rb4 : Symbol(rb4, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 16, 3)) >x : Symbol(x, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 16, 10)) >y : Symbol(y, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 16, 17)) ->b.apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20)) +>b.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(objectTypeWithCallSignatureAppearsToBeFunctionType.ts, 11, 3)) ->apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20)) +>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfExtendedFunction.symbols b/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfExtendedFunction.symbols index de1f2abc5aa..2d80be5f4ea 100644 --- a/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfExtendedFunction.symbols +++ b/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfExtendedFunction.symbols @@ -3,14 +3,14 @@ // no errors expected below interface Function { ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 0, 0)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 0, 0)) data: number; >data : Symbol(data, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 3, 20)) [x: string]: Object; >x : Symbol(x, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 5, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface I { @@ -50,9 +50,9 @@ var r1b: (thisArg: number, ...argArray: number[]) => void = i.call; var r1c = i.arguments; >r1c : Symbol(r1c, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 17, 3)) ->i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) >i : Symbol(i, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 14, 3)) ->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) var r1d = i.data; >r1d : Symbol(r1d, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 18, 3)) @@ -97,9 +97,9 @@ var r2b: (thisArg: number, ...argArray: number[]) => void = x.call; var r2c = x.arguments; >r2c : Symbol(r2c, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 29, 3)) ->x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 21, 3)) ->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) var r2d = x.data; >r2d : Symbol(r2d, Decl(objectTypeWithCallSignatureHidingMembersOfExtendedFunction.ts, 30, 3)) diff --git a/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfFunction.symbols b/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfFunction.symbols index 0ddebe0e68c..07b0ca1a9c1 100644 --- a/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfFunction.symbols +++ b/tests/baselines/reference/objectTypeWithCallSignatureHidingMembersOfFunction.symbols @@ -39,9 +39,9 @@ var r1b: (thisArg: number, ...argArray: number[]) => void = i.call; var r1c = i.arguments; >r1c : Symbol(r1c, Decl(objectTypeWithCallSignatureHidingMembersOfFunction.ts, 12, 3)) ->i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) >i : Symbol(i, Decl(objectTypeWithCallSignatureHidingMembersOfFunction.ts, 9, 3)) ->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) var x: { >x : Symbol(x, Decl(objectTypeWithCallSignatureHidingMembersOfFunction.ts, 14, 3)) @@ -76,7 +76,7 @@ var r2b: (thisArg: number, ...argArray: number[]) => void = x.call; var r2c = x.arguments; >r2c : Symbol(r2c, Decl(objectTypeWithCallSignatureHidingMembersOfFunction.ts, 22, 3)) ->x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypeWithCallSignatureHidingMembersOfFunction.ts, 14, 3)) ->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.symbols b/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.symbols index 57479c548ee..009291b0fb3 100644 --- a/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.symbols +++ b/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.symbols @@ -1,13 +1,13 @@ === tests/cases/conformance/types/members/objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts === interface Function { ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11), Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 0, 0)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 0, 0)) data: number; >data : Symbol(data, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 0, 20)) [x: string]: Object; >x : Symbol(x, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 2, 5)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface I { @@ -47,9 +47,9 @@ var r1b: (thisArg: number, ...argArray: number[]) => void = i.call; var r1c = i.arguments; >r1c : Symbol(r1c, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 14, 3)) ->i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) >i : Symbol(i, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 11, 3)) ->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) var r1d = i.data; >r1d : Symbol(r1d, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 15, 3)) @@ -94,9 +94,9 @@ var r2b: (thisArg: number, ...argArray: number[]) => void = x.call; var r2c = x.arguments; >r2c : Symbol(r2c, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 26, 3)) ->x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 18, 3)) ->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) var r2d = x.data; >r2d : Symbol(r2d, Decl(objectTypeWithConstructSignatureHidingMembersOfExtendedFunction.ts, 27, 3)) diff --git a/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfFunction.symbols b/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfFunction.symbols index 8478fd1d37c..c623bcb6f63 100644 --- a/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfFunction.symbols +++ b/tests/baselines/reference/objectTypeWithConstructSignatureHidingMembersOfFunction.symbols @@ -36,9 +36,9 @@ var r1b: (thisArg: number, ...argArray: number[]) => void = i.call; var r1c = i.arguments; >r1c : Symbol(r1c, Decl(objectTypeWithConstructSignatureHidingMembersOfFunction.ts, 9, 3)) ->i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>i.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) >i : Symbol(i, Decl(objectTypeWithConstructSignatureHidingMembersOfFunction.ts, 6, 3)) ->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) var x: { >x : Symbol(x, Decl(objectTypeWithConstructSignatureHidingMembersOfFunction.ts, 11, 3)) @@ -73,7 +73,7 @@ var r2b: (thisArg: number, ...argArray: number[]) => void = x.call; var r2c = x.arguments; >r2c : Symbol(r2c, Decl(objectTypeWithConstructSignatureHidingMembersOfFunction.ts, 19, 3)) ->x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>x.arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypeWithConstructSignatureHidingMembersOfFunction.ts, 11, 3)) ->arguments : Symbol(Function.arguments, Decl(lib.d.ts, 252, 19)) +>arguments : Symbol(Function.arguments, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols index c95105a8626..d3c463d9a15 100644 --- a/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols +++ b/tests/baselines/reference/objectTypeWithStringNamedNumericProperty.symbols @@ -9,19 +9,19 @@ class C { "0.1": void; ".1": Object; ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "1": number; "1.": string; "1..": boolean; "1.0": Date; ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "-1.0": RegExp; ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "-1": Date; ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var c: C; @@ -115,19 +115,19 @@ interface I { "0.1": void; ".1": Object; ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "1": number; "1.": string; "1..": boolean; "1.0": Date; ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "-1.0": RegExp; ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "-1": Date; ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var i: I; @@ -221,19 +221,19 @@ var a: { "0.1": void; ".1": Object; ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "1": number; "1.": string; "1..": boolean; "1.0": Date; ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "-1.0": RegExp; ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "-1": Date; ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var r1 = a['0.1']; @@ -323,17 +323,17 @@ var b = { "0.1": null, ".1": new Object(), ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "1": 1, "1.": "", "1..": true, "1.0": new Date(), ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) "-1.0": /123/, "-1": Date ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) }; diff --git a/tests/baselines/reference/objectTypesIdentity2.symbols b/tests/baselines/reference/objectTypesIdentity2.symbols index e78def5ca00..6db54e5b59a 100644 --- a/tests/baselines/reference/objectTypesIdentity2.symbols +++ b/tests/baselines/reference/objectTypesIdentity2.symbols @@ -29,13 +29,13 @@ interface I { foo: Date; >foo : Symbol(foo, Decl(objectTypesIdentity2.ts, 14, 13)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var a: { foo: RegExp; } >a : Symbol(a, Decl(objectTypesIdentity2.ts, 18, 3)) >foo : Symbol(foo, Decl(objectTypesIdentity2.ts, 18, 8)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) enum E { A } >E : Symbol(E, Decl(objectTypesIdentity2.ts, 18, 23)) diff --git a/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols b/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols index 85c138a8c34..7e081608bc0 100644 --- a/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols +++ b/tests/baselines/reference/objectTypesIdentityWithCallSignatures2.symbols @@ -51,13 +51,13 @@ var a: { foo(x: Date): string } >a : Symbol(a, Decl(objectTypesIdentityWithCallSignatures2.ts, 22, 3)) >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignatures2.ts, 22, 8)) >x : Symbol(x, Decl(objectTypesIdentityWithCallSignatures2.ts, 22, 13)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var b = { foo(x: RegExp) { return ''; } }; >b : Symbol(b, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 3)) >foo : Symbol(foo, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 9)) >x : Symbol(x, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 14)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1(x: A); >foo1 : Symbol(foo1, Decl(objectTypesIdentityWithCallSignatures2.ts, 23, 42), Decl(objectTypesIdentityWithCallSignatures2.ts, 25, 20), Decl(objectTypesIdentityWithCallSignatures2.ts, 26, 20)) diff --git a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols index 0d37d7fc97b..90ec832873c 100644 --- a/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols +++ b/tests/baselines/reference/objectTypesIdentityWithConstructSignatures2.symbols @@ -37,13 +37,13 @@ interface I2 { var a: { new(x: Date): string } >a : Symbol(a, Decl(objectTypesIdentityWithConstructSignatures2.ts, 18, 3)) >x : Symbol(x, Decl(objectTypesIdentityWithConstructSignatures2.ts, 18, 13)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var b = { new(x: RegExp) { return ''; } }; // not a construct signature, function called new >b : Symbol(b, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 3)) >new : Symbol(new, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 9)) >x : Symbol(x, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 14)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1b(x: B); >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithConstructSignatures2.ts, 19, 42), Decl(objectTypesIdentityWithConstructSignatures2.ts, 21, 21), Decl(objectTypesIdentityWithConstructSignatures2.ts, 22, 21)) diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols index 3b681c55c13..b8432af2425 100644 --- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols +++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.symbols @@ -9,7 +9,7 @@ class A { foo(x: T): string { return null; } >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 4, 9)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 5, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 5, 24)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 5, 8)) } @@ -17,7 +17,7 @@ class A { class B> { >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 8, 8)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo(x: T): string { return null; } >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 8, 34)) @@ -28,7 +28,7 @@ class B> { class C { >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 12, 8)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo(x: T): string { return null; } >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 12, 27)) @@ -39,7 +39,7 @@ class C { interface I { >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 16, 12)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo(x: T): string; >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 16, 31)) @@ -53,7 +53,7 @@ interface I2 { foo(x: T): string; >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 20, 14)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 21, 8)) ->Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11)) +>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 21, 27)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 21, 8)) } @@ -62,7 +62,7 @@ var a: { foo>(x: T): string } >a : Symbol(a, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 24, 3)) >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 24, 8)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 24, 13)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 24, 38)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 24, 13)) @@ -70,7 +70,7 @@ var b = { foo(x: T) { return ''; } }; >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 3)) >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 9)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 14)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 32)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 25, 14)) @@ -92,13 +92,13 @@ function foo1b(x: B>); >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 31, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 32, 36)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 31, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1b(x: B>); // error >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 31, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 32, 36)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 32, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1b(x: any) { } >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 31, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 32, 36)) @@ -108,13 +108,13 @@ function foo1c(x: C); >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 35, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 36, 29)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 35, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1c(x: C); // error >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 35, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 36, 29)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 36, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1c(x: any) { } >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 35, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 36, 29)) @@ -124,13 +124,13 @@ function foo2(x: I); >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 39, 28), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 40, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 39, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo2(x: I); // error >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 39, 28), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 40, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 40, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo2(x: any) { } >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 39, 28), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 40, 28)) @@ -173,7 +173,7 @@ function foo5(x: B>); // ok >foo5 : Symbol(foo5, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 49, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 51, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 52, 35)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 52, 14)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo5(x: any) { } >foo5 : Symbol(foo5, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 49, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 51, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 52, 35)) @@ -188,7 +188,7 @@ function foo5b(x: C); // ok >foo5b : Symbol(foo5b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 53, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 55, 21), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 56, 29)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 56, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo5b(x: any) { } >foo5b : Symbol(foo5b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 53, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 55, 21), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 56, 29)) @@ -203,7 +203,7 @@ function foo6(x: I); // ok >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 57, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 59, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 60, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 60, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo6(x: any) { } >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 57, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 59, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 60, 28)) @@ -227,13 +227,13 @@ function foo8(x: B>); >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 67, 35), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 68, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 67, 14)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo8(x: I); // ok >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 67, 35), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 68, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 68, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo8(x: any) { } >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 67, 35), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 68, 28)) @@ -243,13 +243,13 @@ function foo9(x: B>); >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 71, 35), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 72, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 71, 14)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo9(x: C); // ok >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 71, 35), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 72, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 72, 14)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo9(x: any) { } >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 71, 35), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 72, 28)) @@ -259,7 +259,7 @@ function foo10(x: B>); >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 73, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 75, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 76, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 75, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo10(x: typeof a); // ok >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 73, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 75, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 76, 28)) @@ -274,7 +274,7 @@ function foo11(x: B>); >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 77, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 79, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 80, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 79, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 6, 1)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo11(x: typeof b); // ok >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 77, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 79, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 80, 28)) @@ -289,13 +289,13 @@ function foo12(x: I); >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 83, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 84, 29)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 83, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12(x: C); // ok >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 83, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 84, 29)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 84, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12(x: any) { } >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 83, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 84, 29)) @@ -310,7 +310,7 @@ function foo12b(x: C); // ok >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 85, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 87, 23), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 88, 30)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 88, 16)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12b(x: any) { } >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 85, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 87, 23), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 88, 30)) @@ -320,7 +320,7 @@ function foo13(x: I); >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 89, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 91, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 92, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 91, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo13(x: typeof a); // ok >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 89, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 91, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 92, 28)) @@ -335,7 +335,7 @@ function foo14(x: I); >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 93, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 95, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 96, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 95, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 14, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo14(x: typeof b); // ok >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 93, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 95, 29), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 96, 28)) @@ -355,7 +355,7 @@ function foo15(x: C); // ok >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 97, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 99, 22), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 100, 29)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 100, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 10, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo15(x: any) { } >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 97, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 99, 22), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByConstraints.ts, 100, 29)) diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols index a9210b20f32..e199d538e4b 100644 --- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols +++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.symbols @@ -41,7 +41,7 @@ interface I { >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 16, 16)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 17, 8)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 16, 12)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface I2 { @@ -52,7 +52,7 @@ interface I2 { >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 21, 8)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 21, 11)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType.ts, 21, 8)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var a: { foo(x: T): T } diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols index e1c4e120370..a0c520ef3fa 100644 --- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols +++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.symbols @@ -9,7 +9,7 @@ class A { foo(x: T): string { return null; } >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 4, 9)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 5, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 5, 24)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 5, 8)) } @@ -17,7 +17,7 @@ class A { class B { >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 8, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo(x: T): number { return null; } >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 8, 25)) @@ -28,7 +28,7 @@ class B { class C { >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 12, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo(x: T): boolean { return null; } >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 12, 25)) @@ -39,13 +39,13 @@ class C { interface I { >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 16, 12)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo(x: T): Date; >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 16, 29)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 17, 8)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 16, 12)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface I2 { @@ -54,17 +54,17 @@ interface I2 { foo(x: T): RegExp; >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 20, 14)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 21, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 21, 24)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 21, 8)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var a: { foo(x: T): T } >a : Symbol(a, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 3)) >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 8)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 13)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 29)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 13)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 24, 13)) @@ -73,7 +73,7 @@ var b = { foo(x: T) { return null; } }; >b : Symbol(b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 3)) >foo : Symbol(foo, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 9)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 14)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 30)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 25, 14)) @@ -95,13 +95,13 @@ function foo1b(x: B); >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 31, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 32, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 31, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1b(x: B); // error >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 31, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 32, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 32, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1b(x: any) { } >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 29, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 31, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 32, 27)) @@ -111,13 +111,13 @@ function foo1c(x: C); >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 36, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 35, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1c(x: C); // error >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 36, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 36, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1c(x: any) { } >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 33, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 36, 27)) @@ -127,13 +127,13 @@ function foo2(x: I); >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 39, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 40, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 39, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo2(x: I); // error >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 39, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 40, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 40, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo2(x: any) { } >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 37, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 39, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 40, 26)) @@ -176,7 +176,7 @@ function foo5(x: B); // ok >foo5 : Symbol(foo5, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 49, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 51, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 52, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 52, 14)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo5(x: any) { } >foo5 : Symbol(foo5, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 49, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 51, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 52, 26)) @@ -191,7 +191,7 @@ function foo5b(x: C); // ok >foo5b : Symbol(foo5b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 53, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 55, 21), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 56, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 56, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo5b(x: any) { } >foo5b : Symbol(foo5b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 53, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 55, 21), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 56, 27)) @@ -206,7 +206,7 @@ function foo6(x: I); // ok >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 59, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 60, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 60, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo6(x: any) { } >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 59, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 60, 26)) @@ -230,13 +230,13 @@ function foo8(x: B); >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 67, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 68, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 67, 14)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo8(x: I); // ok >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 67, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 68, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 68, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo8(x: any) { } >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 65, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 67, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 68, 26)) @@ -246,13 +246,13 @@ function foo9(x: B); >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 71, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 72, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 71, 14)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo9(x: C); // ok >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 71, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 72, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 72, 14)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo9(x: any) { } >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 69, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 71, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 72, 26)) @@ -262,7 +262,7 @@ function foo10(x: B); >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 73, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 75, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 76, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 75, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo10(x: typeof a); // ok >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 73, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 75, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 76, 28)) @@ -277,7 +277,7 @@ function foo11(x: B); >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 77, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 79, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 80, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 79, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo11(x: typeof b); // ok >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 77, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 79, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 80, 28)) @@ -292,13 +292,13 @@ function foo12(x: I); >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 83, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 84, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 83, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12(x: C); // ok >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 83, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 84, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 84, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12(x: any) { } >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 81, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 83, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 84, 27)) @@ -313,7 +313,7 @@ function foo12b(x: C); // ok >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 85, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 87, 23), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 88, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 88, 16)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12b(x: any) { } >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 85, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 87, 23), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 88, 28)) @@ -323,7 +323,7 @@ function foo13(x: I); >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 89, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 91, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 92, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 91, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo13(x: typeof a); // ok >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 89, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 91, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 92, 28)) @@ -338,7 +338,7 @@ function foo14(x: I); >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 93, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 95, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 96, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 95, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 14, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo14(x: typeof b); // ok >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 93, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 95, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 96, 28)) @@ -358,7 +358,7 @@ function foo15(x: C); // ok >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 97, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 99, 22), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 100, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 100, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo15(x: any) { } >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 97, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 99, 22), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingByReturnType2.ts, 100, 27)) diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols index 9b801aa2c6f..a4760572e7d 100644 --- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols +++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.symbols @@ -211,7 +211,7 @@ function foo6(x: I); // ok >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 55, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 57, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 58, 51)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 58, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo6(x: any) { } >foo6 : Symbol(foo6, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 55, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 57, 20), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 58, 51)) @@ -240,7 +240,7 @@ function foo8(x: I); // error >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 63, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 65, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 66, 51)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 66, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo8(x: any) { } >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 63, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 65, 36), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 66, 51)) @@ -294,14 +294,14 @@ function foo12(x: I, number, Date, string>); >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 81, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 4, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12(x: C, number, Date>); // error >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 79, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 81, 62), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 82, 54)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 82, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 8, 1)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 4, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12(x: any) { } >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 79, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 81, 62), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 82, 54)) @@ -325,9 +325,9 @@ function foo13(x: I); >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 87, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 89, 49), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 90, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 89, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo13(x: typeof a); // ok >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 87, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 89, 49), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 90, 28)) @@ -342,8 +342,8 @@ function foo14(x: I); >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 91, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 93, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 94, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 93, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 12, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo14(x: typeof b); // ok >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 91, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 93, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts.ts, 94, 28)) diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.symbols index 7e9f1a97f69..d1f87946de5 100644 --- a/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.symbols +++ b/tests/baselines/reference/objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.symbols @@ -85,7 +85,7 @@ function foo13(x: I); >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 23, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 25, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 26, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 25, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo13(x: typeof a); // ok >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 23, 25), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 25, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 26, 28)) @@ -100,7 +100,7 @@ function foo14(x: I); >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 27, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 29, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 30, 22)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 29, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo14(x: I2); // error >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 27, 26), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 29, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 30, 22)) @@ -129,7 +129,7 @@ function foo15(x: I); >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 37, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 38, 22)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 37, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo15(x: I2); // ok >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 35, 27), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 37, 52), Decl(objectTypesIdentityWithGenericCallSignaturesDifferingTypeParameterCounts2.ts, 38, 22)) diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols index 6f53dcf17b2..fb3fba82cb2 100644 --- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols +++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.symbols @@ -6,7 +6,7 @@ class B> { >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 4, 8)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) constructor(x: T) { return null; } >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 5, 16)) @@ -16,7 +16,7 @@ class B> { class C { >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 6, 1)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 8, 8)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) constructor(x: T) { return null; } >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 9, 16)) @@ -26,7 +26,7 @@ class C { interface I { >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 12, 12)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) new(x: T): string; >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 13, 8)) @@ -38,7 +38,7 @@ interface I2 { new(x: T): string; >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 17, 8)) ->Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11)) +>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 17, 27)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 17, 8)) } @@ -46,7 +46,7 @@ interface I2 { var a: { new>(x: T): string } >a : Symbol(a, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 20, 3)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 20, 13)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 20, 38)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 20, 13)) @@ -54,7 +54,7 @@ var b = { new(x: T) { return ''; } }; // not a construct signa >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 3)) >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 9)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 14)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 32)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 14)) @@ -62,13 +62,13 @@ function foo1b(x: B>); >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 23, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 24, 36)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 23, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1b(x: B>); // error >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 23, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 24, 36)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 24, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1b(x: any) { } >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 23, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 24, 36)) @@ -78,13 +78,13 @@ function foo1c(x: C); >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 27, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 28, 29)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 27, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 6, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1c(x: C); // error >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 27, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 28, 29)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 28, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 6, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1c(x: any) { } >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 27, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 28, 29)) @@ -94,13 +94,13 @@ function foo2(x: I); >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 31, 28), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 32, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 31, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo2(x: I); // error >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 31, 28), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 32, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 32, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo2(x: any) { } >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 31, 28), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 32, 28)) @@ -138,13 +138,13 @@ function foo8(x: B>); >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 43, 35), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 44, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 43, 14)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo8(x: I); // ok >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 43, 35), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 44, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 44, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo8(x: any) { } >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 43, 35), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 44, 28)) @@ -154,13 +154,13 @@ function foo9(x: B>); >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 47, 35), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 48, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 47, 14)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo9(x: C); // error, types are structurally equal >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 47, 35), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 48, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 48, 14)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 6, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo9(x: any) { } >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 47, 35), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 48, 28)) @@ -170,7 +170,7 @@ function foo10(x: B>); >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 49, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 51, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 52, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 51, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo10(x: typeof a); // ok >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 49, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 51, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 52, 28)) @@ -185,7 +185,7 @@ function foo11(x: B>); >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 53, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 55, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 56, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 55, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 0, 0)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo11(x: typeof b); // ok >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 53, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 55, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 56, 28)) @@ -200,13 +200,13 @@ function foo12(x: I); >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 59, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 60, 29)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 59, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12(x: C); // ok >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 59, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 60, 29)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 60, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 6, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12(x: any) { } >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 59, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 60, 29)) @@ -221,7 +221,7 @@ function foo12b(x: C); // ok >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 61, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 63, 23), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 64, 30)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 64, 16)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 6, 1)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12b(x: any) { } >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 61, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 63, 23), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 64, 30)) @@ -231,7 +231,7 @@ function foo13(x: I); >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 65, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 67, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 68, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 67, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo13(x: typeof a); // ok >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 65, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 67, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 68, 28)) @@ -246,7 +246,7 @@ function foo14(x: I); >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 69, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 71, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 72, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 71, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 10, 1)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo14(x: typeof b); // ok >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 69, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 71, 29), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByConstraints.ts, 72, 28)) diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols index 703ee5d3cc4..422b5820a8b 100644 --- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols +++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.symbols @@ -28,7 +28,7 @@ interface I { new(x: T): Date; >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 13, 8)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 12, 12)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface I2 { @@ -38,7 +38,7 @@ interface I2 { >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 17, 8)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 17, 11)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType.ts, 17, 8)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var a: { new(x: T): T } diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols index faa0995c2dd..e44493e933b 100644 --- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols +++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.symbols @@ -6,7 +6,7 @@ class B { >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 4, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) constructor(x: T) { return null; } >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 5, 16)) @@ -16,7 +16,7 @@ class B { class C { >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 8, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) constructor(x: T) { return null; } >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 9, 16)) @@ -26,12 +26,12 @@ class C { interface I { >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 12, 12)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) new(x: T): Date; >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 13, 8)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 12, 12)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface I2 { @@ -39,16 +39,16 @@ interface I2 { new(x: T): RegExp; >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 17, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 17, 24)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 17, 8)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var a: { new(x: T): T } >a : Symbol(a, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 3)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 13)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 29)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 13)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 20, 13)) @@ -57,7 +57,7 @@ var b = { new(x: T) { return null; } }; // not a construct signa >b : Symbol(b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 3)) >new : Symbol(new, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 9)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 14)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 30)) >T : Symbol(T, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 14)) @@ -65,13 +65,13 @@ function foo1b(x: B); >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 23, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 24, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 23, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1b(x: B); // error >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 23, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 24, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 24, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1b(x: any) { } >foo1b : Symbol(foo1b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 21, 55), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 23, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 24, 27)) @@ -81,13 +81,13 @@ function foo1c(x: C); >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 27, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 28, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 27, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1c(x: C); // error >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 27, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 28, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 28, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo1c(x: any) { } >foo1c : Symbol(foo1c, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 25, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 27, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 28, 27)) @@ -97,13 +97,13 @@ function foo2(x: I); >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 31, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 32, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 31, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo2(x: I); // error >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 31, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 32, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 32, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo2(x: any) { } >foo2 : Symbol(foo2, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 29, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 31, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 32, 26)) @@ -141,13 +141,13 @@ function foo8(x: B); >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 43, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 44, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 43, 14)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo8(x: I); // ok >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 43, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 44, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 44, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo8(x: any) { } >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 41, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 43, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 44, 26)) @@ -157,13 +157,13 @@ function foo9(x: B); >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 47, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 48, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 47, 14)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo9(x: C); // error since types are structurally equal >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 47, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 48, 26)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 48, 14)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo9(x: any) { } >foo9 : Symbol(foo9, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 45, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 47, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 48, 26)) @@ -173,7 +173,7 @@ function foo10(x: B); >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 49, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 51, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 52, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 51, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo10(x: typeof a); // ok >foo10 : Symbol(foo10, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 49, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 51, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 52, 28)) @@ -188,7 +188,7 @@ function foo11(x: B); >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 53, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 55, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 56, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 55, 15)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo11(x: typeof b); // ok >foo11 : Symbol(foo11, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 53, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 55, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 56, 28)) @@ -203,13 +203,13 @@ function foo12(x: I); >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 59, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 60, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 59, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12(x: C); // ok >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 59, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 60, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 60, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12(x: any) { } >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 57, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 59, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 60, 27)) @@ -224,7 +224,7 @@ function foo12b(x: C); // ok >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 61, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 63, 23), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 64, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 64, 16)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12b(x: any) { } >foo12b : Symbol(foo12b, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 61, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 63, 23), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 64, 28)) @@ -234,7 +234,7 @@ function foo13(x: I); >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 65, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 67, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 68, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 67, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo13(x: typeof a); // ok >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 65, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 67, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 68, 28)) @@ -249,7 +249,7 @@ function foo14(x: I); >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 69, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 71, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 72, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 71, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 10, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo14(x: typeof b); // ok >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 69, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 71, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 72, 28)) @@ -269,7 +269,7 @@ function foo15(x: C); // ok >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 73, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 75, 22), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 76, 27)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 76, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 6, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo15(x: any) { } >foo15 : Symbol(foo15, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 73, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 75, 22), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingByReturnType2.ts, 76, 27)) diff --git a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols index d7797a833c9..48f28e40b8a 100644 --- a/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols +++ b/tests/baselines/reference/objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.symbols @@ -159,7 +159,7 @@ function foo8(x: I); // BUG 832086 >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 39, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 41, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 42, 51)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 42, 14)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 8, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo8(x: any) { } >foo8 : Symbol(foo8, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 39, 25), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 41, 36), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 42, 51)) @@ -213,14 +213,14 @@ function foo12(x: I, number, Date, string>); >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 57, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 8, 1)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12(x: C, number, Date>); // ok >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 55, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 57, 62), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 58, 54)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 58, 15)) >C : Symbol(C, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 4, 1)) >B : Symbol(B, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo12(x: any) { } >foo12 : Symbol(foo12, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 55, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 57, 62), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 58, 54)) @@ -244,9 +244,9 @@ function foo13(x: I); >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 63, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 65, 49), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 66, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 65, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 8, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo13(x: typeof a); // ok >foo13 : Symbol(foo13, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 63, 27), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 65, 49), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 66, 28)) @@ -261,8 +261,8 @@ function foo14(x: I); >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 67, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 69, 52), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 70, 28)) >x : Symbol(x, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 69, 15)) >I : Symbol(I, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 8, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function foo14(x: typeof b); // ok >foo14 : Symbol(foo14, Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 67, 26), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 69, 52), Decl(objectTypesIdentityWithGenericConstructSignaturesDifferingTypeParameterCounts.ts, 70, 28)) diff --git a/tests/baselines/reference/overloadOnGenericArity.symbols b/tests/baselines/reference/overloadOnGenericArity.symbols index 28f3c74fd2b..a9fddb65177 100644 --- a/tests/baselines/reference/overloadOnGenericArity.symbols +++ b/tests/baselines/reference/overloadOnGenericArity.symbols @@ -10,7 +10,7 @@ interface Test { then(p: string): Date; // Error: Overloads cannot differ only by return type >then : Symbol(then, Decl(overloadOnGenericArity.ts, 0, 16), Decl(overloadOnGenericArity.ts, 1, 31)) >p : Symbol(p, Decl(overloadOnGenericArity.ts, 2, 9)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols b/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols index bc2bd0785b9..02390079e38 100644 --- a/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols +++ b/tests/baselines/reference/overloadResolutionOverNonCTLambdas.symbols @@ -14,9 +14,9 @@ module Bugs { var result= message.replace(/\{(\d+)\}/g, function(match, ...rest) { >result : Symbol(result, Decl(overloadResolutionOverNonCTLambdas.ts, 6, 7)) ->message.replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63)) +>message.replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >message : Symbol(message, Decl(overloadResolutionOverNonCTLambdas.ts, 5, 16)) ->replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63)) +>replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >match : Symbol(match, Decl(overloadResolutionOverNonCTLambdas.ts, 6, 55)) >rest : Symbol(rest, Decl(overloadResolutionOverNonCTLambdas.ts, 6, 61)) diff --git a/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols b/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols index 850f188a58b..d352216b74e 100644 --- a/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols +++ b/tests/baselines/reference/overloadResolutionOverNonCTObjectLit.symbols @@ -39,17 +39,17 @@ module Bugs { >IToken : Symbol(IToken, Decl(overloadResolutionOverNonCTObjectLit.ts, 0, 13)) tokens.push({ startIndex: 1, type: '', bracket: 3 }); ->tokens.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>tokens.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >tokens : Symbol(tokens, Decl(overloadResolutionOverNonCTObjectLit.ts, 16, 35)) ->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >startIndex : Symbol(startIndex, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 45)) >type : Symbol(type, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 60)) >bracket : Symbol(bracket, Decl(overloadResolutionOverNonCTObjectLit.ts, 17, 70)) tokens.push(({ startIndex: 1, type: '', bracket: 3, state: null, length: 10 })); ->tokens.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>tokens.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >tokens : Symbol(tokens, Decl(overloadResolutionOverNonCTObjectLit.ts, 16, 35)) ->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >IToken : Symbol(IToken, Decl(overloadResolutionOverNonCTObjectLit.ts, 0, 13)) >startIndex : Symbol(startIndex, Decl(overloadResolutionOverNonCTObjectLit.ts, 18, 54)) >type : Symbol(type, Decl(overloadResolutionOverNonCTObjectLit.ts, 18, 69)) diff --git a/tests/baselines/reference/overloadResolutionWithAny.symbols b/tests/baselines/reference/overloadResolutionWithAny.symbols index af998b6b376..425855fb7da 100644 --- a/tests/baselines/reference/overloadResolutionWithAny.symbols +++ b/tests/baselines/reference/overloadResolutionWithAny.symbols @@ -37,7 +37,7 @@ var func2: { (s: string, t: any): RegExp; >s : Symbol(s, Decl(overloadResolutionWithAny.ts, 13, 5)) >t : Symbol(t, Decl(overloadResolutionWithAny.ts, 13, 15)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) (s: any, t: any): string; >s : Symbol(s, Decl(overloadResolutionWithAny.ts, 14, 5)) diff --git a/tests/baselines/reference/overloadsWithConstraints.symbols b/tests/baselines/reference/overloadsWithConstraints.symbols index 68b675093bf..4b33826e6b8 100644 --- a/tests/baselines/reference/overloadsWithConstraints.symbols +++ b/tests/baselines/reference/overloadsWithConstraints.symbols @@ -2,7 +2,7 @@ declare function f(x: T): T; >f : Symbol(f, Decl(overloadsWithConstraints.ts, 0, 0), Decl(overloadsWithConstraints.ts, 0, 46)) >T : Symbol(T, Decl(overloadsWithConstraints.ts, 0, 19)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(overloadsWithConstraints.ts, 0, 37)) >T : Symbol(T, Decl(overloadsWithConstraints.ts, 0, 19)) >T : Symbol(T, Decl(overloadsWithConstraints.ts, 0, 19)) @@ -10,7 +10,7 @@ declare function f(x: T): T; declare function f(x: T): T >f : Symbol(f, Decl(overloadsWithConstraints.ts, 0, 0), Decl(overloadsWithConstraints.ts, 0, 46)) >T : Symbol(T, Decl(overloadsWithConstraints.ts, 1, 19)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(overloadsWithConstraints.ts, 1, 37)) >T : Symbol(T, Decl(overloadsWithConstraints.ts, 1, 19)) >T : Symbol(T, Decl(overloadsWithConstraints.ts, 1, 19)) diff --git a/tests/baselines/reference/parenthesizedContexualTyping1.symbols b/tests/baselines/reference/parenthesizedContexualTyping1.symbols index 698e26734ad..e5efefb89a0 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping1.symbols +++ b/tests/baselines/reference/parenthesizedContexualTyping1.symbols @@ -102,9 +102,9 @@ var h = fun((((x => x))), ((x => x)), 10); var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10); >i : Symbol(i, Decl(parenthesizedContexualTyping1.ts, 18, 3)) >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57)) ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>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, --, --)) >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 18, 34)) >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 18, 34)) >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 18, 43)) @@ -113,9 +113,9 @@ var i = fun((Math.random() < 0.5 ? x => x : x => undefined), 10); var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10); >j : Symbol(j, Decl(parenthesizedContexualTyping1.ts, 19, 3)) >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57)) ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>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, --, --)) >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 19, 36)) >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 19, 36)) >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 19, 47)) @@ -124,9 +124,9 @@ var j = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), 10); var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10); >k : Symbol(k, Decl(parenthesizedContexualTyping1.ts, 20, 3)) >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57)) ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>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, --, --)) >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 36)) >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 36)) >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 20, 47)) @@ -137,9 +137,9 @@ var k = fun((Math.random() < 0.5 ? (x => x) : (x => undefined)), x => x, 10); var l = fun(((Math.random() < 0.5 ? ((x => x)) : ((x => undefined)))), ((x => x)), 10); >l : Symbol(l, Decl(parenthesizedContexualTyping1.ts, 21, 3)) >fun : Symbol(fun, Decl(parenthesizedContexualTyping1.ts, 0, 0), Decl(parenthesizedContexualTyping1.ts, 1, 41), Decl(parenthesizedContexualTyping1.ts, 2, 57)) ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>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, --, --)) >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 38)) >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 38)) >x : Symbol(x, Decl(parenthesizedContexualTyping1.ts, 21, 51)) diff --git a/tests/baselines/reference/parenthesizedContexualTyping2.symbols b/tests/baselines/reference/parenthesizedContexualTyping2.symbols index f7616f07710..bd735a8078a 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping2.symbols +++ b/tests/baselines/reference/parenthesizedContexualTyping2.symbols @@ -128,9 +128,9 @@ var h = fun((((x => { x(undefined); return x; }))),((x => { x(un var i = fun((Math.random() < 0.5 ? x => { x(undefined); return x; } : x => undefined), 10); >i : Symbol(i, Decl(parenthesizedContexualTyping2.ts, 25, 3)) >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51)) ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>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, --, --)) >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 25, 34)) >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 25, 34)) >undefined : Symbol(undefined) @@ -141,9 +141,9 @@ var i = fun((Math.random() < 0.5 ? x => { x(undefined); return x; } : x var j = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)), 10); >j : Symbol(j, Decl(parenthesizedContexualTyping2.ts, 26, 3)) >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51)) ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>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, --, --)) >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 26, 36)) >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 26, 36)) >undefined : Symbol(undefined) @@ -154,9 +154,9 @@ var j = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : var k = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : (x => undefined)), x => { x(undefined); return x; }, 10); >k : Symbol(k, Decl(parenthesizedContexualTyping2.ts, 27, 3)) >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51)) ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>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, --, --)) >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 36)) >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 27, 36)) >undefined : Symbol(undefined) @@ -171,9 +171,9 @@ var k = fun((Math.random() < 0.5 ? (x => { x(undefined); return x; }) : var l = fun(((Math.random() < 0.5 ? ((x => { x(undefined); return x; })) : ((x => undefined)))),((x => { x(undefined); return x; })), 10); >l : Symbol(l, Decl(parenthesizedContexualTyping2.ts, 28, 3)) >fun : Symbol(fun, Decl(parenthesizedContexualTyping2.ts, 6, 48), Decl(parenthesizedContexualTyping2.ts, 8, 38), Decl(parenthesizedContexualTyping2.ts, 9, 51)) ->Math.random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->random : Symbol(Math.random, Decl(lib.d.ts, 608, 38)) +>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, --, --)) >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 38)) >x : Symbol(x, Decl(parenthesizedContexualTyping2.ts, 28, 38)) >undefined : Symbol(undefined) diff --git a/tests/baselines/reference/parenthesizedContexualTyping3.symbols b/tests/baselines/reference/parenthesizedContexualTyping3.symbols index b0d696e2d21..4db888efd61 100644 --- a/tests/baselines/reference/parenthesizedContexualTyping3.symbols +++ b/tests/baselines/reference/parenthesizedContexualTyping3.symbols @@ -9,7 +9,7 @@ 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, 6, 17)) >tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 6, 20)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) >g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 6, 51)) >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 6, 56)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 6, 17)) @@ -22,7 +22,7 @@ function tempFun(tempStrs: TemplateStringsArray, g: (x: T) => T, h: (y: 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, 7, 17)) >tempStrs : Symbol(tempStrs, Decl(parenthesizedContexualTyping3.ts, 7, 20)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) >g : Symbol(g, Decl(parenthesizedContexualTyping3.ts, 7, 51)) >x : Symbol(x, Decl(parenthesizedContexualTyping3.ts, 7, 56)) >T : Symbol(T, Decl(parenthesizedContexualTyping3.ts, 7, 17)) @@ -39,7 +39,7 @@ 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.d.ts, 518, 38)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.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)) diff --git a/tests/baselines/reference/parenthesizedTypes.symbols b/tests/baselines/reference/parenthesizedTypes.symbols index ec0ec4e4c6f..7d7706795d5 100644 --- a/tests/baselines/reference/parenthesizedTypes.symbols +++ b/tests/baselines/reference/parenthesizedTypes.symbols @@ -40,19 +40,19 @@ var d: ({ (x: string): string } | { (x: number): number })[]; var d: Array<((x: string) => string) | ((x: number) => number)>; >d : Symbol(d, Decl(parenthesizedTypes.ts, 12, 3), Decl(parenthesizedTypes.ts, 13, 3), Decl(parenthesizedTypes.ts, 14, 3), Decl(parenthesizedTypes.ts, 15, 3), Decl(parenthesizedTypes.ts, 16, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(parenthesizedTypes.ts, 14, 15)) >x : Symbol(x, Decl(parenthesizedTypes.ts, 14, 41)) var d: Array<{ (x: string): string } | { (x: number): number }>; >d : Symbol(d, Decl(parenthesizedTypes.ts, 12, 3), Decl(parenthesizedTypes.ts, 13, 3), Decl(parenthesizedTypes.ts, 14, 3), Decl(parenthesizedTypes.ts, 15, 3), Decl(parenthesizedTypes.ts, 16, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(parenthesizedTypes.ts, 15, 16)) >x : Symbol(x, Decl(parenthesizedTypes.ts, 15, 42)) var d: (Array<{ (x: string): string } | { (x: number): number }>); >d : Symbol(d, Decl(parenthesizedTypes.ts, 12, 3), Decl(parenthesizedTypes.ts, 13, 3), Decl(parenthesizedTypes.ts, 14, 3), Decl(parenthesizedTypes.ts, 15, 3), Decl(parenthesizedTypes.ts, 16, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(parenthesizedTypes.ts, 16, 17)) >x : Symbol(x, Decl(parenthesizedTypes.ts, 16, 43)) diff --git a/tests/baselines/reference/parser630933.symbols b/tests/baselines/reference/parser630933.symbols index 70a069c3581..0f2ac0679e0 100644 --- a/tests/baselines/reference/parser630933.symbols +++ b/tests/baselines/reference/parser630933.symbols @@ -4,7 +4,7 @@ var a = "Hello"; var b = a.match(/\/ver=([^/]+)/); >b : Symbol(b, Decl(parser630933.ts, 1, 3)) ->a.match : Symbol(String.match, Decl(lib.d.ts, 317, 40), Decl(lib.d.ts, 323, 44)) +>a.match : Symbol(String.match, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(parser630933.ts, 0, 3)) ->match : Symbol(String.match, Decl(lib.d.ts, 317, 40), Decl(lib.d.ts, 323, 44)) +>match : Symbol(String.match, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/parserClassDeclaration18.errors.txt b/tests/baselines/reference/parserClassDeclaration18.errors.txt index ce4b01d5253..b5f656190bd 100644 --- a/tests/baselines/reference/parserClassDeclaration18.errors.txt +++ b/tests/baselines/reference/parserClassDeclaration18.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration18.ts(4,25): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration18.ts(4,25): error TS1183: An implementation cannot be declared in ambient contexts. ==== tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclaration18.ts (1 errors) ==== @@ -7,7 +7,7 @@ tests/cases/conformance/parser/ecmascript5/ClassDeclarations/parserClassDeclarat constructor(n: number); constructor(x: any) { ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } bar1():void; } \ No newline at end of file diff --git a/tests/baselines/reference/parserComputedPropertyName30.errors.txt b/tests/baselines/reference/parserComputedPropertyName30.errors.txt index de5bc8d7dde..94ab013c8be 100644 --- a/tests/baselines/reference/parserComputedPropertyName30.errors.txt +++ b/tests/baselines/reference/parserComputedPropertyName30.errors.txt @@ -1,14 +1,20 @@ +tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName30.ts(3,5): error TS1164: Computed property names are not allowed in enums. tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName30.ts(3,11): error TS2304: Cannot find name 'id'. tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName30.ts(4,5): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName30.ts(4,5): error TS1164: Computed property names are not allowed in enums. -==== tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName30.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName30.ts (4 errors) ==== enum E { // no ASI, comma expected [e] = id++ + ~~~ +!!! error TS1164: Computed property names are not allowed in enums. ~~ !!! error TS2304: Cannot find name 'id'. [e2] = 1 ~ !!! error TS1005: ',' expected. + ~~~~ +!!! error TS1164: Computed property names are not allowed in enums. } \ No newline at end of file diff --git a/tests/baselines/reference/parserConstructorDeclaration4.errors.txt b/tests/baselines/reference/parserConstructorDeclaration4.errors.txt index e851885f0ee..b5329a1cb47 100644 --- a/tests/baselines/reference/parserConstructorDeclaration4.errors.txt +++ b/tests/baselines/reference/parserConstructorDeclaration4.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstructorDeclaration4.ts(2,3): error TS1031: 'declare' modifier cannot appear on a class element. -tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstructorDeclaration4.ts(2,25): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstructorDeclaration4.ts(2,25): error TS1183: An implementation cannot be declared in ambient contexts. ==== tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstructorDeclaration4.ts (2 errors) ==== @@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/ConstructorDeclarations/parserConstru ~~~~~~~ !!! error TS1031: 'declare' modifier cannot appear on a class element. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } \ No newline at end of file diff --git a/tests/baselines/reference/parserEnumDeclaration6.errors.txt b/tests/baselines/reference/parserEnumDeclaration6.errors.txt deleted file mode 100644 index b9d547c07f3..00000000000 --- a/tests/baselines/reference/parserEnumDeclaration6.errors.txt +++ /dev/null @@ -1,12 +0,0 @@ -tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnumDeclaration6.ts(5,5): error TS1061: Enum member must have initializer. - - -==== tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnumDeclaration6.ts (1 errors) ==== - enum E { - A = 1, - B, - C = 1 << 1, - D, - ~ -!!! error TS1061: Enum member must have initializer. - } \ No newline at end of file diff --git a/tests/baselines/reference/parserEnumDeclaration6.symbols b/tests/baselines/reference/parserEnumDeclaration6.symbols new file mode 100644 index 00000000000..325b236fd7e --- /dev/null +++ b/tests/baselines/reference/parserEnumDeclaration6.symbols @@ -0,0 +1,16 @@ +=== tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnumDeclaration6.ts === +enum E { +>E : Symbol(E, Decl(parserEnumDeclaration6.ts, 0, 0)) + + A = 1, +>A : Symbol(E.A, Decl(parserEnumDeclaration6.ts, 0, 8)) + + B, +>B : Symbol(E.B, Decl(parserEnumDeclaration6.ts, 1, 10)) + + C = 1 << 1, +>C : Symbol(E.C, Decl(parserEnumDeclaration6.ts, 2, 6)) + + D, +>D : Symbol(E.D, Decl(parserEnumDeclaration6.ts, 3, 15)) +} diff --git a/tests/baselines/reference/parserEnumDeclaration6.types b/tests/baselines/reference/parserEnumDeclaration6.types new file mode 100644 index 00000000000..c13d66db41c --- /dev/null +++ b/tests/baselines/reference/parserEnumDeclaration6.types @@ -0,0 +1,20 @@ +=== tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnumDeclaration6.ts === +enum E { +>E : E + + A = 1, +>A : E +>1 : number + + B, +>B : E + + C = 1 << 1, +>C : E +>1 << 1 : number +>1 : number +>1 : number + + D, +>D : E +} diff --git a/tests/baselines/reference/parserFunctionDeclaration2.d.errors.txt b/tests/baselines/reference/parserFunctionDeclaration2.d.errors.txt index 9aee5f2b0e7..6f836544efc 100644 --- a/tests/baselines/reference/parserFunctionDeclaration2.d.errors.txt +++ b/tests/baselines/reference/parserFunctionDeclaration2.d.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.d.ts(1,1): error TS1046: A 'declare' modifier is required for a top level declaration in a .d.ts file. -tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.d.ts(1,14): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.d.ts(1,14): error TS1183: An implementation cannot be declared in ambient contexts. ==== tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.d.ts (2 errors) ==== @@ -7,5 +7,5 @@ tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDe ~~~~~~~~ !!! error TS1046: A 'declare' modifier is required for a top level declaration in a .d.ts file. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } \ No newline at end of file diff --git a/tests/baselines/reference/parserFunctionDeclaration2.errors.txt b/tests/baselines/reference/parserFunctionDeclaration2.errors.txt index deb96553220..f69850a5210 100644 --- a/tests/baselines/reference/parserFunctionDeclaration2.errors.txt +++ b/tests/baselines/reference/parserFunctionDeclaration2.errors.txt @@ -1,8 +1,8 @@ -tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.ts(1,24): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.ts(1,24): error TS1183: An implementation cannot be declared in ambient contexts. ==== tests/cases/conformance/parser/ecmascript5/FunctionDeclarations/parserFunctionDeclaration2.ts (1 errors) ==== declare function Foo() { ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } \ No newline at end of file diff --git a/tests/baselines/reference/parserMemberFunctionDeclaration5.errors.txt b/tests/baselines/reference/parserMemberFunctionDeclaration5.errors.txt index 12fb40ad232..402355919a0 100644 --- a/tests/baselines/reference/parserMemberFunctionDeclaration5.errors.txt +++ b/tests/baselines/reference/parserMemberFunctionDeclaration5.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/parser/ecmascript5/MemberFunctionDeclarations/parserMemberFunctionDeclaration5.ts(2,5): error TS1031: 'declare' modifier cannot appear on a class element. -tests/cases/conformance/parser/ecmascript5/MemberFunctionDeclarations/parserMemberFunctionDeclaration5.ts(2,19): error TS1184: An implementation cannot be declared in ambient contexts. +tests/cases/conformance/parser/ecmascript5/MemberFunctionDeclarations/parserMemberFunctionDeclaration5.ts(2,19): error TS1183: An implementation cannot be declared in ambient contexts. ==== tests/cases/conformance/parser/ecmascript5/MemberFunctionDeclarations/parserMemberFunctionDeclaration5.ts (2 errors) ==== @@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/MemberFunctionDeclarations/parserMemb ~~~~~~~ !!! error TS1031: 'declare' modifier cannot appear on a class element. ~ -!!! error TS1184: An implementation cannot be declared in ambient contexts. +!!! error TS1183: An implementation cannot be declared in ambient contexts. } \ No newline at end of file diff --git a/tests/baselines/reference/parserSymbolProperty1.symbols b/tests/baselines/reference/parserSymbolProperty1.symbols index f21959df892..b337b6ae30b 100644 --- a/tests/baselines/reference/parserSymbolProperty1.symbols +++ b/tests/baselines/reference/parserSymbolProperty1.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(parserSymbolProperty1.ts, 0, 0)) [Symbol.iterator]: string; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/parserSymbolProperty2.symbols b/tests/baselines/reference/parserSymbolProperty2.symbols index 9f43ba7b006..d4bfa388fa8 100644 --- a/tests/baselines/reference/parserSymbolProperty2.symbols +++ b/tests/baselines/reference/parserSymbolProperty2.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(parserSymbolProperty2.ts, 0, 0)) [Symbol.unscopables](): string; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/parserSymbolProperty3.symbols b/tests/baselines/reference/parserSymbolProperty3.symbols index e3a3b1d5609..b740d5be4ad 100644 --- a/tests/baselines/reference/parserSymbolProperty3.symbols +++ b/tests/baselines/reference/parserSymbolProperty3.symbols @@ -3,7 +3,7 @@ declare class C { >C : Symbol(C, Decl(parserSymbolProperty3.ts, 0, 0)) [Symbol.unscopables](): string; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/parserSymbolProperty4.symbols b/tests/baselines/reference/parserSymbolProperty4.symbols index ba0134e82a9..65250e977b7 100644 --- a/tests/baselines/reference/parserSymbolProperty4.symbols +++ b/tests/baselines/reference/parserSymbolProperty4.symbols @@ -3,7 +3,7 @@ declare class C { >C : Symbol(C, Decl(parserSymbolProperty4.ts, 0, 0)) [Symbol.toPrimitive]: string; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/parserSymbolProperty5.symbols b/tests/baselines/reference/parserSymbolProperty5.symbols index 970f8a0b753..c883c0aa12f 100644 --- a/tests/baselines/reference/parserSymbolProperty5.symbols +++ b/tests/baselines/reference/parserSymbolProperty5.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(parserSymbolProperty5.ts, 0, 0)) [Symbol.toPrimitive]: string; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/parserSymbolProperty6.symbols b/tests/baselines/reference/parserSymbolProperty6.symbols index 29831fad7ef..d8a2b9bf1cc 100644 --- a/tests/baselines/reference/parserSymbolProperty6.symbols +++ b/tests/baselines/reference/parserSymbolProperty6.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(parserSymbolProperty6.ts, 0, 0)) [Symbol.toStringTag]: string = ""; ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/parserSymbolProperty7.symbols b/tests/baselines/reference/parserSymbolProperty7.symbols index 8322d312839..9319dfe87bb 100644 --- a/tests/baselines/reference/parserSymbolProperty7.symbols +++ b/tests/baselines/reference/parserSymbolProperty7.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(parserSymbolProperty7.ts, 0, 0)) [Symbol.toStringTag](): void { } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/parserSymbolProperty8.symbols b/tests/baselines/reference/parserSymbolProperty8.symbols index 7c5dfbff7c6..2a58473973e 100644 --- a/tests/baselines/reference/parserSymbolProperty8.symbols +++ b/tests/baselines/reference/parserSymbolProperty8.symbols @@ -3,7 +3,7 @@ var x: { >x : Symbol(x, Decl(parserSymbolProperty8.ts, 0, 3)) [Symbol.toPrimitive](): string ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/parserSymbolProperty9.symbols b/tests/baselines/reference/parserSymbolProperty9.symbols index 7ee5e7e6998..85c66b21d5e 100644 --- a/tests/baselines/reference/parserSymbolProperty9.symbols +++ b/tests/baselines/reference/parserSymbolProperty9.symbols @@ -3,7 +3,7 @@ var x: { >x : Symbol(x, Decl(parserSymbolProperty9.ts, 0, 3)) [Symbol.toPrimitive]: string ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/plusOperatorWithStringType.symbols b/tests/baselines/reference/plusOperatorWithStringType.symbols index 1ff2cec5dff..fd3e10c172f 100644 --- a/tests/baselines/reference/plusOperatorWithStringType.symbols +++ b/tests/baselines/reference/plusOperatorWithStringType.symbols @@ -88,9 +88,9 @@ var ResultIsNumber11 = +(STRING + STRING); var ResultIsNumber12 = +STRING.charAt(0); >ResultIsNumber12 : Symbol(ResultIsNumber12, Decl(plusOperatorWithStringType.ts, 32, 3)) ->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(plusOperatorWithStringType.ts, 1, 3)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) // miss assignment operators +""; diff --git a/tests/baselines/reference/privacyCheckOnTypeParameterReferenceInConstructorParameter.types b/tests/baselines/reference/privacyCheckOnTypeParameterReferenceInConstructorParameter.types index 2000b877abd..293585db7b0 100644 --- a/tests/baselines/reference/privacyCheckOnTypeParameterReferenceInConstructorParameter.types +++ b/tests/baselines/reference/privacyCheckOnTypeParameterReferenceInConstructorParameter.types @@ -10,10 +10,10 @@ export class A{ >T1 : T1 var child = new B(this); ->child : B> ->new B(this) : B> +>child : B +>new B(this) : B >B : typeof B ->this : A +>this : this } } diff --git a/tests/baselines/reference/privacyGloImportParseErrors.errors.txt b/tests/baselines/reference/privacyGloImportParseErrors.errors.txt index d6d24ebcb30..236418a10ae 100644 --- a/tests/baselines/reference/privacyGloImportParseErrors.errors.txt +++ b/tests/baselines/reference/privacyGloImportParseErrors.errors.txt @@ -1,5 +1,5 @@ -tests/cases/compiler/privacyGloImportParseErrors.ts(22,27): error TS2435: Ambient modules cannot be nested in other modules. -tests/cases/compiler/privacyGloImportParseErrors.ts(30,20): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/privacyGloImportParseErrors.ts(22,27): error TS2435: Ambient modules cannot be nested in other modules or namespaces. +tests/cases/compiler/privacyGloImportParseErrors.ts(30,20): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/privacyGloImportParseErrors.ts(49,29): error TS4000: Import declaration 'm1_im2_private' is using private name 'm1_M2_private'. tests/cases/compiler/privacyGloImportParseErrors.ts(59,37): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyGloImportParseErrors.ts(59,37): error TS2307: Cannot find module 'm1_M3_public'. @@ -11,9 +11,9 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(82,43): error TS1147: Import tests/cases/compiler/privacyGloImportParseErrors.ts(121,38): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyGloImportParseErrors.ts(125,45): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyGloImportParseErrors.ts(133,9): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/privacyGloImportParseErrors.ts(133,24): error TS2435: Ambient modules cannot be nested in other modules. -tests/cases/compiler/privacyGloImportParseErrors.ts(138,16): error TS2435: Ambient modules cannot be nested in other modules. -tests/cases/compiler/privacyGloImportParseErrors.ts(141,12): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/privacyGloImportParseErrors.ts(133,24): error TS2435: Ambient modules cannot be nested in other modules or namespaces. +tests/cases/compiler/privacyGloImportParseErrors.ts(138,16): error TS2435: Ambient modules cannot be nested in other modules or namespaces. +tests/cases/compiler/privacyGloImportParseErrors.ts(141,12): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/privacyGloImportParseErrors.ts(146,25): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyGloImportParseErrors.ts(149,29): error TS1147: Import declarations in a namespace cannot reference a module. @@ -42,7 +42,7 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(149,29): error TS1147: Impor export declare module "m1_M3_public" { ~~~~~~~~~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. export function f1(); export class c1 { } @@ -52,7 +52,7 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(149,29): error TS1147: Impor declare module "m1_M4_private" { ~~~~~~~~~~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. export function f1(); export class c1 { } @@ -179,19 +179,19 @@ tests/cases/compiler/privacyGloImportParseErrors.ts(149,29): error TS1147: Impor ~~~~~~~ !!! error TS1038: A 'declare' modifier cannot be used in an already ambient context. ~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. } } module m2 { module "abc2" { ~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. } } module "abc3" { ~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. } } diff --git a/tests/baselines/reference/privacyImportParseErrors.errors.txt b/tests/baselines/reference/privacyImportParseErrors.errors.txt index 06277c63b23..5bae45f405c 100644 --- a/tests/baselines/reference/privacyImportParseErrors.errors.txt +++ b/tests/baselines/reference/privacyImportParseErrors.errors.txt @@ -1,48 +1,48 @@ -tests/cases/compiler/privacyImportParseErrors.ts(22,27): error TS2435: Ambient modules cannot be nested in other modules. -tests/cases/compiler/privacyImportParseErrors.ts(30,20): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/privacyImportParseErrors.ts(22,27): error TS2435: Ambient modules cannot be nested in other modules or namespaces. +tests/cases/compiler/privacyImportParseErrors.ts(30,20): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/privacyImportParseErrors.ts(59,37): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyImportParseErrors.ts(59,37): error TS2307: Cannot find module 'm1_M3_public'. tests/cases/compiler/privacyImportParseErrors.ts(69,37): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyImportParseErrors.ts(69,37): error TS2307: Cannot find module 'm1_M4_private'. tests/cases/compiler/privacyImportParseErrors.ts(81,43): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyImportParseErrors.ts(82,43): error TS1147: Import declarations in a namespace cannot reference a module. -tests/cases/compiler/privacyImportParseErrors.ts(106,27): error TS2435: Ambient modules cannot be nested in other modules. -tests/cases/compiler/privacyImportParseErrors.ts(114,20): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/privacyImportParseErrors.ts(106,27): error TS2435: Ambient modules cannot be nested in other modules or namespaces. +tests/cases/compiler/privacyImportParseErrors.ts(114,20): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/privacyImportParseErrors.ts(143,37): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyImportParseErrors.ts(143,37): error TS2307: Cannot find module 'm2_M3_public'. tests/cases/compiler/privacyImportParseErrors.ts(153,37): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyImportParseErrors.ts(153,37): error TS2307: Cannot find module 'm2_M4_private'. tests/cases/compiler/privacyImportParseErrors.ts(166,43): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyImportParseErrors.ts(167,43): error TS1147: Import declarations in a namespace cannot reference a module. -tests/cases/compiler/privacyImportParseErrors.ts(180,23): error TS2435: Ambient modules cannot be nested in other modules. -tests/cases/compiler/privacyImportParseErrors.ts(198,23): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/privacyImportParseErrors.ts(180,23): error TS2435: Ambient modules cannot be nested in other modules or namespaces. +tests/cases/compiler/privacyImportParseErrors.ts(198,23): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/privacyImportParseErrors.ts(218,34): error TS2307: Cannot find module 'glo_M2_public'. tests/cases/compiler/privacyImportParseErrors.ts(238,34): error TS2307: Cannot find module 'glo_M4_private'. tests/cases/compiler/privacyImportParseErrors.ts(251,40): error TS2307: Cannot find module 'glo_M2_public'. tests/cases/compiler/privacyImportParseErrors.ts(252,40): error TS2307: Cannot find module 'glo_M4_private'. -tests/cases/compiler/privacyImportParseErrors.ts(255,23): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/privacyImportParseErrors.ts(255,23): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/privacyImportParseErrors.ts(258,45): error TS2304: Cannot find name 'use_glo_M1_public'. tests/cases/compiler/privacyImportParseErrors.ts(261,39): error TS2304: Cannot find name 'use_glo_M1_public'. tests/cases/compiler/privacyImportParseErrors.ts(264,40): error TS2307: Cannot find module 'glo_M2_public'. tests/cases/compiler/privacyImportParseErrors.ts(273,38): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyImportParseErrors.ts(277,45): error TS1147: Import declarations in a namespace cannot reference a module. -tests/cases/compiler/privacyImportParseErrors.ts(284,16): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/privacyImportParseErrors.ts(284,16): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/privacyImportParseErrors.ts(287,46): error TS2304: Cannot find name 'use_glo_M3_private'. tests/cases/compiler/privacyImportParseErrors.ts(290,40): error TS2304: Cannot find name 'use_glo_M3_private'. tests/cases/compiler/privacyImportParseErrors.ts(293,41): error TS2307: Cannot find module 'glo_M4_private'. tests/cases/compiler/privacyImportParseErrors.ts(302,38): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyImportParseErrors.ts(306,45): error TS1147: Import declarations in a namespace cannot reference a module. -tests/cases/compiler/privacyImportParseErrors.ts(312,16): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/privacyImportParseErrors.ts(312,16): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/privacyImportParseErrors.ts(314,9): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/privacyImportParseErrors.ts(314,24): error TS2435: Ambient modules cannot be nested in other modules. -tests/cases/compiler/privacyImportParseErrors.ts(319,16): error TS2435: Ambient modules cannot be nested in other modules. -tests/cases/compiler/privacyImportParseErrors.ts(322,12): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/privacyImportParseErrors.ts(314,24): error TS2435: Ambient modules cannot be nested in other modules or namespaces. +tests/cases/compiler/privacyImportParseErrors.ts(319,16): error TS2435: Ambient modules cannot be nested in other modules or namespaces. +tests/cases/compiler/privacyImportParseErrors.ts(322,12): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/privacyImportParseErrors.ts(326,9): error TS1029: 'export' modifier must precede 'declare' modifier. -tests/cases/compiler/privacyImportParseErrors.ts(326,23): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/privacyImportParseErrors.ts(326,23): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/privacyImportParseErrors.ts(328,9): error TS1038: A 'declare' modifier cannot be used in an already ambient context. -tests/cases/compiler/privacyImportParseErrors.ts(328,24): error TS2435: Ambient modules cannot be nested in other modules. -tests/cases/compiler/privacyImportParseErrors.ts(333,16): error TS2435: Ambient modules cannot be nested in other modules. -tests/cases/compiler/privacyImportParseErrors.ts(336,12): error TS2435: Ambient modules cannot be nested in other modules. +tests/cases/compiler/privacyImportParseErrors.ts(328,24): error TS2435: Ambient modules cannot be nested in other modules or namespaces. +tests/cases/compiler/privacyImportParseErrors.ts(333,16): error TS2435: Ambient modules cannot be nested in other modules or namespaces. +tests/cases/compiler/privacyImportParseErrors.ts(336,12): error TS2435: Ambient modules cannot be nested in other modules or namespaces. tests/cases/compiler/privacyImportParseErrors.ts(341,25): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyImportParseErrors.ts(344,29): error TS1147: Import declarations in a namespace cannot reference a module. tests/cases/compiler/privacyImportParseErrors.ts(350,25): error TS1147: Import declarations in a namespace cannot reference a module. @@ -73,7 +73,7 @@ tests/cases/compiler/privacyImportParseErrors.ts(353,29): error TS1147: Import d export declare module "m1_M3_public" { ~~~~~~~~~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. export function f1(); export class c1 { } @@ -83,7 +83,7 @@ tests/cases/compiler/privacyImportParseErrors.ts(353,29): error TS1147: Import d declare module "m1_M4_private" { ~~~~~~~~~~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. export function f1(); export class c1 { } @@ -173,7 +173,7 @@ tests/cases/compiler/privacyImportParseErrors.ts(353,29): error TS1147: Import d export declare module "m2_M3_public" { ~~~~~~~~~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. export function f1(); export class c1 { } @@ -183,7 +183,7 @@ tests/cases/compiler/privacyImportParseErrors.ts(353,29): error TS1147: Import d declare module "m2_M4_private" { ~~~~~~~~~~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. export function f1(); export class c1 { } @@ -263,7 +263,7 @@ tests/cases/compiler/privacyImportParseErrors.ts(353,29): error TS1147: Import d export declare module "glo_M2_public" { ~~~~~~~~~~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. export function f1(); export class c1 { } @@ -283,7 +283,7 @@ tests/cases/compiler/privacyImportParseErrors.ts(353,29): error TS1147: Import d export declare module "glo_M4_private" { ~~~~~~~~~~~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. export function f1(); export class c1 { } @@ -350,7 +350,7 @@ tests/cases/compiler/privacyImportParseErrors.ts(353,29): error TS1147: Import d export declare module "use_glo_M1_public" { ~~~~~~~~~~~~~~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. import use_glo_M1_public = glo_M1_public; export var use_glo_M1_public_v1_public: { new (): use_glo_M1_public.c1; }; export var use_glo_M1_public_v2_public: use_glo_M1_public; @@ -391,7 +391,7 @@ tests/cases/compiler/privacyImportParseErrors.ts(353,29): error TS1147: Import d declare module "use_glo_M3_private" { ~~~~~~~~~~~~~~~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. import use_glo_M3_private = glo_M3_private; export var use_glo_M3_private_v1_public: { new (): use_glo_M3_private.c1; }; export var use_glo_M3_private_v2_public: use_glo_M3_private; @@ -431,25 +431,25 @@ tests/cases/compiler/privacyImportParseErrors.ts(353,29): error TS1147: Import d declare module "anotherParseError" { ~~~~~~~~~~~~~~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. module m2 { declare module "abc" { ~~~~~~~ !!! error TS1038: A 'declare' modifier cannot be used in an already ambient context. ~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. } } module m2 { module "abc2" { ~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. } } module "abc3" { ~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. } } @@ -457,25 +457,25 @@ tests/cases/compiler/privacyImportParseErrors.ts(353,29): error TS1147: Import d ~~~~~~ !!! error TS1029: 'export' modifier must precede 'declare' modifier. ~~~~~~~~~~~~~~~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. module m2 { declare module "abc" { ~~~~~~~ !!! error TS1038: A 'declare' modifier cannot be used in an already ambient context. ~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. } } module m2 { module "abc2" { ~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. } } module "abc3" { ~~~~~~ -!!! error TS2435: Ambient modules cannot be nested in other modules. +!!! error TS2435: Ambient modules cannot be nested in other modules or namespaces. } } diff --git a/tests/baselines/reference/privateInstanceMemberAccessibility.errors.txt b/tests/baselines/reference/privateInstanceMemberAccessibility.errors.txt index 7893100b5a5..adca4e30e10 100644 --- a/tests/baselines/reference/privateInstanceMemberAccessibility.errors.txt +++ b/tests/baselines/reference/privateInstanceMemberAccessibility.errors.txt @@ -1,9 +1,10 @@ +tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(5,7): error TS2415: Class 'Derived' incorrectly extends base class 'Base'. + Property 'foo' is private in type 'Base' but not in type 'Derived'. tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(6,15): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(8,22): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(10,15): error TS1003: Identifier expected. tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(10,21): error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. -tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(12,8): error TS1110: Type expected. -tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(12,8): error TS2341: Property 'foo' is private and only accessible within class 'Base'. +tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts(12,12): error TS1005: ';' expected. ==== tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAccessibility.ts (6 errors) ==== @@ -12,6 +13,9 @@ tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAcces } class Derived extends Base { + ~~~~~~~ +!!! error TS2415: Class 'Derived' incorrectly extends base class 'Base'. +!!! error TS2415: Property 'foo' is private in type 'Base' but not in type 'Derived'. x = super.foo; // error ~~~ !!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. @@ -27,8 +31,6 @@ tests/cases/conformance/classes/members/accessibility/privateInstanceMemberAcces !!! error TS2340: Only public and protected methods of the base class are accessible via the 'super' keyword. a: this.foo; // error - ~~~~ -!!! error TS1110: Type expected. - ~~~~~~~~ -!!! error TS2341: Property 'foo' is private and only accessible within class 'Base'. + ~ +!!! error TS1005: ';' expected. } \ No newline at end of file diff --git a/tests/baselines/reference/privateInstanceMemberAccessibility.js b/tests/baselines/reference/privateInstanceMemberAccessibility.js index ac2f44ee5d9..0ba2093a5c7 100644 --- a/tests/baselines/reference/privateInstanceMemberAccessibility.js +++ b/tests/baselines/reference/privateInstanceMemberAccessibility.js @@ -30,7 +30,6 @@ var Derived = (function (_super) { _super.apply(this, arguments); this.x = _super.prototype.foo; // error this.z = _super.prototype.foo; // error - this.a = this.foo; // error } Derived.prototype.y = function () { return _super.prototype.foo; // error diff --git a/tests/baselines/reference/privateInstanceVisibility.types b/tests/baselines/reference/privateInstanceVisibility.types index 109309ceb76..54a2c51ec14 100644 --- a/tests/baselines/reference/privateInstanceVisibility.types +++ b/tests/baselines/reference/privateInstanceVisibility.types @@ -14,8 +14,8 @@ module Test { >doSomething : () => void var that = this; ->that : Example ->this : Example +>that : this +>this : this function innerFunction() { >innerFunction : () => void @@ -23,7 +23,7 @@ module Test { var num = that.someNumber; >num : number >that.someNumber : number ->that : Example +>that : this >someNumber : number } @@ -45,7 +45,7 @@ class C { getX() { return this.x; } >getX : () => number >this.x : number ->this : C +>this : this >x : number clone(other: C) { @@ -56,7 +56,7 @@ class C { this.x = other.x; >this.x = other.x : number >this.x : number ->this : C +>this : this >x : number >other.x : number >other : C diff --git a/tests/baselines/reference/privateVisibles.types b/tests/baselines/reference/privateVisibles.types index e7c192d54db..71e26d7e264 100644 --- a/tests/baselines/reference/privateVisibles.types +++ b/tests/baselines/reference/privateVisibles.types @@ -10,7 +10,7 @@ class Foo { var n = this.pvar; >n : number >this.pvar : number ->this : Foo +>this : this >pvar : number } @@ -18,7 +18,7 @@ class Foo { >meth : () => void >q : number >this.pvar : number ->this : Foo +>this : this >pvar : number } diff --git a/tests/baselines/reference/promiseChaining.symbols b/tests/baselines/reference/promiseChaining.symbols index 1ad7044faae..f13323742ce 100644 --- a/tests/baselines/reference/promiseChaining.symbols +++ b/tests/baselines/reference/promiseChaining.symbols @@ -38,9 +38,9 @@ class Chain { >x : Symbol(x, Decl(promiseChaining.ts, 5, 49)) >then : Symbol(Chain.then, Decl(promiseChaining.ts, 1, 36)) >x : Symbol(x, Decl(promiseChaining.ts, 5, 76)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(promiseChaining.ts, 5, 76)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) return new Chain(result); >Chain : Symbol(Chain, Decl(promiseChaining.ts, 0, 0)) diff --git a/tests/baselines/reference/promiseChaining.types b/tests/baselines/reference/promiseChaining.types index 981a19ef0a9..23a8b276fdc 100644 --- a/tests/baselines/reference/promiseChaining.types +++ b/tests/baselines/reference/promiseChaining.types @@ -22,7 +22,7 @@ class Chain { >cb(this.value) : S >cb : (x: T) => S >this.value : T ->this : Chain +>this : this >value : T // should get a fresh type parameter which each then call @@ -34,7 +34,7 @@ class Chain { >this.then(x => result)/*S*/.then : (cb: (x: S) => S) => Chain >this.then(x => result) : Chain >this.then : (cb: (x: T) => S) => Chain ->this : Chain +>this : this >then : (cb: (x: T) => S) => Chain >x => result : (x: T) => S >x : T diff --git a/tests/baselines/reference/promiseVoidErrorCallback.symbols b/tests/baselines/reference/promiseVoidErrorCallback.symbols index 3fc23ce5253..93e86b9ec2e 100644 --- a/tests/baselines/reference/promiseVoidErrorCallback.symbols +++ b/tests/baselines/reference/promiseVoidErrorCallback.symbols @@ -22,13 +22,13 @@ interface T3 { function f1(): Promise { >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T1 : Symbol(T1, Decl(promiseVoidErrorCallback.ts, 0, 0)) return Promise.resolve({ __t1: "foo_t1" }); ->Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 5136, 39), Decl(lib.d.ts, 5143, 54)) ->Promise : Symbol(Promise, Decl(lib.d.ts, 5068, 1), Decl(lib.d.ts, 5154, 11)) ->resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, 5136, 39), Decl(lib.d.ts, 5143, 54)) +>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >__t1 : Symbol(__t1, Decl(promiseVoidErrorCallback.ts, 13, 28)) } @@ -47,22 +47,22 @@ function f2(x: T1): T2 { var x3 = f1() >x3 : Symbol(x3, Decl(promiseVoidErrorCallback.ts, 20, 3)) ->f1() .then(f2, (e: Error) => { throw e;}) .then : Symbol(Promise.then, Decl(lib.d.ts, 5073, 22), Decl(lib.d.ts, 5080, 158)) ->f1() .then : Symbol(Promise.then, Decl(lib.d.ts, 5073, 22), Decl(lib.d.ts, 5080, 158)) +>f1() .then(f2, (e: Error) => { throw e;}) .then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>f1() .then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >f1 : Symbol(f1, Decl(promiseVoidErrorCallback.ts, 10, 1)) .then(f2, (e: Error) => { ->then : Symbol(Promise.then, Decl(lib.d.ts, 5073, 22), Decl(lib.d.ts, 5080, 158)) +>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >f2 : Symbol(f2, Decl(promiseVoidErrorCallback.ts, 14, 1)) >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15)) ->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw e; >e : Symbol(e, Decl(promiseVoidErrorCallback.ts, 21, 15)) }) .then((x: T2) => { ->then : Symbol(Promise.then, Decl(lib.d.ts, 5073, 22), Decl(lib.d.ts, 5080, 158)) +>then : Symbol(Promise.then, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(promiseVoidErrorCallback.ts, 24, 11)) >T2 : Symbol(T2, Decl(promiseVoidErrorCallback.ts, 2, 1)) diff --git a/tests/baselines/reference/propagationOfPromiseInitialization.symbols b/tests/baselines/reference/propagationOfPromiseInitialization.symbols index 2289c175168..25527f05809 100644 --- a/tests/baselines/reference/propagationOfPromiseInitialization.symbols +++ b/tests/baselines/reference/propagationOfPromiseInitialization.symbols @@ -36,9 +36,9 @@ foo.then((x) => { // x is inferred to be string x.length; ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(propagationOfPromiseInitialization.ts, 8, 9)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) return 123; }); diff --git a/tests/baselines/reference/propertyAccess7.symbols b/tests/baselines/reference/propertyAccess7.symbols index f6407ae8c3c..9f9dd879f6a 100644 --- a/tests/baselines/reference/propertyAccess7.symbols +++ b/tests/baselines/reference/propertyAccess7.symbols @@ -3,7 +3,7 @@ var foo: string; >foo : Symbol(foo, Decl(propertyAccess7.ts, 0, 3)) foo.toUpperCase(); ->foo.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32)) +>foo.toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --)) >foo : Symbol(foo, Decl(propertyAccess7.ts, 0, 3)) ->toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, 405, 32)) +>toUpperCase : Symbol(String.toUpperCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols index 99856e99ae1..bf5cb72a708 100644 --- a/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols +++ b/tests/baselines/reference/propertyAccessOnTypeParameterWithConstraints.symbols @@ -5,7 +5,7 @@ class C { >C : Symbol(C, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 0, 0)) >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 3, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) f() { >f : Symbol(f, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 3, 25)) @@ -17,13 +17,13 @@ class C { var a = x['getDate'](); // number >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 6, 11)) >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 5, 11)) ->'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) return a + x.getDate(); >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 6, 11)) ->x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 5, 11)) ->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) } } @@ -31,13 +31,13 @@ var r = (new C()).f(); >r : Symbol(r, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 11, 3)) >(new C()).f : Symbol(C.f, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 3, 25)) >C : Symbol(C, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 0, 0)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >f : Symbol(C.f, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 3, 25)) interface I { >I : Symbol(I, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 11, 28)) >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 12)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo: T; >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 29)) @@ -46,42 +46,42 @@ interface I { var i: I; >i : Symbol(i, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 16, 3)) >I : Symbol(I, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 11, 28)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r2 = i.foo.getDate(); >r2 : Symbol(r2, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 17, 3)) ->i.foo.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>i.foo.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) >i.foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 29)) >i : Symbol(i, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 16, 3)) >foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 29)) ->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) var r2b = i.foo['getDate'](); >r2b : Symbol(r2b, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 18, 3)) >i.foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 29)) >i : Symbol(i, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 16, 3)) >foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 13, 29)) ->'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) var a: { >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 20, 3)) (): T; >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 21, 5)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 21, 5)) } var r3 = a().getDate(); >r3 : Symbol(r3, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 23, 3)) ->a().getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>a().getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 20, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) var r3b = a()['getDate'](); >r3b : Symbol(r3b, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 24, 3)) >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 20, 3)) ->'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) var b = { >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 3)) @@ -89,20 +89,20 @@ var b = { foo: (x: T) => { >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 9)) >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 10)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 26)) >T : Symbol(T, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 10)) var a = x['getDate'](); // number >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 28, 11)) >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 26)) ->'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>'getDate' : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) return a + x.getDate(); >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 28, 11)) ->x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>x.getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 27, 26)) ->getDate : Symbol(Date.getDate, Decl(lib.d.ts, 660, 26)) +>getDate : Symbol(Date.getDate, Decl(lib.d.ts, --, --)) } } @@ -111,5 +111,5 @@ var r4 = b.foo(new Date()); >b.foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 9)) >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 3)) >foo : Symbol(foo, Decl(propertyAccessOnTypeParameterWithConstraints.ts, 26, 9)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols b/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols index 425c7e42aff..7417346a791 100644 --- a/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols +++ b/tests/baselines/reference/propertyAccessOnTypeParameterWithoutConstraints.symbols @@ -13,13 +13,13 @@ class C { var a = x['toString'](); // should be string >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 3, 11)) >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 2, 11)) ->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --)) return a + x.toString(); >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 3, 11)) ->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 2, 11)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) } } @@ -43,18 +43,18 @@ var i: I; var r2 = i.foo.toString(); >r2 : Symbol(r2, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 14, 3)) ->i.foo.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>i.foo.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >i.foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 10, 16)) >i : Symbol(i, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 13, 3)) >foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 10, 16)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) var r2b = i.foo['toString'](); >r2b : Symbol(r2b, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 15, 3)) >i.foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 10, 16)) >i : Symbol(i, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 13, 3)) >foo : Symbol(I.foo, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 10, 16)) ->'toString' : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>'toString' : Symbol(Number.toString, Decl(lib.d.ts, --, --)) var a: { >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 17, 3)) @@ -65,14 +65,14 @@ var a: { } var r3: string = a().toString(); >r3 : Symbol(r3, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 20, 3)) ->a().toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>a().toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 17, 3)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) var r3b: string = a()['toString'](); >r3b : Symbol(r3b, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 21, 3)) >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 17, 3)) ->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --)) var b = { >b : Symbol(b, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 23, 3)) @@ -86,13 +86,13 @@ var b = { var a = x['toString'](); // should be string >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 25, 11)) >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 24, 13)) ->'toString' : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>'toString' : Symbol(Object.toString, Decl(lib.d.ts, --, --)) return a + x.toString(); >a : Symbol(a, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 25, 11)) ->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(propertyAccessOnTypeParameterWithoutConstraints.ts, 24, 13)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/protectedClassPropertyAccessibleWithinClass.types b/tests/baselines/reference/protectedClassPropertyAccessibleWithinClass.types index 98e5c120c3d..1e325d1d6f5 100644 --- a/tests/baselines/reference/protectedClassPropertyAccessibleWithinClass.types +++ b/tests/baselines/reference/protectedClassPropertyAccessibleWithinClass.types @@ -10,7 +10,7 @@ class C { protected get y() { return this.x; } >y : string >this.x : string ->this : C +>this : this >x : string protected set y(x) { this.y = this.x; } @@ -18,16 +18,16 @@ class C { >x : string >this.y = this.x : string >this.y : string ->this : C +>this : this >y : string >this.x : string ->this : C +>this : this >x : string protected foo() { return this.foo; } >foo : () => any >this.foo : () => any ->this : C +>this : this >foo : () => any protected static x: string; @@ -75,7 +75,7 @@ class C2 { >y : any >() => this.x : () => string >this.x : string ->this : C2 +>this : this >x : string >null : null @@ -85,17 +85,17 @@ class C2 { >() => { this.y = this.x; } : () => void >this.y = this.x : string >this.y : any ->this : C2 +>this : this >y : any >this.x : string ->this : C2 +>this : this >x : string protected foo() { () => this.foo; } >foo : () => void >() => this.foo : () => () => void >this.foo : () => void ->this : C2 +>this : this >foo : () => void protected static x: string; diff --git a/tests/baselines/reference/protectedClassPropertyAccessibleWithinSubclass.types b/tests/baselines/reference/protectedClassPropertyAccessibleWithinSubclass.types index bd230239d47..863f3100599 100644 --- a/tests/baselines/reference/protectedClassPropertyAccessibleWithinSubclass.types +++ b/tests/baselines/reference/protectedClassPropertyAccessibleWithinSubclass.types @@ -18,7 +18,7 @@ class C extends B { protected get y() { return this.x; } >y : string >this.x : string ->this : C +>this : this >x : string protected set y(x) { this.y = this.x; } @@ -26,23 +26,23 @@ class C extends B { >x : string >this.y = this.x : string >this.y : string ->this : C +>this : this >y : string >this.x : string ->this : C +>this : this >x : string protected foo() { return this.x; } >foo : () => string >this.x : string ->this : C +>this : this >x : string protected bar() { return this.foo(); } >bar : () => string >this.foo() : string >this.foo : () => string ->this : C +>this : this >foo : () => string protected static get y() { return this.x; } diff --git a/tests/baselines/reference/protoInIndexer.types b/tests/baselines/reference/protoInIndexer.types index 48e8b5d56dc..bfafc56404a 100644 --- a/tests/baselines/reference/protoInIndexer.types +++ b/tests/baselines/reference/protoInIndexer.types @@ -6,7 +6,7 @@ class X { this['__proto__'] = null; // used to cause ICE >this['__proto__'] = null : null >this['__proto__'] : any ->this : X +>this : this >'__proto__' : string >null : null } diff --git a/tests/baselines/reference/prototypeOnConstructorFunctions.symbols b/tests/baselines/reference/prototypeOnConstructorFunctions.symbols index ada59370532..d3644ad89b2 100644 --- a/tests/baselines/reference/prototypeOnConstructorFunctions.symbols +++ b/tests/baselines/reference/prototypeOnConstructorFunctions.symbols @@ -15,9 +15,9 @@ var i: I1; i.const.prototype.prop = "yo"; ->i.const.prototype : Symbol(Function.prototype, Decl(lib.d.ts, 249, 48)) +>i.const.prototype : Symbol(Function.prototype, Decl(lib.d.ts, --, --)) >i.const : Symbol(I1.const, Decl(prototypeOnConstructorFunctions.ts, 0, 14)) >i : Symbol(i, Decl(prototypeOnConstructorFunctions.ts, 5, 3)) >const : Symbol(I1.const, Decl(prototypeOnConstructorFunctions.ts, 0, 14)) ->prototype : Symbol(Function.prototype, Decl(lib.d.ts, 249, 48)) +>prototype : Symbol(Function.prototype, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/quotedPropertyName3.types b/tests/baselines/reference/quotedPropertyName3.types index 53d375f7621..7c957372e0d 100644 --- a/tests/baselines/reference/quotedPropertyName3.types +++ b/tests/baselines/reference/quotedPropertyName3.types @@ -10,7 +10,7 @@ class Test { >x : () => number >() => this["prop1"] : () => number >this["prop1"] : number ->this : Test +>this : this >"prop1" : string var y: number = x(); diff --git a/tests/baselines/reference/recursiveComplicatedClasses.types b/tests/baselines/reference/recursiveComplicatedClasses.types index 247b9ee27c5..1bb48a3c0c9 100644 --- a/tests/baselines/reference/recursiveComplicatedClasses.types +++ b/tests/baselines/reference/recursiveComplicatedClasses.types @@ -24,7 +24,7 @@ class Symbol { >bound : boolean public visible() { ->visible : () => boolean +>visible : () => any var b: TypeSymbol; >b : TypeSymbol diff --git a/tests/baselines/reference/recursiveGenericUnionType1.js b/tests/baselines/reference/recursiveGenericUnionType1.js new file mode 100644 index 00000000000..54faae39b86 --- /dev/null +++ b/tests/baselines/reference/recursiveGenericUnionType1.js @@ -0,0 +1,29 @@ +//// [recursiveGenericUnionType1.ts] +declare module Test1 { + export type Container = T | { + [i: string]: Container; + }; + export type IStringContainer = Container; +} + +declare module Test2 { + export type Container = T | { + [i: string]: Container; + }; + export type IStringContainer = Container; +} + +var x: Test1.Container; + +var s1: Test1.IStringContainer; +var s2: Test2.IStringContainer; +s1 = s2; +s2 = s1; + + +//// [recursiveGenericUnionType1.js] +var x; +var s1; +var s2; +s1 = s2; +s2 = s1; diff --git a/tests/baselines/reference/recursiveGenericUnionType1.symbols b/tests/baselines/reference/recursiveGenericUnionType1.symbols new file mode 100644 index 00000000000..bd48cf90cde --- /dev/null +++ b/tests/baselines/reference/recursiveGenericUnionType1.symbols @@ -0,0 +1,62 @@ +=== tests/cases/compiler/recursiveGenericUnionType1.ts === +declare module Test1 { +>Test1 : Symbol(Test1, Decl(recursiveGenericUnionType1.ts, 0, 0)) + + export type Container = T | { +>Container : Symbol(Container, Decl(recursiveGenericUnionType1.ts, 0, 22)) +>T : Symbol(T, Decl(recursiveGenericUnionType1.ts, 1, 26)) +>T : Symbol(T, Decl(recursiveGenericUnionType1.ts, 1, 26)) + + [i: string]: Container; +>i : Symbol(i, Decl(recursiveGenericUnionType1.ts, 2, 9)) +>Container : Symbol(Container, Decl(recursiveGenericUnionType1.ts, 0, 22)) +>T : Symbol(T, Decl(recursiveGenericUnionType1.ts, 1, 26)) + + }; + export type IStringContainer = Container; +>IStringContainer : Symbol(IStringContainer, Decl(recursiveGenericUnionType1.ts, 3, 6)) +>Container : Symbol(Container, Decl(recursiveGenericUnionType1.ts, 0, 22)) +} + +declare module Test2 { +>Test2 : Symbol(Test2, Decl(recursiveGenericUnionType1.ts, 5, 1)) + + export type Container = T | { +>Container : Symbol(Container, Decl(recursiveGenericUnionType1.ts, 7, 22)) +>T : Symbol(T, Decl(recursiveGenericUnionType1.ts, 8, 26)) +>T : Symbol(T, Decl(recursiveGenericUnionType1.ts, 8, 26)) + + [i: string]: Container; +>i : Symbol(i, Decl(recursiveGenericUnionType1.ts, 9, 9)) +>Container : Symbol(Container, Decl(recursiveGenericUnionType1.ts, 7, 22)) +>T : Symbol(T, Decl(recursiveGenericUnionType1.ts, 8, 26)) + + }; + export type IStringContainer = Container; +>IStringContainer : Symbol(IStringContainer, Decl(recursiveGenericUnionType1.ts, 10, 6)) +>Container : Symbol(Container, Decl(recursiveGenericUnionType1.ts, 7, 22)) +} + +var x: Test1.Container; +>x : Symbol(x, Decl(recursiveGenericUnionType1.ts, 14, 3)) +>Test1 : Symbol(Test1, Decl(recursiveGenericUnionType1.ts, 0, 0)) +>Container : Symbol(Test1.Container, Decl(recursiveGenericUnionType1.ts, 0, 22)) + +var s1: Test1.IStringContainer; +>s1 : Symbol(s1, Decl(recursiveGenericUnionType1.ts, 16, 3)) +>Test1 : Symbol(Test1, Decl(recursiveGenericUnionType1.ts, 0, 0)) +>IStringContainer : Symbol(Test1.IStringContainer, Decl(recursiveGenericUnionType1.ts, 3, 6)) + +var s2: Test2.IStringContainer; +>s2 : Symbol(s2, Decl(recursiveGenericUnionType1.ts, 17, 3)) +>Test2 : Symbol(Test2, Decl(recursiveGenericUnionType1.ts, 5, 1)) +>IStringContainer : Symbol(Test2.IStringContainer, Decl(recursiveGenericUnionType1.ts, 10, 6)) + +s1 = s2; +>s1 : Symbol(s1, Decl(recursiveGenericUnionType1.ts, 16, 3)) +>s2 : Symbol(s2, Decl(recursiveGenericUnionType1.ts, 17, 3)) + +s2 = s1; +>s2 : Symbol(s2, Decl(recursiveGenericUnionType1.ts, 17, 3)) +>s1 : Symbol(s1, Decl(recursiveGenericUnionType1.ts, 16, 3)) + diff --git a/tests/baselines/reference/recursiveGenericUnionType1.types b/tests/baselines/reference/recursiveGenericUnionType1.types new file mode 100644 index 00000000000..c153aba0e7c --- /dev/null +++ b/tests/baselines/reference/recursiveGenericUnionType1.types @@ -0,0 +1,64 @@ +=== tests/cases/compiler/recursiveGenericUnionType1.ts === +declare module Test1 { +>Test1 : any + + export type Container = T | { +>Container : T | { [i: string]: T | any; } +>T : T +>T : T + + [i: string]: Container; +>i : string +>Container : T | { [i: string]: T | any; } +>T : T + + }; + export type IStringContainer = Container; +>IStringContainer : string | { [i: string]: string | any; } +>Container : T | { [i: string]: T | any; } +} + +declare module Test2 { +>Test2 : any + + export type Container = T | { +>Container : T | { [i: string]: T | any; } +>T : T +>T : T + + [i: string]: Container; +>i : string +>Container : T | { [i: string]: T | any; } +>T : T + + }; + export type IStringContainer = Container; +>IStringContainer : string | { [i: string]: string | any; } +>Container : T | { [i: string]: T | any; } +} + +var x: Test1.Container; +>x : number | { [i: string]: number | any; } +>Test1 : any +>Container : T | { [i: string]: T | any; } + +var s1: Test1.IStringContainer; +>s1 : string | { [i: string]: string | any; } +>Test1 : any +>IStringContainer : string | { [i: string]: string | any; } + +var s2: Test2.IStringContainer; +>s2 : string | { [i: string]: string | any; } +>Test2 : any +>IStringContainer : string | { [i: string]: string | any; } + +s1 = s2; +>s1 = s2 : string | { [i: string]: string | any; } +>s1 : string | { [i: string]: string | any; } +>s2 : string | { [i: string]: string | any; } + +s2 = s1; +>s2 = s1 : string | { [i: string]: string | any; } +>s2 : string | { [i: string]: string | any; } +>s1 : string | { [i: string]: string | any; } + diff --git a/tests/baselines/reference/recursiveGenericUnionType2.js b/tests/baselines/reference/recursiveGenericUnionType2.js new file mode 100644 index 00000000000..bb7977d02cd --- /dev/null +++ b/tests/baselines/reference/recursiveGenericUnionType2.js @@ -0,0 +1,29 @@ +//// [recursiveGenericUnionType2.ts] +declare module Test1 { + export type Container = T | { + [i: string]: Container[]; + }; + export type IStringContainer = Container; +} + +declare module Test2 { + export type Container = T | { + [i: string]: Container[]; + }; + export type IStringContainer = Container; +} + +var x: Test1.Container; + +var s1: Test1.IStringContainer; +var s2: Test2.IStringContainer; +s1 = s2; +s2 = s1; + + +//// [recursiveGenericUnionType2.js] +var x; +var s1; +var s2; +s1 = s2; +s2 = s1; diff --git a/tests/baselines/reference/recursiveGenericUnionType2.symbols b/tests/baselines/reference/recursiveGenericUnionType2.symbols new file mode 100644 index 00000000000..bd189e68f3a --- /dev/null +++ b/tests/baselines/reference/recursiveGenericUnionType2.symbols @@ -0,0 +1,62 @@ +=== tests/cases/compiler/recursiveGenericUnionType2.ts === +declare module Test1 { +>Test1 : Symbol(Test1, Decl(recursiveGenericUnionType2.ts, 0, 0)) + + export type Container = T | { +>Container : Symbol(Container, Decl(recursiveGenericUnionType2.ts, 0, 22)) +>T : Symbol(T, Decl(recursiveGenericUnionType2.ts, 1, 26)) +>T : Symbol(T, Decl(recursiveGenericUnionType2.ts, 1, 26)) + + [i: string]: Container[]; +>i : Symbol(i, Decl(recursiveGenericUnionType2.ts, 2, 9)) +>Container : Symbol(Container, Decl(recursiveGenericUnionType2.ts, 0, 22)) +>T : Symbol(T, Decl(recursiveGenericUnionType2.ts, 1, 26)) + + }; + export type IStringContainer = Container; +>IStringContainer : Symbol(IStringContainer, Decl(recursiveGenericUnionType2.ts, 3, 6)) +>Container : Symbol(Container, Decl(recursiveGenericUnionType2.ts, 0, 22)) +} + +declare module Test2 { +>Test2 : Symbol(Test2, Decl(recursiveGenericUnionType2.ts, 5, 1)) + + export type Container = T | { +>Container : Symbol(Container, Decl(recursiveGenericUnionType2.ts, 7, 22)) +>T : Symbol(T, Decl(recursiveGenericUnionType2.ts, 8, 26)) +>T : Symbol(T, Decl(recursiveGenericUnionType2.ts, 8, 26)) + + [i: string]: Container[]; +>i : Symbol(i, Decl(recursiveGenericUnionType2.ts, 9, 9)) +>Container : Symbol(Container, Decl(recursiveGenericUnionType2.ts, 7, 22)) +>T : Symbol(T, Decl(recursiveGenericUnionType2.ts, 8, 26)) + + }; + export type IStringContainer = Container; +>IStringContainer : Symbol(IStringContainer, Decl(recursiveGenericUnionType2.ts, 10, 6)) +>Container : Symbol(Container, Decl(recursiveGenericUnionType2.ts, 7, 22)) +} + +var x: Test1.Container; +>x : Symbol(x, Decl(recursiveGenericUnionType2.ts, 14, 3)) +>Test1 : Symbol(Test1, Decl(recursiveGenericUnionType2.ts, 0, 0)) +>Container : Symbol(Test1.Container, Decl(recursiveGenericUnionType2.ts, 0, 22)) + +var s1: Test1.IStringContainer; +>s1 : Symbol(s1, Decl(recursiveGenericUnionType2.ts, 16, 3)) +>Test1 : Symbol(Test1, Decl(recursiveGenericUnionType2.ts, 0, 0)) +>IStringContainer : Symbol(Test1.IStringContainer, Decl(recursiveGenericUnionType2.ts, 3, 6)) + +var s2: Test2.IStringContainer; +>s2 : Symbol(s2, Decl(recursiveGenericUnionType2.ts, 17, 3)) +>Test2 : Symbol(Test2, Decl(recursiveGenericUnionType2.ts, 5, 1)) +>IStringContainer : Symbol(Test2.IStringContainer, Decl(recursiveGenericUnionType2.ts, 10, 6)) + +s1 = s2; +>s1 : Symbol(s1, Decl(recursiveGenericUnionType2.ts, 16, 3)) +>s2 : Symbol(s2, Decl(recursiveGenericUnionType2.ts, 17, 3)) + +s2 = s1; +>s2 : Symbol(s2, Decl(recursiveGenericUnionType2.ts, 17, 3)) +>s1 : Symbol(s1, Decl(recursiveGenericUnionType2.ts, 16, 3)) + diff --git a/tests/baselines/reference/recursiveGenericUnionType2.types b/tests/baselines/reference/recursiveGenericUnionType2.types new file mode 100644 index 00000000000..f98cf144780 --- /dev/null +++ b/tests/baselines/reference/recursiveGenericUnionType2.types @@ -0,0 +1,64 @@ +=== tests/cases/compiler/recursiveGenericUnionType2.ts === +declare module Test1 { +>Test1 : any + + export type Container = T | { +>Container : T | { [i: string]: (T | any)[]; } +>T : T +>T : T + + [i: string]: Container[]; +>i : string +>Container : T | { [i: string]: (T | any)[]; } +>T : T + + }; + export type IStringContainer = Container; +>IStringContainer : string | { [i: string]: (string | any)[]; } +>Container : T | { [i: string]: (T | any)[]; } +} + +declare module Test2 { +>Test2 : any + + export type Container = T | { +>Container : T | { [i: string]: (T | any)[]; } +>T : T +>T : T + + [i: string]: Container[]; +>i : string +>Container : T | { [i: string]: (T | any)[]; } +>T : T + + }; + export type IStringContainer = Container; +>IStringContainer : string | { [i: string]: (string | any)[]; } +>Container : T | { [i: string]: (T | any)[]; } +} + +var x: Test1.Container; +>x : number | { [i: string]: (number | any)[]; } +>Test1 : any +>Container : T | { [i: string]: (T | any)[]; } + +var s1: Test1.IStringContainer; +>s1 : string | { [i: string]: (string | any)[]; } +>Test1 : any +>IStringContainer : string | { [i: string]: (string | any)[]; } + +var s2: Test2.IStringContainer; +>s2 : string | { [i: string]: (string | any)[]; } +>Test2 : any +>IStringContainer : string | { [i: string]: (string | any)[]; } + +s1 = s2; +>s1 = s2 : string | { [i: string]: (string | any)[]; } +>s1 : string | { [i: string]: (string | any)[]; } +>s2 : string | { [i: string]: (string | any)[]; } + +s2 = s1; +>s2 = s1 : string | { [i: string]: (string | any)[]; } +>s2 : string | { [i: string]: (string | any)[]; } +>s1 : string | { [i: string]: (string | any)[]; } + diff --git a/tests/baselines/reference/recursiveProperties.types b/tests/baselines/reference/recursiveProperties.types index 2c3f90c6503..1e8a4ed3c1a 100644 --- a/tests/baselines/reference/recursiveProperties.types +++ b/tests/baselines/reference/recursiveProperties.types @@ -5,7 +5,7 @@ class A { get testProp() { return this.testProp; } >testProp : any >this.testProp : any ->this : A +>this : this >testProp : any } @@ -17,7 +17,7 @@ class B { >value : string >this.testProp = value : string >this.testProp : string ->this : B +>this : this >testProp : string >value : string } diff --git a/tests/baselines/reference/regExpWithSlashInCharClass.symbols b/tests/baselines/reference/regExpWithSlashInCharClass.symbols index 68a257a9666..105724b12f1 100644 --- a/tests/baselines/reference/regExpWithSlashInCharClass.symbols +++ b/tests/baselines/reference/regExpWithSlashInCharClass.symbols @@ -1,16 +1,16 @@ === tests/cases/compiler/regExpWithSlashInCharClass.ts === var foo1 = "a/".replace(/.[/]/, ""); >foo1 : Symbol(foo1, Decl(regExpWithSlashInCharClass.ts, 0, 3)) ->"a/".replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63)) ->replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63)) +>"a/".replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var foo2 = "a//".replace(/.[//]/g, ""); >foo2 : Symbol(foo2, Decl(regExpWithSlashInCharClass.ts, 1, 3)) ->"a//".replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63)) ->replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63)) +>"a//".replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var foo3 = "a/".replace(/.[/no sleep /till/]/, "bugfix"); >foo3 : Symbol(foo3, Decl(regExpWithSlashInCharClass.ts, 2, 3)) ->"a/".replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63)) ->replace : Symbol(String.replace, Decl(lib.d.ts, 329, 44), Decl(lib.d.ts, 336, 63), Decl(lib.d.ts, 343, 98), Decl(lib.d.ts, 350, 63)) +>"a/".replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>replace : Symbol(String.replace, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/resolvingClassDeclarationWhenInBaseTypeResolution.types b/tests/baselines/reference/resolvingClassDeclarationWhenInBaseTypeResolution.types index c9025b56502..3b0a3c001b4 100644 --- a/tests/baselines/reference/resolvingClassDeclarationWhenInBaseTypeResolution.types +++ b/tests/baselines/reference/resolvingClassDeclarationWhenInBaseTypeResolution.types @@ -18,8 +18,8 @@ module rionegrensis { >x : caniventer >caniventer : caniventer >() => { var y = this; } : () => void ->y : caniventer ->this : caniventer +>y : this +>this : this >x : caniventer uchidai() : lavali.xanthognathus { var x : lavali.xanthognathus; () => { var y = this; }; return x; } @@ -30,8 +30,8 @@ module rionegrensis { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : caniventer ->this : caniventer +>y : this +>this : this >x : lavali.xanthognathus raffrayana() : lavali.otion { var x : lavali.otion; () => { var y = this; }; return x; } @@ -42,8 +42,8 @@ module rionegrensis { >lavali : any >otion : lavali.otion >() => { var y = this; } : () => void ->y : caniventer ->this : caniventer +>y : this +>this : this >x : lavali.otion Uranium() : minutus.inez, trivirgatus.falconeri> { var x : minutus.inez, trivirgatus.falconeri>; () => { var y = this; }; return x; } @@ -70,8 +70,8 @@ module rionegrensis { >trivirgatus : any >falconeri : trivirgatus.falconeri >() => { var y = this; } : () => void ->y : caniventer ->this : caniventer +>y : this +>this : this >x : minutus.inez, trivirgatus.falconeri> nayaur() : gabriellae.amicus { var x : gabriellae.amicus; () => { var y = this; }; return x; } @@ -82,8 +82,8 @@ module rionegrensis { >gabriellae : any >amicus : gabriellae.amicus >() => { var y = this; } : () => void ->y : caniventer ->this : caniventer +>y : this +>this : this >x : gabriellae.amicus } export class veraecrucis extends trivirgatus.mixtus { @@ -122,8 +122,8 @@ module rionegrensis { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : veraecrucis ->this : veraecrucis +>y : this +>this : this >x : panamensis.setulosus> vancouverensis() : imperfecta.ciliolabrum { var x : imperfecta.ciliolabrum; () => { var y = this; }; return x; } @@ -142,8 +142,8 @@ module rionegrensis { >argurus : any >peninsulae : argurus.peninsulae >() => { var y = this; } : () => void ->y : veraecrucis ->this : veraecrucis +>y : this +>this : this >x : imperfecta.ciliolabrum africana() : argurus.gilbertii, sagitta.cinereus> { var x : argurus.gilbertii, sagitta.cinereus>; () => { var y = this; }; return x; } @@ -178,8 +178,8 @@ module rionegrensis { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : veraecrucis ->this : veraecrucis +>y : this +>this : this >x : argurus.gilbertii, sagitta.cinereus> palliolata() : Lanthanum.jugularis { var x : Lanthanum.jugularis; () => { var y = this; }; return x; } @@ -190,8 +190,8 @@ module rionegrensis { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : veraecrucis ->this : veraecrucis +>y : this +>this : this >x : Lanthanum.jugularis nivicola() : samarensis.pallidus { var x : samarensis.pallidus; () => { var y = this; }; return x; } @@ -202,8 +202,8 @@ module rionegrensis { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : veraecrucis ->this : veraecrucis +>y : this +>this : this >x : samarensis.pallidus } } @@ -224,8 +224,8 @@ module julianae { >argurus : any >germaini : argurus.germaini >() => { var y = this; } : () => void ->y : nudicaudus ->this : nudicaudus +>y : this +>this : this >x : argurus.germaini maxwellii() : ruatanica.Praseodymium { var x : ruatanica.Praseodymium; () => { var y = this; }; return x; } @@ -244,8 +244,8 @@ module julianae { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : nudicaudus ->this : nudicaudus +>y : this +>this : this >x : ruatanica.Praseodymium endoi() : panglima.abidi { var x : panglima.abidi; () => { var y = this; }; return x; } @@ -264,8 +264,8 @@ module julianae { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : nudicaudus ->this : nudicaudus +>y : this +>this : this >x : panglima.abidi venezuelae() : howi.marcanoi { var x : howi.marcanoi; () => { var y = this; }; return x; } @@ -276,8 +276,8 @@ module julianae { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : nudicaudus ->this : nudicaudus +>y : this +>this : this >x : howi.marcanoi zamicrus() : rionegrensis.caniventer { var x : rionegrensis.caniventer; () => { var y = this; }; return x; } @@ -288,8 +288,8 @@ module julianae { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : nudicaudus ->this : nudicaudus +>y : this +>this : this >x : rionegrensis.caniventer } export class galapagoensis { @@ -311,8 +311,8 @@ module julianae { >patas : any >uralensis : patas.uralensis >() => { var y = this; } : () => void ->y : galapagoensis ->this : galapagoensis +>y : this +>this : this >x : panglima.amphibius rueppellii() : ruatanica.americanus { var x : ruatanica.americanus; () => { var y = this; }; return x; } @@ -323,8 +323,8 @@ module julianae { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : galapagoensis ->this : galapagoensis +>y : this +>this : this >x : ruatanica.americanus peregusna() : dogramacii.kaiseri { var x : dogramacii.kaiseri; () => { var y = this; }; return x; } @@ -335,8 +335,8 @@ module julianae { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : galapagoensis ->this : galapagoensis +>y : this +>this : this >x : dogramacii.kaiseri gliroides() : howi.coludo { var x : howi.coludo; () => { var y = this; }; return x; } @@ -355,8 +355,8 @@ module julianae { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : galapagoensis ->this : galapagoensis +>y : this +>this : this >x : howi.coludo banakrisi() : macrorhinos.daphaenodon { var x : macrorhinos.daphaenodon; () => { var y = this; }; return x; } @@ -367,8 +367,8 @@ module julianae { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : galapagoensis ->this : galapagoensis +>y : this +>this : this >x : macrorhinos.daphaenodon rozendaali() : lutreolus.foina { var x : lutreolus.foina; () => { var y = this; }; return x; } @@ -379,8 +379,8 @@ module julianae { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : galapagoensis ->this : galapagoensis +>y : this +>this : this >x : lutreolus.foina stuhlmanni() : panamensis.linulus { var x : panamensis.linulus; () => { var y = this; }; return x; } @@ -399,8 +399,8 @@ module julianae { >caurinus : any >megaphyllus : caurinus.megaphyllus >() => { var y = this; } : () => void ->y : galapagoensis ->this : galapagoensis +>y : this +>this : this >x : panamensis.linulus } export class albidens { @@ -432,8 +432,8 @@ module julianae { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : albidens ->this : albidens +>y : this +>this : this >x : samarensis.fuscus> Astatine() : steerii { var x : steerii; () => { var y = this; }; return x; } @@ -442,8 +442,8 @@ module julianae { >x : steerii >steerii : steerii >() => { var y = this; } : () => void ->y : albidens ->this : albidens +>y : this +>this : this >x : steerii vincenti() : argurus.dauricus { var x : argurus.dauricus; () => { var y = this; }; return x; } @@ -462,8 +462,8 @@ module julianae { >patas : any >uralensis : patas.uralensis >() => { var y = this; } : () => void ->y : albidens ->this : albidens +>y : this +>this : this >x : argurus.dauricus hirta() : Lanthanum.jugularis { var x : Lanthanum.jugularis; () => { var y = this; }; return x; } @@ -474,8 +474,8 @@ module julianae { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : albidens ->this : albidens +>y : this +>this : this >x : Lanthanum.jugularis virginianus() : durangae { var x : durangae; () => { var y = this; }; return x; } @@ -484,8 +484,8 @@ module julianae { >x : durangae >durangae : durangae >() => { var y = this; } : () => void ->y : albidens ->this : albidens +>y : this +>this : this >x : durangae macrophyllum() : howi.marcanoi { var x : howi.marcanoi; () => { var y = this; }; return x; } @@ -496,8 +496,8 @@ module julianae { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : albidens ->this : albidens +>y : this +>this : this >x : howi.marcanoi porcellus() : ruatanica.americanus { var x : ruatanica.americanus; () => { var y = this; }; return x; } @@ -508,8 +508,8 @@ module julianae { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : albidens ->this : albidens +>y : this +>this : this >x : ruatanica.americanus } export class oralis extends caurinus.psilurus { @@ -528,8 +528,8 @@ module julianae { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : caurinus.psilurus porteri() : lavali.thaeleri { var x : lavali.thaeleri; () => { var y = this; }; return x; } @@ -540,8 +540,8 @@ module julianae { >lavali : any >thaeleri : lavali.thaeleri >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : lavali.thaeleri bindi() : caurinus.mahaganus> { var x : caurinus.mahaganus>; () => { var y = this; }; return x; } @@ -568,8 +568,8 @@ module julianae { >patas : any >uralensis : patas.uralensis >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : caurinus.mahaganus> puda() : sagitta.stolzmanni { var x : sagitta.stolzmanni; () => { var y = this; }; return x; } @@ -580,8 +580,8 @@ module julianae { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : sagitta.stolzmanni mindorensis() : trivirgatus.falconeri { var x : trivirgatus.falconeri; () => { var y = this; }; return x; } @@ -592,8 +592,8 @@ module julianae { >trivirgatus : any >falconeri : trivirgatus.falconeri >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : trivirgatus.falconeri ignitus() : petrophilus.rosalia, lavali.wilsoni> { var x : petrophilus.rosalia, lavali.wilsoni>; () => { var y = this; }; return x; } @@ -618,8 +618,8 @@ module julianae { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : petrophilus.rosalia, lavali.wilsoni> rufus() : nudicaudus { var x : nudicaudus; () => { var y = this; }; return x; } @@ -628,8 +628,8 @@ module julianae { >x : nudicaudus >nudicaudus : nudicaudus >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : nudicaudus monax() : imperfecta.subspinosus { var x : imperfecta.subspinosus; () => { var y = this; }; return x; } @@ -640,8 +640,8 @@ module julianae { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : imperfecta.subspinosus unalascensis() : minutus.inez, gabriellae.echinatus>, dogramacii.aurata> { var x : minutus.inez, gabriellae.echinatus>, dogramacii.aurata>; () => { var y = this; }; return x; } @@ -676,8 +676,8 @@ module julianae { >dogramacii : any >aurata : dogramacii.aurata >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : minutus.inez, gabriellae.echinatus>, dogramacii.aurata> wuchihensis() : howi.angulatus, petrophilus.minutilla> { var x : howi.angulatus, petrophilus.minutilla>; () => { var y = this; }; return x; } @@ -704,8 +704,8 @@ module julianae { >petrophilus : any >minutilla : petrophilus.minutilla >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : howi.angulatus, petrophilus.minutilla> leucippe() : lavali.otion { var x : lavali.otion; () => { var y = this; }; return x; } @@ -716,8 +716,8 @@ module julianae { >lavali : any >otion : lavali.otion >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : lavali.otion ordii() : daubentonii.arboreus { var x : daubentonii.arboreus; () => { var y = this; }; return x; } @@ -736,8 +736,8 @@ module julianae { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : daubentonii.arboreus eisentrauti() : rendalli.zuluensis { var x : rendalli.zuluensis; () => { var y = this; }; return x; } @@ -748,8 +748,8 @@ module julianae { >rendalli : any >zuluensis : rendalli.zuluensis >() => { var y = this; } : () => void ->y : oralis ->this : oralis +>y : this +>this : this >x : rendalli.zuluensis } export class sumatrana extends Lanthanum.jugularis { @@ -774,8 +774,8 @@ module julianae { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : sumatrana ->this : sumatrana +>y : this +>this : this >x : Lanthanum.suillus geata() : ruatanica.hector { var x : ruatanica.hector; () => { var y = this; }; return x; } @@ -792,8 +792,8 @@ module julianae { >quasiater : any >bobrinskoi : quasiater.bobrinskoi >() => { var y = this; } : () => void ->y : sumatrana ->this : sumatrana +>y : this +>this : this >x : ruatanica.hector awashensis() : petrophilus.minutilla { var x : petrophilus.minutilla; () => { var y = this; }; return x; } @@ -804,8 +804,8 @@ module julianae { >petrophilus : any >minutilla : petrophilus.minutilla >() => { var y = this; } : () => void ->y : sumatrana ->this : sumatrana +>y : this +>this : this >x : petrophilus.minutilla sturdeei() : lutreolus.cor { var x : lutreolus.cor; () => { var y = this; }; return x; } @@ -822,8 +822,8 @@ module julianae { >jugularis : Lanthanum.jugularis >galapagoensis : galapagoensis >() => { var y = this; } : () => void ->y : sumatrana ->this : sumatrana +>y : this +>this : this >x : lutreolus.cor pachyurus() : howi.angulatus> { var x : howi.angulatus>; () => { var y = this; }; return x; } @@ -848,8 +848,8 @@ module julianae { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : sumatrana ->this : sumatrana +>y : this +>this : this >x : howi.angulatus> lyelli() : provocax.melanoleuca { var x : provocax.melanoleuca; () => { var y = this; }; return x; } @@ -860,8 +860,8 @@ module julianae { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : sumatrana ->this : sumatrana +>y : this +>this : this >x : provocax.melanoleuca neohibernicus() : dammermani.siberu { var x : dammermani.siberu; () => { var y = this; }; return x; } @@ -880,8 +880,8 @@ module julianae { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : sumatrana ->this : sumatrana +>y : this +>this : this >x : dammermani.siberu } export class gerbillus { @@ -905,8 +905,8 @@ module julianae { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : gerbillus ->this : gerbillus +>y : this +>this : this >x : sagitta.sicarius tristrami() : petrophilus.minutilla { var x : petrophilus.minutilla; () => { var y = this; }; return x; } @@ -917,8 +917,8 @@ module julianae { >petrophilus : any >minutilla : petrophilus.minutilla >() => { var y = this; } : () => void ->y : gerbillus ->this : gerbillus +>y : this +>this : this >x : petrophilus.minutilla swarthi() : lutreolus.foina { var x : lutreolus.foina; () => { var y = this; }; return x; } @@ -929,8 +929,8 @@ module julianae { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : gerbillus ->this : gerbillus +>y : this +>this : this >x : lutreolus.foina horsfieldii() : trivirgatus.falconeri { var x : trivirgatus.falconeri; () => { var y = this; }; return x; } @@ -941,8 +941,8 @@ module julianae { >trivirgatus : any >falconeri : trivirgatus.falconeri >() => { var y = this; } : () => void ->y : gerbillus ->this : gerbillus +>y : this +>this : this >x : trivirgatus.falconeri diazi() : imperfecta.lasiurus { var x : imperfecta.lasiurus; () => { var y = this; }; return x; } @@ -961,8 +961,8 @@ module julianae { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : gerbillus ->this : gerbillus +>y : this +>this : this >x : imperfecta.lasiurus rennelli() : argurus.luctuosa { var x : argurus.luctuosa; () => { var y = this; }; return x; } @@ -973,8 +973,8 @@ module julianae { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : gerbillus ->this : gerbillus +>y : this +>this : this >x : argurus.luctuosa maulinus() : lavali.lepturus { var x : lavali.lepturus; () => { var y = this; }; return x; } @@ -985,8 +985,8 @@ module julianae { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : gerbillus ->this : gerbillus +>y : this +>this : this >x : lavali.lepturus muscina() : daubentonii.arboreus { var x : daubentonii.arboreus; () => { var y = this; }; return x; } @@ -1005,8 +1005,8 @@ module julianae { >argurus : any >peninsulae : argurus.peninsulae >() => { var y = this; } : () => void ->y : gerbillus ->this : gerbillus +>y : this +>this : this >x : daubentonii.arboreus pelengensis() : sagitta.leptoceros { var x : sagitta.leptoceros; () => { var y = this; }; return x; } @@ -1025,8 +1025,8 @@ module julianae { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : gerbillus ->this : gerbillus +>y : this +>this : this >x : sagitta.leptoceros abramus() : lavali.thaeleri { var x : lavali.thaeleri; () => { var y = this; }; return x; } @@ -1037,8 +1037,8 @@ module julianae { >lavali : any >thaeleri : lavali.thaeleri >() => { var y = this; } : () => void ->y : gerbillus ->this : gerbillus +>y : this +>this : this >x : lavali.thaeleri reevesi() : provocax.melanoleuca { var x : provocax.melanoleuca; () => { var y = this; }; return x; } @@ -1049,8 +1049,8 @@ module julianae { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : gerbillus ->this : gerbillus +>y : this +>this : this >x : provocax.melanoleuca } export class acariensis { @@ -1064,8 +1064,8 @@ module julianae { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : acariensis ->this : acariensis +>y : this +>this : this >x : lavali.lepturus minous() : argurus.dauricus { var x : argurus.dauricus; () => { var y = this; }; return x; } @@ -1084,8 +1084,8 @@ module julianae { >lavali : any >otion : lavali.otion >() => { var y = this; } : () => void ->y : acariensis ->this : acariensis +>y : this +>this : this >x : argurus.dauricus cinereiventer() : panamensis.setulosus { var x : panamensis.setulosus; () => { var y = this; }; return x; } @@ -1104,8 +1104,8 @@ module julianae { >lavali : any >otion : lavali.otion >() => { var y = this; } : () => void ->y : acariensis ->this : acariensis +>y : this +>this : this >x : panamensis.setulosus longicaudatus() : macrorhinos.marmosurus> { var x : macrorhinos.marmosurus>; () => { var y = this; }; return x; } @@ -1130,8 +1130,8 @@ module julianae { >lavali : any >otion : lavali.otion >() => { var y = this; } : () => void ->y : acariensis ->this : acariensis +>y : this +>this : this >x : macrorhinos.marmosurus> baeodon() : argurus.netscheri, argurus.luctuosa> { var x : argurus.netscheri, argurus.luctuosa>; () => { var y = this; }; return x; } @@ -1158,8 +1158,8 @@ module julianae { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : acariensis ->this : acariensis +>y : this +>this : this >x : argurus.netscheri, argurus.luctuosa> soricoides() : argurus.luctuosa { var x : argurus.luctuosa; () => { var y = this; }; return x; } @@ -1170,8 +1170,8 @@ module julianae { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : acariensis ->this : acariensis +>y : this +>this : this >x : argurus.luctuosa datae() : daubentonii.arboreus> { var x : daubentonii.arboreus>; () => { var y = this; }; return x; } @@ -1198,8 +1198,8 @@ module julianae { >patas : any >uralensis : patas.uralensis >() => { var y = this; } : () => void ->y : acariensis ->this : acariensis +>y : this +>this : this >x : daubentonii.arboreus> spixii() : imperfecta.subspinosus { var x : imperfecta.subspinosus; () => { var y = this; }; return x; } @@ -1210,8 +1210,8 @@ module julianae { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : acariensis ->this : acariensis +>y : this +>this : this >x : imperfecta.subspinosus anakuma() : lavali.wilsoni { var x : lavali.wilsoni; () => { var y = this; }; return x; } @@ -1222,8 +1222,8 @@ module julianae { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : acariensis ->this : acariensis +>y : this +>this : this >x : lavali.wilsoni kihaulei() : panglima.amphibius { var x : panglima.amphibius; () => { var y = this; }; return x; } @@ -1242,8 +1242,8 @@ module julianae { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : acariensis ->this : acariensis +>y : this +>this : this >x : panglima.amphibius gymnura() : quasiater.carolinensis { var x : quasiater.carolinensis; () => { var y = this; }; return x; } @@ -1254,8 +1254,8 @@ module julianae { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : acariensis ->this : acariensis +>y : this +>this : this >x : quasiater.carolinensis olchonensis() : rendalli.crenulata { var x : rendalli.crenulata; () => { var y = this; }; return x; } @@ -1274,8 +1274,8 @@ module julianae { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : acariensis ->this : acariensis +>y : this +>this : this >x : rendalli.crenulata } export class durangae extends dogramacii.aurata { @@ -1300,8 +1300,8 @@ module julianae { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : durangae ->this : durangae +>y : this +>this : this >x : panamensis.setulosus Flerovium() : howi.angulatus { var x : howi.angulatus; () => { var y = this; }; return x; } @@ -1320,8 +1320,8 @@ module julianae { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : durangae ->this : durangae +>y : this +>this : this >x : howi.angulatus phrudus() : sagitta.stolzmanni { var x : sagitta.stolzmanni; () => { var y = this; }; return x; } @@ -1332,8 +1332,8 @@ module julianae { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : durangae ->this : durangae +>y : this +>this : this >x : sagitta.stolzmanni } } @@ -1353,8 +1353,8 @@ module ruatanica { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : hector ->this : hector +>y : this +>this : this >x : julianae.steerii eurycerus() : panamensis.linulus, lavali.wilsoni> { var x : panamensis.linulus, lavali.wilsoni>; () => { var y = this; }; return x; } @@ -1381,8 +1381,8 @@ module ruatanica { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : hector ->this : hector +>y : this +>this : this >x : panamensis.linulus, lavali.wilsoni> } } @@ -1402,8 +1402,8 @@ module Lanthanum { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : suillus ->this : suillus +>y : this +>this : this >x : quasiater.carolinensis tumbalensis() : caurinus.megaphyllus { var x : caurinus.megaphyllus; () => { var y = this; }; return x; } @@ -1414,8 +1414,8 @@ module Lanthanum { >caurinus : any >megaphyllus : caurinus.megaphyllus >() => { var y = this; } : () => void ->y : suillus ->this : suillus +>y : this +>this : this >x : caurinus.megaphyllus anatolicus() : julianae.steerii { var x : julianae.steerii; () => { var y = this; }; return x; } @@ -1426,8 +1426,8 @@ module Lanthanum { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : suillus ->this : suillus +>y : this +>this : this >x : julianae.steerii } export class nitidus extends argurus.gilbertii { @@ -1450,8 +1450,8 @@ module Lanthanum { >quasiater : any >bobrinskoi : quasiater.bobrinskoi >() => { var y = this; } : () => void ->y : nitidus ->this : nitidus +>y : this +>this : this >x : quasiater.bobrinskoi negligens() : minutus.inez { var x : minutus.inez; () => { var y = this; }; return x; } @@ -1470,8 +1470,8 @@ module Lanthanum { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : nitidus ->this : nitidus +>y : this +>this : this >x : minutus.inez lewisi() : julianae.oralis { var x : julianae.oralis; () => { var y = this; }; return x; } @@ -1490,8 +1490,8 @@ module Lanthanum { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : nitidus ->this : nitidus +>y : this +>this : this >x : julianae.oralis arge() : chrysaeolus.sarasinorum { var x : chrysaeolus.sarasinorum; () => { var y = this; }; return x; } @@ -1510,8 +1510,8 @@ module Lanthanum { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : nitidus ->this : nitidus +>y : this +>this : this >x : chrysaeolus.sarasinorum dominicensis() : dammermani.melanops { var x : dammermani.melanops; () => { var y = this; }; return x; } @@ -1522,8 +1522,8 @@ module Lanthanum { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : nitidus ->this : nitidus +>y : this +>this : this >x : dammermani.melanops taurus() : macrorhinos.konganensis { var x : macrorhinos.konganensis; () => { var y = this; }; return x; } @@ -1534,8 +1534,8 @@ module Lanthanum { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : nitidus ->this : nitidus +>y : this +>this : this >x : macrorhinos.konganensis tonganus() : argurus.netscheri { var x : argurus.netscheri; () => { var y = this; }; return x; } @@ -1554,8 +1554,8 @@ module Lanthanum { >dogramacii : any >aurata : dogramacii.aurata >() => { var y = this; } : () => void ->y : nitidus ->this : nitidus +>y : this +>this : this >x : argurus.netscheri silvatica() : rendalli.moojeni { var x : rendalli.moojeni; () => { var y = this; }; return x; } @@ -1574,8 +1574,8 @@ module Lanthanum { >lavali : any >otion : lavali.otion >() => { var y = this; } : () => void ->y : nitidus ->this : nitidus +>y : this +>this : this >x : rendalli.moojeni midas() : lavali.xanthognathus { var x : lavali.xanthognathus; () => { var y = this; }; return x; } @@ -1586,8 +1586,8 @@ module Lanthanum { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : nitidus ->this : nitidus +>y : this +>this : this >x : lavali.xanthognathus bicornis() : dogramacii.kaiseri { var x : dogramacii.kaiseri; () => { var y = this; }; return x; } @@ -1598,8 +1598,8 @@ module Lanthanum { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : nitidus ->this : nitidus +>y : this +>this : this >x : dogramacii.kaiseri } export class megalonyx extends caurinus.johorensis { @@ -1620,8 +1620,8 @@ module Lanthanum { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : megalonyx ->this : megalonyx +>y : this +>this : this >x : macrorhinos.konganensis melanogaster() : rionegrensis.veraecrucis { var x : rionegrensis.veraecrucis; () => { var y = this; }; return x; } @@ -1640,8 +1640,8 @@ module Lanthanum { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : megalonyx ->this : megalonyx +>y : this +>this : this >x : rionegrensis.veraecrucis elaphus() : nitidus { var x : nitidus; () => { var y = this; }; return x; } @@ -1658,8 +1658,8 @@ module Lanthanum { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : megalonyx ->this : megalonyx +>y : this +>this : this >x : nitidus elater() : lavali.lepturus { var x : lavali.lepturus; () => { var y = this; }; return x; } @@ -1670,8 +1670,8 @@ module Lanthanum { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : megalonyx ->this : megalonyx +>y : this +>this : this >x : lavali.lepturus ourebi() : provocax.melanoleuca { var x : provocax.melanoleuca; () => { var y = this; }; return x; } @@ -1682,8 +1682,8 @@ module Lanthanum { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : megalonyx ->this : megalonyx +>y : this +>this : this >x : provocax.melanoleuca caraccioli() : imperfecta.ciliolabrum> { var x : imperfecta.ciliolabrum>; () => { var y = this; }; return x; } @@ -1710,8 +1710,8 @@ module Lanthanum { >julianae : any >acariensis : julianae.acariensis >() => { var y = this; } : () => void ->y : megalonyx ->this : megalonyx +>y : this +>this : this >x : imperfecta.ciliolabrum> parva() : gabriellae.echinatus { var x : gabriellae.echinatus; () => { var y = this; }; return x; } @@ -1722,8 +1722,8 @@ module Lanthanum { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : megalonyx ->this : megalonyx +>y : this +>this : this >x : gabriellae.echinatus albipes() : quasiater.wattsi { var x : quasiater.wattsi; () => { var y = this; }; return x; } @@ -1740,8 +1740,8 @@ module Lanthanum { >melanops : dammermani.melanops >megalonyx : megalonyx >() => { var y = this; } : () => void ->y : megalonyx ->this : megalonyx +>y : this +>this : this >x : quasiater.wattsi } export class jugularis { @@ -1763,8 +1763,8 @@ module Lanthanum { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : petrophilus.sodyi revoili() : lavali.wilsoni { var x : lavali.wilsoni; () => { var y = this; }; return x; } @@ -1775,8 +1775,8 @@ module Lanthanum { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : lavali.wilsoni macrobullatus() : macrorhinos.daphaenodon { var x : macrorhinos.daphaenodon; () => { var y = this; }; return x; } @@ -1787,8 +1787,8 @@ module Lanthanum { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : macrorhinos.daphaenodon compactus() : sagitta.stolzmanni { var x : sagitta.stolzmanni; () => { var y = this; }; return x; } @@ -1799,8 +1799,8 @@ module Lanthanum { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : sagitta.stolzmanni talpinus() : nitidus { var x : nitidus; () => { var y = this; }; return x; } @@ -1817,8 +1817,8 @@ module Lanthanum { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : nitidus stramineus() : gabriellae.amicus { var x : gabriellae.amicus; () => { var y = this; }; return x; } @@ -1829,8 +1829,8 @@ module Lanthanum { >gabriellae : any >amicus : gabriellae.amicus >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : gabriellae.amicus dartmouthi() : trivirgatus.mixtus { var x : trivirgatus.mixtus; () => { var y = this; }; return x; } @@ -1849,8 +1849,8 @@ module Lanthanum { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : trivirgatus.mixtus ogilbyi() : argurus.dauricus { var x : argurus.dauricus; () => { var y = this; }; return x; } @@ -1869,8 +1869,8 @@ module Lanthanum { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : argurus.dauricus incomtus() : daubentonii.nesiotes { var x : daubentonii.nesiotes; () => { var y = this; }; return x; } @@ -1889,8 +1889,8 @@ module Lanthanum { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : daubentonii.nesiotes surdaster() : ruatanica.Praseodymium { var x : ruatanica.Praseodymium; () => { var y = this; }; return x; } @@ -1909,8 +1909,8 @@ module Lanthanum { >caurinus : any >megaphyllus : caurinus.megaphyllus >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : ruatanica.Praseodymium melanorhinus() : samarensis.pelurus { var x : samarensis.pelurus; () => { var y = this; }; return x; } @@ -1929,8 +1929,8 @@ module Lanthanum { >rendalli : any >zuluensis : rendalli.zuluensis >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : samarensis.pelurus picticaudata() : minutus.inez, dogramacii.kaiseri> { var x : minutus.inez, dogramacii.kaiseri>; () => { var y = this; }; return x; } @@ -1957,8 +1957,8 @@ module Lanthanum { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : minutus.inez, dogramacii.kaiseri> pomona() : julianae.steerii { var x : julianae.steerii; () => { var y = this; }; return x; } @@ -1969,8 +1969,8 @@ module Lanthanum { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : julianae.steerii ileile() : quasiater.carolinensis { var x : quasiater.carolinensis; () => { var y = this; }; return x; } @@ -1981,8 +1981,8 @@ module Lanthanum { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : jugularis ->this : jugularis +>y : this +>this : this >x : quasiater.carolinensis } } @@ -2011,8 +2011,8 @@ module rendalli { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : argurus.wetmorei keyensis() : quasiater.wattsi { var x : quasiater.wattsi; () => { var y = this; }; return x; } @@ -2031,8 +2031,8 @@ module rendalli { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : quasiater.wattsi occasius() : argurus.gilbertii { var x : argurus.gilbertii; () => { var y = this; }; return x; } @@ -2051,8 +2051,8 @@ module rendalli { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : argurus.gilbertii damarensis() : julianae.galapagoensis { var x : julianae.galapagoensis; () => { var y = this; }; return x; } @@ -2063,8 +2063,8 @@ module rendalli { >julianae : any >galapagoensis : julianae.galapagoensis >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : julianae.galapagoensis Neptunium() : panglima.abidi { var x : panglima.abidi; () => { var y = this; }; return x; } @@ -2083,8 +2083,8 @@ module rendalli { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : panglima.abidi griseoflavus() : ruatanica.americanus { var x : ruatanica.americanus; () => { var y = this; }; return x; } @@ -2095,8 +2095,8 @@ module rendalli { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : ruatanica.americanus thar() : argurus.oreas { var x : argurus.oreas; () => { var y = this; }; return x; } @@ -2107,8 +2107,8 @@ module rendalli { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : argurus.oreas alborufus() : panamensis.linulus { var x : panamensis.linulus; () => { var y = this; }; return x; } @@ -2127,8 +2127,8 @@ module rendalli { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : panamensis.linulus fusicaudus() : sagitta.stolzmanni { var x : sagitta.stolzmanni; () => { var y = this; }; return x; } @@ -2139,8 +2139,8 @@ module rendalli { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : sagitta.stolzmanni gordonorum() : howi.angulatus { var x : howi.angulatus; () => { var y = this; }; return x; } @@ -2159,8 +2159,8 @@ module rendalli { >argurus : any >germaini : argurus.germaini >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : howi.angulatus ruber() : dammermani.siberu { var x : dammermani.siberu; () => { var y = this; }; return x; } @@ -2179,8 +2179,8 @@ module rendalli { >julianae : any >acariensis : julianae.acariensis >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : dammermani.siberu desmarestianus() : julianae.steerii { var x : julianae.steerii; () => { var y = this; }; return x; } @@ -2191,8 +2191,8 @@ module rendalli { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : julianae.steerii lutillus() : nigra.dolichurus { var x : nigra.dolichurus; () => { var y = this; }; return x; } @@ -2211,8 +2211,8 @@ module rendalli { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : nigra.dolichurus salocco() : argurus.peninsulae { var x : argurus.peninsulae; () => { var y = this; }; return x; } @@ -2223,8 +2223,8 @@ module rendalli { >argurus : any >peninsulae : argurus.peninsulae >() => { var y = this; } : () => void ->y : zuluensis ->this : zuluensis +>y : this +>this : this >x : argurus.peninsulae } export class moojeni { @@ -2240,8 +2240,8 @@ module rendalli { >lavali : any >otion : lavali.otion >() => { var y = this; } : () => void ->y : moojeni ->this : moojeni +>y : this +>this : this >x : lavali.otion montosa() : imperfecta.ciliolabrum { var x : imperfecta.ciliolabrum; () => { var y = this; }; return x; } @@ -2260,8 +2260,8 @@ module rendalli { >petrophilus : any >minutilla : petrophilus.minutilla >() => { var y = this; } : () => void ->y : moojeni ->this : moojeni +>y : this +>this : this >x : imperfecta.ciliolabrum miletus() : julianae.sumatrana { var x : julianae.sumatrana; () => { var y = this; }; return x; } @@ -2272,8 +2272,8 @@ module rendalli { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : moojeni ->this : moojeni +>y : this +>this : this >x : julianae.sumatrana heaneyi() : zuluensis { var x : zuluensis; () => { var y = this; }; return x; } @@ -2282,8 +2282,8 @@ module rendalli { >x : zuluensis >zuluensis : zuluensis >() => { var y = this; } : () => void ->y : moojeni ->this : moojeni +>y : this +>this : this >x : zuluensis marchei() : panglima.amphibius> { var x : panglima.amphibius>; () => { var y = this; }; return x; } @@ -2310,8 +2310,8 @@ module rendalli { >dogramacii : any >aurata : dogramacii.aurata >() => { var y = this; } : () => void ->y : moojeni ->this : moojeni +>y : this +>this : this >x : panglima.amphibius> budini() : julianae.durangae { var x : julianae.durangae; () => { var y = this; }; return x; } @@ -2322,8 +2322,8 @@ module rendalli { >julianae : any >durangae : julianae.durangae >() => { var y = this; } : () => void ->y : moojeni ->this : moojeni +>y : this +>this : this >x : julianae.durangae maggietaylorae() : trivirgatus.mixtus, imperfecta.subspinosus>, sagitta.stolzmanni> { var x : trivirgatus.mixtus, imperfecta.subspinosus>, sagitta.stolzmanni>; () => { var y = this; }; return x; } @@ -2358,8 +2358,8 @@ module rendalli { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : moojeni ->this : moojeni +>y : this +>this : this >x : trivirgatus.mixtus, imperfecta.subspinosus>, sagitta.stolzmanni> poliocephalus() : julianae.gerbillus { var x : julianae.gerbillus; () => { var y = this; }; return x; } @@ -2378,8 +2378,8 @@ module rendalli { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : moojeni ->this : moojeni +>y : this +>this : this >x : julianae.gerbillus zibethicus() : minutus.inez { var x : minutus.inez; () => { var y = this; }; return x; } @@ -2398,8 +2398,8 @@ module rendalli { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : moojeni ->this : moojeni +>y : this +>this : this >x : minutus.inez biacensis() : howi.coludo { var x : howi.coludo; () => { var y = this; }; return x; } @@ -2418,8 +2418,8 @@ module rendalli { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : moojeni ->this : moojeni +>y : this +>this : this >x : howi.coludo } export class crenulata extends trivirgatus.falconeri { @@ -2446,8 +2446,8 @@ module rendalli { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : crenulata ->this : crenulata +>y : this +>this : this >x : howi.coludo maritimus() : ruatanica.americanus { var x : ruatanica.americanus; () => { var y = this; }; return x; } @@ -2458,8 +2458,8 @@ module rendalli { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : crenulata ->this : crenulata +>y : this +>this : this >x : ruatanica.americanus edax() : lutreolus.cor>, rionegrensis.caniventer> { var x : lutreolus.cor>, rionegrensis.caniventer>; () => { var y = this; }; return x; } @@ -2494,8 +2494,8 @@ module rendalli { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : crenulata ->this : crenulata +>y : this +>this : this >x : lutreolus.cor>, rionegrensis.caniventer> } } @@ -2515,8 +2515,8 @@ module trivirgatus { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : tumidifrons ->this : tumidifrons +>y : this +>this : this >x : dogramacii.kaiseri vestitus() : lavali.xanthognathus { var x : lavali.xanthognathus; () => { var y = this; }; return x; } @@ -2527,8 +2527,8 @@ module trivirgatus { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : tumidifrons ->this : tumidifrons +>y : this +>this : this >x : lavali.xanthognathus aequatorius() : rionegrensis.caniventer { var x : rionegrensis.caniventer; () => { var y = this; }; return x; } @@ -2539,8 +2539,8 @@ module trivirgatus { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : tumidifrons ->this : tumidifrons +>y : this +>this : this >x : rionegrensis.caniventer scherman() : oconnelli { var x : oconnelli; () => { var y = this; }; return x; } @@ -2549,8 +2549,8 @@ module trivirgatus { >x : oconnelli >oconnelli : oconnelli >() => { var y = this; } : () => void ->y : tumidifrons ->this : tumidifrons +>y : this +>this : this >x : oconnelli improvisum() : argurus.peninsulae { var x : argurus.peninsulae; () => { var y = this; }; return x; } @@ -2561,8 +2561,8 @@ module trivirgatus { >argurus : any >peninsulae : argurus.peninsulae >() => { var y = this; } : () => void ->y : tumidifrons ->this : tumidifrons +>y : this +>this : this >x : argurus.peninsulae cervinipes() : panglima.abidi { var x : panglima.abidi; () => { var y = this; }; return x; } @@ -2581,8 +2581,8 @@ module trivirgatus { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : tumidifrons ->this : tumidifrons +>y : this +>this : this >x : panglima.abidi audax() : dogramacii.robustulus { var x : dogramacii.robustulus; () => { var y = this; }; return x; } @@ -2593,8 +2593,8 @@ module trivirgatus { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : tumidifrons ->this : tumidifrons +>y : this +>this : this >x : dogramacii.robustulus vallinus() : sagitta.sicarius { var x : sagitta.sicarius; () => { var y = this; }; return x; } @@ -2613,8 +2613,8 @@ module trivirgatus { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : tumidifrons ->this : tumidifrons +>y : this +>this : this >x : sagitta.sicarius } export class mixtus extends argurus.pygmaea> { @@ -2641,8 +2641,8 @@ module trivirgatus { >dogramacii : any >aurata : dogramacii.aurata >() => { var y = this; } : () => void ->y : mixtus ->this : mixtus +>y : this +>this : this >x : dogramacii.aurata bryophilus() : macrorhinos.marmosurus>> { var x : macrorhinos.marmosurus>>; () => { var y = this; }; return x; } @@ -2677,8 +2677,8 @@ module trivirgatus { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : mixtus ->this : mixtus +>y : this +>this : this >x : macrorhinos.marmosurus>> liechtensteini() : rendalli.zuluensis { var x : rendalli.zuluensis; () => { var y = this; }; return x; } @@ -2689,8 +2689,8 @@ module trivirgatus { >rendalli : any >zuluensis : rendalli.zuluensis >() => { var y = this; } : () => void ->y : mixtus ->this : mixtus +>y : this +>this : this >x : rendalli.zuluensis crawfordi() : howi.coludo> { var x : howi.coludo>; () => { var y = this; }; return x; } @@ -2717,8 +2717,8 @@ module trivirgatus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : mixtus ->this : mixtus +>y : this +>this : this >x : howi.coludo> hypsibia() : lavali.thaeleri { var x : lavali.thaeleri; () => { var y = this; }; return x; } @@ -2729,8 +2729,8 @@ module trivirgatus { >lavali : any >thaeleri : lavali.thaeleri >() => { var y = this; } : () => void ->y : mixtus ->this : mixtus +>y : this +>this : this >x : lavali.thaeleri matacus() : panglima.fundatus, lavali.beisa>, dammermani.melanops> { var x : panglima.fundatus, lavali.beisa>, dammermani.melanops>; () => { var y = this; }; return x; } @@ -2763,8 +2763,8 @@ module trivirgatus { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : mixtus ->this : mixtus +>y : this +>this : this >x : panglima.fundatus, lavali.beisa>, dammermani.melanops> demidoff() : caurinus.johorensis { var x : caurinus.johorensis; () => { var y = this; }; return x; } @@ -2783,8 +2783,8 @@ module trivirgatus { >rendalli : any >zuluensis : rendalli.zuluensis >() => { var y = this; } : () => void ->y : mixtus ->this : mixtus +>y : this +>this : this >x : caurinus.johorensis } export class lotor { @@ -2800,8 +2800,8 @@ module trivirgatus { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : lotor ->this : lotor +>y : this +>this : this >x : samarensis.pallidus pullata() : rionegrensis.veraecrucis { var x : rionegrensis.veraecrucis; () => { var y = this; }; return x; } @@ -2820,8 +2820,8 @@ module trivirgatus { >argurus : any >peninsulae : argurus.peninsulae >() => { var y = this; } : () => void ->y : lotor ->this : lotor +>y : this +>this : this >x : rionegrensis.veraecrucis } export class falconeri { @@ -2867,8 +2867,8 @@ module trivirgatus { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : falconeri ->this : falconeri +>y : this +>this : this >x : rendalli.moojeni>, daubentonii.arboreus> gouldi() : nigra.dolichurus>, patas.uralensis> { var x : nigra.dolichurus>, patas.uralensis>; () => { var y = this; }; return x; } @@ -2903,8 +2903,8 @@ module trivirgatus { >patas : any >uralensis : patas.uralensis >() => { var y = this; } : () => void ->y : falconeri ->this : falconeri +>y : this +>this : this >x : nigra.dolichurus>, patas.uralensis> fuscicollis() : samarensis.pelurus> { var x : samarensis.pelurus>; () => { var y = this; }; return x; } @@ -2931,8 +2931,8 @@ module trivirgatus { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : falconeri ->this : falconeri +>y : this +>this : this >x : samarensis.pelurus> martiensseni() : sagitta.cinereus>, dogramacii.koepckeae> { var x : sagitta.cinereus>, dogramacii.koepckeae>; () => { var y = this; }; return x; } @@ -2967,8 +2967,8 @@ module trivirgatus { >dogramacii : any >koepckeae : dogramacii.koepckeae >() => { var y = this; } : () => void ->y : falconeri ->this : falconeri +>y : this +>this : this >x : sagitta.cinereus>, dogramacii.koepckeae> gaoligongensis() : dogramacii.koepckeae { var x : dogramacii.koepckeae; () => { var y = this; }; return x; } @@ -2979,8 +2979,8 @@ module trivirgatus { >dogramacii : any >koepckeae : dogramacii.koepckeae >() => { var y = this; } : () => void ->y : falconeri ->this : falconeri +>y : this +>this : this >x : dogramacii.koepckeae shawi() : minutus.inez> { var x : minutus.inez>; () => { var y = this; }; return x; } @@ -3007,8 +3007,8 @@ module trivirgatus { >quasiater : any >bobrinskoi : quasiater.bobrinskoi >() => { var y = this; } : () => void ->y : falconeri ->this : falconeri +>y : this +>this : this >x : minutus.inez> gmelini() : rionegrensis.caniventer { var x : rionegrensis.caniventer; () => { var y = this; }; return x; } @@ -3019,8 +3019,8 @@ module trivirgatus { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : falconeri ->this : falconeri +>y : this +>this : this >x : rionegrensis.caniventer } export class oconnelli { @@ -3042,8 +3042,8 @@ module trivirgatus { >julianae : any >galapagoensis : julianae.galapagoensis >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : nigra.thalia terrestris() : macrorhinos.konganensis { var x : macrorhinos.konganensis; () => { var y = this; }; return x; } @@ -3054,8 +3054,8 @@ module trivirgatus { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : macrorhinos.konganensis chrysopus() : sagitta.sicarius> { var x : sagitta.sicarius>; () => { var y = this; }; return x; } @@ -3082,8 +3082,8 @@ module trivirgatus { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : sagitta.sicarius> fuscomurina() : argurus.peninsulae { var x : argurus.peninsulae; () => { var y = this; }; return x; } @@ -3094,8 +3094,8 @@ module trivirgatus { >argurus : any >peninsulae : argurus.peninsulae >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : argurus.peninsulae hellwaldii() : nigra.gracilis, petrophilus.sodyi> { var x : nigra.gracilis, petrophilus.sodyi>; () => { var y = this; }; return x; } @@ -3130,8 +3130,8 @@ module trivirgatus { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : nigra.gracilis, petrophilus.sodyi> aenea() : argurus.luctuosa { var x : argurus.luctuosa; () => { var y = this; }; return x; } @@ -3142,8 +3142,8 @@ module trivirgatus { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : argurus.luctuosa perrini() : quasiater.bobrinskoi { var x : quasiater.bobrinskoi; () => { var y = this; }; return x; } @@ -3154,8 +3154,8 @@ module trivirgatus { >quasiater : any >bobrinskoi : quasiater.bobrinskoi >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : quasiater.bobrinskoi entellus() : dammermani.melanops { var x : dammermani.melanops; () => { var y = this; }; return x; } @@ -3166,8 +3166,8 @@ module trivirgatus { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : dammermani.melanops krebsii() : rionegrensis.veraecrucis { var x : rionegrensis.veraecrucis; () => { var y = this; }; return x; } @@ -3186,8 +3186,8 @@ module trivirgatus { >julianae : any >durangae : julianae.durangae >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : rionegrensis.veraecrucis cephalotes() : lutreolus.schlegeli { var x : lutreolus.schlegeli; () => { var y = this; }; return x; } @@ -3198,8 +3198,8 @@ module trivirgatus { >lutreolus : any >schlegeli : lutreolus.schlegeli >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : lutreolus.schlegeli molossinus() : daubentonii.nigricans> { var x : daubentonii.nigricans>; () => { var y = this; }; return x; } @@ -3226,8 +3226,8 @@ module trivirgatus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : daubentonii.nigricans> luisi() : dogramacii.robustulus { var x : dogramacii.robustulus; () => { var y = this; }; return x; } @@ -3238,8 +3238,8 @@ module trivirgatus { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : dogramacii.robustulus ceylonicus() : rionegrensis.caniventer { var x : rionegrensis.caniventer; () => { var y = this; }; return x; } @@ -3250,8 +3250,8 @@ module trivirgatus { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : rionegrensis.caniventer ralli() : lavali.xanthognathus { var x : lavali.xanthognathus; () => { var y = this; }; return x; } @@ -3262,8 +3262,8 @@ module trivirgatus { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : oconnelli ->this : oconnelli +>y : this +>this : this >x : lavali.xanthognathus } } @@ -3289,8 +3289,8 @@ module quasiater { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : bobrinskoi ->this : bobrinskoi +>y : this +>this : this >x : samarensis.cahirinus mulatta() : argurus.oreas { var x : argurus.oreas; () => { var y = this; }; return x; } @@ -3301,8 +3301,8 @@ module quasiater { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : bobrinskoi ->this : bobrinskoi +>y : this +>this : this >x : argurus.oreas ansorgei() : rendalli.moojeni, gabriellae.echinatus> { var x : rendalli.moojeni, gabriellae.echinatus>; () => { var y = this; }; return x; } @@ -3329,8 +3329,8 @@ module quasiater { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : bobrinskoi ->this : bobrinskoi +>y : this +>this : this >x : rendalli.moojeni, gabriellae.echinatus> Copper() : argurus.netscheri { var x : argurus.netscheri; () => { var y = this; }; return x; } @@ -3349,8 +3349,8 @@ module quasiater { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : bobrinskoi ->this : bobrinskoi +>y : this +>this : this >x : argurus.netscheri } } @@ -3375,8 +3375,8 @@ module ruatanica { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : americanus ->this : americanus +>y : this +>this : this >x : macrorhinos.konganensis mystacalis() : howi.angulatus { var x : howi.angulatus; () => { var y = this; }; return x; } @@ -3395,8 +3395,8 @@ module ruatanica { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : americanus ->this : americanus +>y : this +>this : this >x : howi.angulatus fardoulisi() : trivirgatus.oconnelli { var x : trivirgatus.oconnelli; () => { var y = this; }; return x; } @@ -3407,8 +3407,8 @@ module ruatanica { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : americanus ->this : americanus +>y : this +>this : this >x : trivirgatus.oconnelli tumidus() : gabriellae.amicus { var x : gabriellae.amicus; () => { var y = this; }; return x; } @@ -3419,8 +3419,8 @@ module ruatanica { >gabriellae : any >amicus : gabriellae.amicus >() => { var y = this; } : () => void ->y : americanus ->this : americanus +>y : this +>this : this >x : gabriellae.amicus } } @@ -3451,8 +3451,8 @@ module lavali { >uralensis : patas.uralensis >wilsoni : wilsoni >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : nigra.thalia lorentzii() : imperfecta.subspinosus { var x : imperfecta.subspinosus; () => { var y = this; }; return x; } @@ -3463,8 +3463,8 @@ module lavali { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : imperfecta.subspinosus antisensis() : lutreolus.foina { var x : lutreolus.foina; () => { var y = this; }; return x; } @@ -3475,8 +3475,8 @@ module lavali { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : lutreolus.foina blossevillii() : dammermani.siberu { var x : dammermani.siberu; () => { var y = this; }; return x; } @@ -3495,8 +3495,8 @@ module lavali { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : dammermani.siberu bontanus() : rionegrensis.caniventer { var x : rionegrensis.caniventer; () => { var y = this; }; return x; } @@ -3507,8 +3507,8 @@ module lavali { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : rionegrensis.caniventer caligata() : argurus.oreas { var x : argurus.oreas; () => { var y = this; }; return x; } @@ -3519,8 +3519,8 @@ module lavali { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : argurus.oreas franqueti() : panglima.amphibius, imperfecta.subspinosus> { var x : panglima.amphibius, imperfecta.subspinosus>; () => { var y = this; }; return x; } @@ -3547,8 +3547,8 @@ module lavali { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : panglima.amphibius, imperfecta.subspinosus> roberti() : julianae.acariensis { var x : julianae.acariensis; () => { var y = this; }; return x; } @@ -3559,8 +3559,8 @@ module lavali { >julianae : any >acariensis : julianae.acariensis >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : julianae.acariensis degelidus() : chrysaeolus.sarasinorum { var x : chrysaeolus.sarasinorum; () => { var y = this; }; return x; } @@ -3579,8 +3579,8 @@ module lavali { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : chrysaeolus.sarasinorum amoenus() : quasiater.carolinensis { var x : quasiater.carolinensis; () => { var y = this; }; return x; } @@ -3591,8 +3591,8 @@ module lavali { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : quasiater.carolinensis kob() : trivirgatus.lotor { var x : trivirgatus.lotor; () => { var y = this; }; return x; } @@ -3609,8 +3609,8 @@ module lavali { >oreas : argurus.oreas >beisa : beisa >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : trivirgatus.lotor csorbai() : caurinus.johorensis { var x : caurinus.johorensis; () => { var y = this; }; return x; } @@ -3629,8 +3629,8 @@ module lavali { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : caurinus.johorensis dorsata() : gabriellae.echinatus { var x : gabriellae.echinatus; () => { var y = this; }; return x; } @@ -3641,8 +3641,8 @@ module lavali { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : wilsoni ->this : wilsoni +>y : this +>this : this >x : gabriellae.echinatus } export class beisa { @@ -3666,8 +3666,8 @@ module lavali { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : provocax.melanoleuca dussumieri() : nigra.gracilis { var x : nigra.gracilis; () => { var y = this; }; return x; } @@ -3686,8 +3686,8 @@ module lavali { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : nigra.gracilis osvaldoreigi() : julianae.albidens { var x : julianae.albidens; () => { var y = this; }; return x; } @@ -3706,8 +3706,8 @@ module lavali { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : julianae.albidens grevyi() : samarensis.pallidus { var x : samarensis.pallidus; () => { var y = this; }; return x; } @@ -3718,8 +3718,8 @@ module lavali { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : samarensis.pallidus hirtula() : lepturus { var x : lepturus; () => { var y = this; }; return x; } @@ -3728,8 +3728,8 @@ module lavali { >x : lepturus >lepturus : lepturus >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : lepturus cristatus() : argurus.luctuosa { var x : argurus.luctuosa; () => { var y = this; }; return x; } @@ -3740,8 +3740,8 @@ module lavali { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : argurus.luctuosa darlingtoni() : sagitta.leptoceros { var x : sagitta.leptoceros; () => { var y = this; }; return x; } @@ -3758,8 +3758,8 @@ module lavali { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : sagitta.leptoceros fontanierii() : panamensis.setulosus>, lutreolus.foina> { var x : panamensis.setulosus>, lutreolus.foina>; () => { var y = this; }; return x; } @@ -3792,8 +3792,8 @@ module lavali { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : panamensis.setulosus>, lutreolus.foina> umbrosus() : howi.marcanoi { var x : howi.marcanoi; () => { var y = this; }; return x; } @@ -3804,8 +3804,8 @@ module lavali { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : howi.marcanoi chiriquinus() : imperfecta.lasiurus { var x : imperfecta.lasiurus; () => { var y = this; }; return x; } @@ -3824,8 +3824,8 @@ module lavali { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : imperfecta.lasiurus orarius() : lutreolus.schlegeli { var x : lutreolus.schlegeli; () => { var y = this; }; return x; } @@ -3836,8 +3836,8 @@ module lavali { >lutreolus : any >schlegeli : lutreolus.schlegeli >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : lutreolus.schlegeli ilaeus() : caurinus.mahaganus { var x : caurinus.mahaganus; () => { var y = this; }; return x; } @@ -3856,8 +3856,8 @@ module lavali { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : caurinus.mahaganus musschenbroekii() : trivirgatus.falconeri { var x : trivirgatus.falconeri; () => { var y = this; }; return x; } @@ -3868,8 +3868,8 @@ module lavali { >trivirgatus : any >falconeri : trivirgatus.falconeri >() => { var y = this; } : () => void ->y : otion ->this : otion +>y : this +>this : this >x : trivirgatus.falconeri } export class xanthognathus { @@ -3891,8 +3891,8 @@ module lavali { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : xanthognathus ->this : xanthognathus +>y : this +>this : this >x : daubentonii.nigricans albigena() : chrysaeolus.sarasinorum { var x : chrysaeolus.sarasinorum; () => { var y = this; }; return x; } @@ -3911,8 +3911,8 @@ module lavali { >quasiater : any >bobrinskoi : quasiater.bobrinskoi >() => { var y = this; } : () => void ->y : xanthognathus ->this : xanthognathus +>y : this +>this : this >x : chrysaeolus.sarasinorum onca() : sagitta.stolzmanni { var x : sagitta.stolzmanni; () => { var y = this; }; return x; } @@ -3923,8 +3923,8 @@ module lavali { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : xanthognathus ->this : xanthognathus +>y : this +>this : this >x : sagitta.stolzmanni gunnii() : minutus.himalayana, nigra.thalia> { var x : minutus.himalayana, nigra.thalia>; () => { var y = this; }; return x; } @@ -3957,8 +3957,8 @@ module lavali { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : xanthognathus ->this : xanthognathus +>y : this +>this : this >x : minutus.himalayana, nigra.thalia> apeco() : lutreolus.foina { var x : lutreolus.foina; () => { var y = this; }; return x; } @@ -3969,8 +3969,8 @@ module lavali { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : xanthognathus ->this : xanthognathus +>y : this +>this : this >x : lutreolus.foina variegates() : gabriellae.klossii { var x : gabriellae.klossii; () => { var y = this; }; return x; } @@ -3987,8 +3987,8 @@ module lavali { >julianae : any >nudicaudus : julianae.nudicaudus >() => { var y = this; } : () => void ->y : xanthognathus ->this : xanthognathus +>y : this +>this : this >x : gabriellae.klossii goudotii() : trivirgatus.falconeri { var x : trivirgatus.falconeri; () => { var y = this; }; return x; } @@ -3999,8 +3999,8 @@ module lavali { >trivirgatus : any >falconeri : trivirgatus.falconeri >() => { var y = this; } : () => void ->y : xanthognathus ->this : xanthognathus +>y : this +>this : this >x : trivirgatus.falconeri pohlei() : Lanthanum.megalonyx { var x : Lanthanum.megalonyx; () => { var y = this; }; return x; } @@ -4011,8 +4011,8 @@ module lavali { >Lanthanum : any >megalonyx : Lanthanum.megalonyx >() => { var y = this; } : () => void ->y : xanthognathus ->this : xanthognathus +>y : this +>this : this >x : Lanthanum.megalonyx ineptus() : panamensis.setulosus { var x : panamensis.setulosus; () => { var y = this; }; return x; } @@ -4027,8 +4027,8 @@ module lavali { >xanthognathus : xanthognathus >beisa : beisa >() => { var y = this; } : () => void ->y : xanthognathus ->this : xanthognathus +>y : this +>this : this >x : panamensis.setulosus euryotis() : rendalli.moojeni> { var x : rendalli.moojeni>; () => { var y = this; }; return x; } @@ -4055,8 +4055,8 @@ module lavali { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : xanthognathus ->this : xanthognathus +>y : this +>this : this >x : rendalli.moojeni> maurisca() : Lanthanum.suillus { var x : Lanthanum.suillus; () => { var y = this; }; return x; } @@ -4075,8 +4075,8 @@ module lavali { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : xanthognathus ->this : xanthognathus +>y : this +>this : this >x : Lanthanum.suillus coyhaiquensis() : caurinus.mahaganus, panglima.abidi>, lutreolus.punicus> { var x : caurinus.mahaganus, panglima.abidi>, lutreolus.punicus>; () => { var y = this; }; return x; } @@ -4119,8 +4119,8 @@ module lavali { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : xanthognathus ->this : xanthognathus +>y : this +>this : this >x : caurinus.mahaganus, panglima.abidi>, lutreolus.punicus> } export class thaeleri extends argurus.oreas { @@ -4137,8 +4137,8 @@ module lavali { >julianae : any >galapagoensis : julianae.galapagoensis >() => { var y = this; } : () => void ->y : thaeleri ->this : thaeleri +>y : this +>this : this >x : julianae.galapagoensis parvipes() : nigra.dolichurus { var x : nigra.dolichurus; () => { var y = this; }; return x; } @@ -4157,8 +4157,8 @@ module lavali { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : thaeleri ->this : thaeleri +>y : this +>this : this >x : nigra.dolichurus sponsorius() : rionegrensis.veraecrucis, julianae.steerii> { var x : rionegrensis.veraecrucis, julianae.steerii>; () => { var y = this; }; return x; } @@ -4185,8 +4185,8 @@ module lavali { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : thaeleri ->this : thaeleri +>y : this +>this : this >x : rionegrensis.veraecrucis, julianae.steerii> vates() : dogramacii.robustulus { var x : dogramacii.robustulus; () => { var y = this; }; return x; } @@ -4197,8 +4197,8 @@ module lavali { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : thaeleri ->this : thaeleri +>y : this +>this : this >x : dogramacii.robustulus roosmalenorum() : dogramacii.koepckeae { var x : dogramacii.koepckeae; () => { var y = this; }; return x; } @@ -4209,8 +4209,8 @@ module lavali { >dogramacii : any >koepckeae : dogramacii.koepckeae >() => { var y = this; } : () => void ->y : thaeleri ->this : thaeleri +>y : this +>this : this >x : dogramacii.koepckeae rubicola() : rendalli.moojeni, gabriellae.echinatus>> { var x : rendalli.moojeni, gabriellae.echinatus>>; () => { var y = this; }; return x; } @@ -4245,8 +4245,8 @@ module lavali { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : thaeleri ->this : thaeleri +>y : this +>this : this >x : rendalli.moojeni, gabriellae.echinatus>> ikonnikovi() : argurus.luctuosa { var x : argurus.luctuosa; () => { var y = this; }; return x; } @@ -4257,8 +4257,8 @@ module lavali { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : thaeleri ->this : thaeleri +>y : this +>this : this >x : argurus.luctuosa paramicrus() : imperfecta.ciliolabrum> { var x : imperfecta.ciliolabrum>; () => { var y = this; }; return x; } @@ -4283,8 +4283,8 @@ module lavali { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : thaeleri ->this : thaeleri +>y : this +>this : this >x : imperfecta.ciliolabrum> } export class lepturus extends Lanthanum.suillus { @@ -4313,8 +4313,8 @@ module lavali { >julianae : any >nudicaudus : julianae.nudicaudus >() => { var y = this; } : () => void ->y : lepturus ->this : lepturus +>y : this +>this : this >x : argurus.netscheri aequalis() : sagitta.cinereus>, petrophilus.minutilla>, Lanthanum.jugularis> { var x : sagitta.cinereus>, petrophilus.minutilla>, Lanthanum.jugularis>; () => { var y = this; }; return x; } @@ -4355,8 +4355,8 @@ module lavali { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : lepturus ->this : lepturus +>y : this +>this : this >x : sagitta.cinereus>, petrophilus.minutilla>, Lanthanum.jugularis> } } @@ -4385,8 +4385,8 @@ module dogramacii { >julianae : any >nudicaudus : julianae.nudicaudus >() => { var y = this; } : () => void ->y : robustulus ->this : robustulus +>y : this +>this : this >x : minutus.inez humboldti() : sagitta.cinereus { var x : sagitta.cinereus; () => { var y = this; }; return x; } @@ -4405,8 +4405,8 @@ module dogramacii { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : robustulus ->this : robustulus +>y : this +>this : this >x : sagitta.cinereus mexicana() : macrorhinos.konganensis { var x : macrorhinos.konganensis; () => { var y = this; }; return x; } @@ -4417,8 +4417,8 @@ module dogramacii { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : robustulus ->this : robustulus +>y : this +>this : this >x : macrorhinos.konganensis martini() : julianae.oralis { var x : julianae.oralis; () => { var y = this; }; return x; } @@ -4437,8 +4437,8 @@ module dogramacii { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : robustulus ->this : robustulus +>y : this +>this : this >x : julianae.oralis beatus() : Lanthanum.jugularis { var x : Lanthanum.jugularis; () => { var y = this; }; return x; } @@ -4449,8 +4449,8 @@ module dogramacii { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : robustulus ->this : robustulus +>y : this +>this : this >x : Lanthanum.jugularis leporina() : trivirgatus.falconeri { var x : trivirgatus.falconeri; () => { var y = this; }; return x; } @@ -4461,8 +4461,8 @@ module dogramacii { >trivirgatus : any >falconeri : trivirgatus.falconeri >() => { var y = this; } : () => void ->y : robustulus ->this : robustulus +>y : this +>this : this >x : trivirgatus.falconeri pearsonii() : dammermani.melanops { var x : dammermani.melanops; () => { var y = this; }; return x; } @@ -4473,8 +4473,8 @@ module dogramacii { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : robustulus ->this : robustulus +>y : this +>this : this >x : dammermani.melanops keaysi() : howi.angulatus { var x : howi.angulatus; () => { var y = this; }; return x; } @@ -4493,8 +4493,8 @@ module dogramacii { >rendalli : any >zuluensis : rendalli.zuluensis >() => { var y = this; } : () => void ->y : robustulus ->this : robustulus +>y : this +>this : this >x : howi.angulatus hindei() : imperfecta.lasiurus { var x : imperfecta.lasiurus; () => { var y = this; }; return x; } @@ -4513,8 +4513,8 @@ module dogramacii { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : robustulus ->this : robustulus +>y : this +>this : this >x : imperfecta.lasiurus } export class koepckeae { @@ -4542,8 +4542,8 @@ module dogramacii { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : koepckeae ->this : koepckeae +>y : this +>this : this >x : samarensis.pelurus, julianae.sumatrana> } export class kaiseri { @@ -4557,8 +4557,8 @@ module dogramacii { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : quasiater.carolinensis paramorum() : Lanthanum.megalonyx { var x : Lanthanum.megalonyx; () => { var y = this; }; return x; } @@ -4569,8 +4569,8 @@ module dogramacii { >Lanthanum : any >megalonyx : Lanthanum.megalonyx >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : Lanthanum.megalonyx rubidus() : trivirgatus.lotor { var x : trivirgatus.lotor; () => { var y = this; }; return x; } @@ -4589,8 +4589,8 @@ module dogramacii { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : trivirgatus.lotor juninensis() : quasiater.bobrinskoi { var x : quasiater.bobrinskoi; () => { var y = this; }; return x; } @@ -4601,8 +4601,8 @@ module dogramacii { >quasiater : any >bobrinskoi : quasiater.bobrinskoi >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : quasiater.bobrinskoi marginata() : argurus.wetmorei>> { var x : argurus.wetmorei>>; () => { var y = this; }; return x; } @@ -4637,8 +4637,8 @@ module dogramacii { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : argurus.wetmorei>> Meitnerium() : ruatanica.Praseodymium> { var x : ruatanica.Praseodymium>; () => { var y = this; }; return x; } @@ -4665,8 +4665,8 @@ module dogramacii { >julianae : any >galapagoensis : julianae.galapagoensis >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : ruatanica.Praseodymium> pinetorum() : rionegrensis.caniventer { var x : rionegrensis.caniventer; () => { var y = this; }; return x; } @@ -4677,8 +4677,8 @@ module dogramacii { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : rionegrensis.caniventer hoolock() : samarensis.pelurus { var x : samarensis.pelurus; () => { var y = this; }; return x; } @@ -4697,8 +4697,8 @@ module dogramacii { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : samarensis.pelurus poeyi() : gabriellae.echinatus { var x : gabriellae.echinatus; () => { var y = this; }; return x; } @@ -4709,8 +4709,8 @@ module dogramacii { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : gabriellae.echinatus Thulium() : julianae.durangae { var x : julianae.durangae; () => { var y = this; }; return x; } @@ -4721,8 +4721,8 @@ module dogramacii { >julianae : any >durangae : julianae.durangae >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : julianae.durangae patrius() : Lanthanum.jugularis { var x : Lanthanum.jugularis; () => { var y = this; }; return x; } @@ -4733,8 +4733,8 @@ module dogramacii { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : Lanthanum.jugularis quadraticauda() : julianae.nudicaudus { var x : julianae.nudicaudus; () => { var y = this; }; return x; } @@ -4745,8 +4745,8 @@ module dogramacii { >julianae : any >nudicaudus : julianae.nudicaudus >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : julianae.nudicaudus ater() : ruatanica.americanus { var x : ruatanica.americanus; () => { var y = this; }; return x; } @@ -4757,8 +4757,8 @@ module dogramacii { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : kaiseri ->this : kaiseri +>y : this +>this : this >x : ruatanica.americanus } export class aurata { @@ -4794,8 +4794,8 @@ module dogramacii { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : aurata ->this : aurata +>y : this +>this : this >x : nigra.gracilis, julianae.sumatrana>, ruatanica.americanus> howensis() : ruatanica.americanus { var x : ruatanica.americanus; () => { var y = this; }; return x; } @@ -4806,8 +4806,8 @@ module dogramacii { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : aurata ->this : aurata +>y : this +>this : this >x : ruatanica.americanus karlkoopmani() : caurinus.psilurus { var x : caurinus.psilurus; () => { var y = this; }; return x; } @@ -4818,8 +4818,8 @@ module dogramacii { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : aurata ->this : aurata +>y : this +>this : this >x : caurinus.psilurus mirapitanga() : julianae.albidens { var x : julianae.albidens; () => { var y = this; }; return x; } @@ -4838,8 +4838,8 @@ module dogramacii { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : aurata ->this : aurata +>y : this +>this : this >x : julianae.albidens ophiodon() : aurata { var x : aurata; () => { var y = this; }; return x; } @@ -4848,8 +4848,8 @@ module dogramacii { >x : aurata >aurata : aurata >() => { var y = this; } : () => void ->y : aurata ->this : aurata +>y : this +>this : this >x : aurata landeri() : samarensis.pelurus { var x : samarensis.pelurus; () => { var y = this; }; return x; } @@ -4868,8 +4868,8 @@ module dogramacii { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : aurata ->this : aurata +>y : this +>this : this >x : samarensis.pelurus sonomae() : trivirgatus.lotor, koepckeae> { var x : trivirgatus.lotor, koepckeae>; () => { var y = this; }; return x; } @@ -4894,8 +4894,8 @@ module dogramacii { >psilurus : caurinus.psilurus >koepckeae : koepckeae >() => { var y = this; } : () => void ->y : aurata ->this : aurata +>y : this +>this : this >x : trivirgatus.lotor, koepckeae> erythromos() : caurinus.johorensis, nigra.dolichurus> { var x : caurinus.johorensis, nigra.dolichurus>; () => { var y = this; }; return x; } @@ -4930,8 +4930,8 @@ module dogramacii { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : aurata ->this : aurata +>y : this +>this : this >x : caurinus.johorensis, nigra.dolichurus> } } @@ -4952,8 +4952,8 @@ module lutreolus { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : rionegrensis.caniventer blicki() : dogramacii.robustulus { var x : dogramacii.robustulus; () => { var y = this; }; return x; } @@ -4964,8 +4964,8 @@ module lutreolus { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : dogramacii.robustulus culionensis() : argurus.dauricus { var x : argurus.dauricus; () => { var y = this; }; return x; } @@ -4984,8 +4984,8 @@ module lutreolus { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : argurus.dauricus scrofa() : petrophilus.sodyi { var x : petrophilus.sodyi; () => { var y = this; }; return x; } @@ -5004,8 +5004,8 @@ module lutreolus { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : petrophilus.sodyi fernandoni() : quasiater.carolinensis { var x : quasiater.carolinensis; () => { var y = this; }; return x; } @@ -5016,8 +5016,8 @@ module lutreolus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : quasiater.carolinensis Tin() : sagitta.leptoceros> { var x : sagitta.leptoceros>; () => { var y = this; }; return x; } @@ -5044,8 +5044,8 @@ module lutreolus { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : sagitta.leptoceros> marmorata() : panamensis.setulosus> { var x : panamensis.setulosus>; () => { var y = this; }; return x; } @@ -5072,8 +5072,8 @@ module lutreolus { >lutreolus : any >punicus : punicus >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : panamensis.setulosus> tavaratra() : Lanthanum.nitidus { var x : Lanthanum.nitidus; () => { var y = this; }; return x; } @@ -5092,8 +5092,8 @@ module lutreolus { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : Lanthanum.nitidus peregrina() : daubentonii.nesiotes { var x : daubentonii.nesiotes; () => { var y = this; }; return x; } @@ -5112,8 +5112,8 @@ module lutreolus { >lutreolus : any >punicus : punicus >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : daubentonii.nesiotes frontalis() : macrorhinos.marmosurus>, samarensis.pallidus> { var x : macrorhinos.marmosurus>, samarensis.pallidus>; () => { var y = this; }; return x; } @@ -5148,8 +5148,8 @@ module lutreolus { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : macrorhinos.marmosurus>, samarensis.pallidus> cuniculus() : patas.uralensis { var x : patas.uralensis; () => { var y = this; }; return x; } @@ -5160,8 +5160,8 @@ module lutreolus { >patas : any >uralensis : patas.uralensis >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : patas.uralensis magdalenae() : julianae.gerbillus> { var x : julianae.gerbillus>; () => { var y = this; }; return x; } @@ -5188,8 +5188,8 @@ module lutreolus { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : julianae.gerbillus> andamanensis() : julianae.oralis { var x : julianae.oralis; () => { var y = this; }; return x; } @@ -5208,8 +5208,8 @@ module lutreolus { >rendalli : any >zuluensis : rendalli.zuluensis >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : julianae.oralis dispar() : panamensis.linulus { var x : panamensis.linulus; () => { var y = this; }; return x; } @@ -5228,8 +5228,8 @@ module lutreolus { >minutus : any >portoricensis : minutus.portoricensis >() => { var y = this; } : () => void ->y : schlegeli ->this : schlegeli +>y : this +>this : this >x : panamensis.linulus } } @@ -5249,8 +5249,8 @@ module argurus { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : dauricus ->this : dauricus +>y : this +>this : this >x : Lanthanum.jugularis duodecimcostatus() : lavali.xanthognathus { var x : lavali.xanthognathus; () => { var y = this; }; return x; } @@ -5261,8 +5261,8 @@ module argurus { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : dauricus ->this : dauricus +>y : this +>this : this >x : lavali.xanthognathus foxi() : daubentonii.nesiotes { var x : daubentonii.nesiotes; () => { var y = this; }; return x; } @@ -5281,8 +5281,8 @@ module argurus { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : dauricus ->this : dauricus +>y : this +>this : this >x : daubentonii.nesiotes macleayii() : petrophilus.sodyi>, petrophilus.minutilla> { var x : petrophilus.sodyi>, petrophilus.minutilla>; () => { var y = this; }; return x; } @@ -5317,8 +5317,8 @@ module argurus { >petrophilus : any >minutilla : petrophilus.minutilla >() => { var y = this; } : () => void ->y : dauricus ->this : dauricus +>y : this +>this : this >x : petrophilus.sodyi>, petrophilus.minutilla> darienensis() : trivirgatus.oconnelli { var x : trivirgatus.oconnelli; () => { var y = this; }; return x; } @@ -5329,8 +5329,8 @@ module argurus { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : dauricus ->this : dauricus +>y : this +>this : this >x : trivirgatus.oconnelli hardwickii() : macrorhinos.daphaenodon { var x : macrorhinos.daphaenodon; () => { var y = this; }; return x; } @@ -5341,8 +5341,8 @@ module argurus { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : dauricus ->this : dauricus +>y : this +>this : this >x : macrorhinos.daphaenodon albifrons() : rionegrensis.veraecrucis { var x : rionegrensis.veraecrucis; () => { var y = this; }; return x; } @@ -5361,8 +5361,8 @@ module argurus { >julianae : any >durangae : julianae.durangae >() => { var y = this; } : () => void ->y : dauricus ->this : dauricus +>y : this +>this : this >x : rionegrensis.veraecrucis jacobitus() : caurinus.johorensis>> { var x : caurinus.johorensis>>; () => { var y = this; }; return x; } @@ -5397,8 +5397,8 @@ module argurus { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : dauricus ->this : dauricus +>y : this +>this : this >x : caurinus.johorensis>> guentheri() : rendalli.moojeni { var x : rendalli.moojeni; () => { var y = this; }; return x; } @@ -5417,8 +5417,8 @@ module argurus { >argurus : any >oreas : oreas >() => { var y = this; } : () => void ->y : dauricus ->this : dauricus +>y : this +>this : this >x : rendalli.moojeni mahomet() : imperfecta.ciliolabrum { var x : imperfecta.ciliolabrum; () => { var y = this; }; return x; } @@ -5437,8 +5437,8 @@ module argurus { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : dauricus ->this : dauricus +>y : this +>this : this >x : imperfecta.ciliolabrum misionensis() : macrorhinos.marmosurus, gabriellae.echinatus> { var x : macrorhinos.marmosurus, gabriellae.echinatus>; () => { var y = this; }; return x; } @@ -5465,8 +5465,8 @@ module argurus { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : dauricus ->this : dauricus +>y : this +>this : this >x : macrorhinos.marmosurus, gabriellae.echinatus> } } @@ -5534,8 +5534,8 @@ module nigra { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : dolichurus ->this : dolichurus +>y : this +>this : this >x : panglima.abidi, argurus.netscheri, julianae.oralis>>> alfredi() : caurinus.psilurus { var x : caurinus.psilurus; () => { var y = this; }; return x; } @@ -5546,8 +5546,8 @@ module nigra { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : dolichurus ->this : dolichurus +>y : this +>this : this >x : caurinus.psilurus morrisi() : ruatanica.hector, quasiater.wattsi>>> { var x : ruatanica.hector, quasiater.wattsi>>>; () => { var y = this; }; return x; } @@ -5598,8 +5598,8 @@ module nigra { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : dolichurus ->this : dolichurus +>y : this +>this : this >x : ruatanica.hector, quasiater.wattsi>>> lekaguli() : Lanthanum.nitidus { var x : Lanthanum.nitidus; () => { var y = this; }; return x; } @@ -5618,8 +5618,8 @@ module nigra { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : dolichurus ->this : dolichurus +>y : this +>this : this >x : Lanthanum.nitidus dimissus() : imperfecta.subspinosus { var x : imperfecta.subspinosus; () => { var y = this; }; return x; } @@ -5630,8 +5630,8 @@ module nigra { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : dolichurus ->this : dolichurus +>y : this +>this : this >x : imperfecta.subspinosus phaeotis() : julianae.sumatrana { var x : julianae.sumatrana; () => { var y = this; }; return x; } @@ -5642,8 +5642,8 @@ module nigra { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : dolichurus ->this : dolichurus +>y : this +>this : this >x : julianae.sumatrana ustus() : julianae.acariensis { var x : julianae.acariensis; () => { var y = this; }; return x; } @@ -5654,8 +5654,8 @@ module nigra { >julianae : any >acariensis : julianae.acariensis >() => { var y = this; } : () => void ->y : dolichurus ->this : dolichurus +>y : this +>this : this >x : julianae.acariensis sagei() : howi.marcanoi { var x : howi.marcanoi; () => { var y = this; }; return x; } @@ -5666,8 +5666,8 @@ module nigra { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : dolichurus ->this : dolichurus +>y : this +>this : this >x : howi.marcanoi } } @@ -5720,8 +5720,8 @@ module panglima { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : amphibius ->this : amphibius +>y : this +>this : this >x : macrorhinos.marmosurus, gabriellae.echinatus>, sagitta.stolzmanni> jerdoni(): macrorhinos.daphaenodon { var x: macrorhinos.daphaenodon; () => { var y = this; }; return x; } @@ -5732,8 +5732,8 @@ module panglima { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : amphibius ->this : amphibius +>y : this +>this : this >x : macrorhinos.daphaenodon camtschatica(): samarensis.pallidus { var x: samarensis.pallidus; () => { var y = this; }; return x; } @@ -5744,8 +5744,8 @@ module panglima { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : amphibius ->this : amphibius +>y : this +>this : this >x : samarensis.pallidus spadix(): petrophilus.sodyi { var x: petrophilus.sodyi; () => { var y = this; }; return x; } @@ -5764,8 +5764,8 @@ module panglima { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : amphibius ->this : amphibius +>y : this +>this : this >x : petrophilus.sodyi luismanueli(): rendalli.moojeni { var x: rendalli.moojeni; () => { var y = this; }; return x; } @@ -5784,8 +5784,8 @@ module panglima { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : amphibius ->this : amphibius +>y : this +>this : this >x : rendalli.moojeni aceramarcae(): daubentonii.arboreus { var x: daubentonii.arboreus; () => { var y = this; }; return x; } @@ -5804,8 +5804,8 @@ module panglima { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : amphibius ->this : amphibius +>y : this +>this : this >x : daubentonii.arboreus } export class fundatus extends lutreolus.schlegeli { @@ -5832,8 +5832,8 @@ module panglima { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : fundatus ->this : fundatus +>y : this +>this : this >x : nigra.gracilis flamarioni(): imperfecta.lasiurus>, sagitta.leptoceros>> { var x: imperfecta.lasiurus>, sagitta.leptoceros>>; () => { var y = this; }; return x; } @@ -5882,8 +5882,8 @@ module panglima { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : fundatus ->this : fundatus +>y : this +>this : this >x : imperfecta.lasiurus>, sagitta.leptoceros>> mirabilis(): macrorhinos.marmosurus, lavali.lepturus> { var x: macrorhinos.marmosurus, lavali.lepturus>; () => { var y = this; }; return x; } @@ -5910,8 +5910,8 @@ module panglima { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : fundatus ->this : fundatus +>y : this +>this : this >x : macrorhinos.marmosurus, lavali.lepturus> } export class abidi extends argurus.dauricus { @@ -5934,8 +5934,8 @@ module panglima { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : abidi ->this : abidi +>y : this +>this : this >x : trivirgatus.oconnelli macedonicus(): petrophilus.minutilla { var x: petrophilus.minutilla; () => { var y = this; }; return x; } @@ -5946,8 +5946,8 @@ module panglima { >petrophilus : any >minutilla : petrophilus.minutilla >() => { var y = this; } : () => void ->y : abidi ->this : abidi +>y : this +>this : this >x : petrophilus.minutilla galili(): samarensis.cahirinus { var x: samarensis.cahirinus; () => { var y = this; }; return x; } @@ -5966,8 +5966,8 @@ module panglima { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : abidi ->this : abidi +>y : this +>this : this >x : samarensis.cahirinus thierryi(): dogramacii.robustulus { var x: dogramacii.robustulus; () => { var y = this; }; return x; } @@ -5978,8 +5978,8 @@ module panglima { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : abidi ->this : abidi +>y : this +>this : this >x : dogramacii.robustulus ega(): imperfecta.lasiurus> { var x: imperfecta.lasiurus>; () => { var y = this; }; return x; } @@ -6006,8 +6006,8 @@ module panglima { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : abidi ->this : abidi +>y : this +>this : this >x : imperfecta.lasiurus> } } @@ -6025,8 +6025,8 @@ module quasiater { >rendalli : any >zuluensis : rendalli.zuluensis >() => { var y = this; } : () => void ->y : carolinensis ->this : carolinensis +>y : this +>this : this >x : rendalli.zuluensis aeneus(): howi.marcanoi { var x: howi.marcanoi; () => { var y = this; }; return x; } @@ -6037,8 +6037,8 @@ module quasiater { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : carolinensis ->this : carolinensis +>y : this +>this : this >x : howi.marcanoi aloysiisabaudiae(): argurus.netscheri, lavali.lepturus> { var x: argurus.netscheri, lavali.lepturus>; () => { var y = this; }; return x; } @@ -6065,8 +6065,8 @@ module quasiater { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : carolinensis ->this : carolinensis +>y : this +>this : this >x : argurus.netscheri, lavali.lepturus> tenellus(): julianae.nudicaudus { var x: julianae.nudicaudus; () => { var y = this; }; return x; } @@ -6077,8 +6077,8 @@ module quasiater { >julianae : any >nudicaudus : julianae.nudicaudus >() => { var y = this; } : () => void ->y : carolinensis ->this : carolinensis +>y : this +>this : this >x : julianae.nudicaudus andium(): lavali.beisa { var x: lavali.beisa; () => { var y = this; }; return x; } @@ -6089,8 +6089,8 @@ module quasiater { >lavali : any >beisa : lavali.beisa >() => { var y = this; } : () => void ->y : carolinensis ->this : carolinensis +>y : this +>this : this >x : lavali.beisa persephone(): panglima.fundatus { var x: panglima.fundatus; () => { var y = this; }; return x; } @@ -6109,8 +6109,8 @@ module quasiater { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : carolinensis ->this : carolinensis +>y : this +>this : this >x : panglima.fundatus patrizii(): Lanthanum.megalonyx { var x: Lanthanum.megalonyx; () => { var y = this; }; return x; } @@ -6121,8 +6121,8 @@ module quasiater { >Lanthanum : any >megalonyx : Lanthanum.megalonyx >() => { var y = this; } : () => void ->y : carolinensis ->this : carolinensis +>y : this +>this : this >x : Lanthanum.megalonyx } } @@ -6161,8 +6161,8 @@ module minutus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : himalayana ->this : himalayana +>y : this +>this : this >x : argurus.netscheri> lobata(): samarensis.pallidus { var x: samarensis.pallidus; () => { var y = this; }; return x; } @@ -6173,8 +6173,8 @@ module minutus { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : himalayana ->this : himalayana +>y : this +>this : this >x : samarensis.pallidus rusticus(): dogramacii.aurata { var x: dogramacii.aurata; () => { var y = this; }; return x; } @@ -6185,8 +6185,8 @@ module minutus { >dogramacii : any >aurata : dogramacii.aurata >() => { var y = this; } : () => void ->y : himalayana ->this : himalayana +>y : this +>this : this >x : dogramacii.aurata latona(): daubentonii.nesiotes { var x: daubentonii.nesiotes; () => { var y = this; }; return x; } @@ -6205,8 +6205,8 @@ module minutus { >Lanthanum : any >megalonyx : Lanthanum.megalonyx >() => { var y = this; } : () => void ->y : himalayana ->this : himalayana +>y : this +>this : this >x : daubentonii.nesiotes famulus(): patas.uralensis { var x: patas.uralensis; () => { var y = this; }; return x; } @@ -6217,8 +6217,8 @@ module minutus { >patas : any >uralensis : patas.uralensis >() => { var y = this; } : () => void ->y : himalayana ->this : himalayana +>y : this +>this : this >x : patas.uralensis flaviceps(): minutus.inez> { var x: minutus.inez>; () => { var y = this; }; return x; } @@ -6245,8 +6245,8 @@ module minutus { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : himalayana ->this : himalayana +>y : this +>this : this >x : inez> paradoxolophus(): nigra.dolichurus> { var x: nigra.dolichurus>; () => { var y = this; }; return x; } @@ -6273,8 +6273,8 @@ module minutus { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : himalayana ->this : himalayana +>y : this +>this : this >x : nigra.dolichurus> Osmium(): lavali.wilsoni { var x: lavali.wilsoni; () => { var y = this; }; return x; } @@ -6285,8 +6285,8 @@ module minutus { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : himalayana ->this : himalayana +>y : this +>this : this >x : lavali.wilsoni vulgaris(): Lanthanum.nitidus { var x: Lanthanum.nitidus; () => { var y = this; }; return x; } @@ -6305,8 +6305,8 @@ module minutus { >julianae : any >acariensis : julianae.acariensis >() => { var y = this; } : () => void ->y : himalayana ->this : himalayana +>y : this +>this : this >x : Lanthanum.nitidus betsileoensis(): panglima.amphibius { var x: panglima.amphibius; () => { var y = this; }; return x; } @@ -6325,8 +6325,8 @@ module minutus { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : himalayana ->this : himalayana +>y : this +>this : this >x : panglima.amphibius vespuccii(): argurus.gilbertii, provocax.melanoleuca> { var x: argurus.gilbertii, provocax.melanoleuca>; () => { var y = this; }; return x; } @@ -6353,8 +6353,8 @@ module minutus { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : himalayana ->this : himalayana +>y : this +>this : this >x : argurus.gilbertii, provocax.melanoleuca> olympus(): Lanthanum.megalonyx { var x: Lanthanum.megalonyx; () => { var y = this; }; return x; } @@ -6365,8 +6365,8 @@ module minutus { >Lanthanum : any >megalonyx : Lanthanum.megalonyx >() => { var y = this; } : () => void ->y : himalayana ->this : himalayana +>y : this +>this : this >x : Lanthanum.megalonyx } } @@ -6417,8 +6417,8 @@ module caurinus { >lavali : any >otion : lavali.otion >() => { var y = this; } : () => void ->y : mahaganus ->this : mahaganus +>y : this +>this : this >x : ruatanica.hector>> devius(): samarensis.pelurus, trivirgatus.falconeri>> { var x: samarensis.pelurus, trivirgatus.falconeri>>; () => { var y = this; }; return x; } @@ -6453,8 +6453,8 @@ module caurinus { >trivirgatus : any >falconeri : trivirgatus.falconeri >() => { var y = this; } : () => void ->y : mahaganus ->this : mahaganus +>y : this +>this : this >x : samarensis.pelurus, trivirgatus.falconeri>> masalai(): argurus.oreas { var x: argurus.oreas; () => { var y = this; }; return x; } @@ -6465,8 +6465,8 @@ module caurinus { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : mahaganus ->this : mahaganus +>y : this +>this : this >x : argurus.oreas kathleenae(): nigra.dolichurus { var x: nigra.dolichurus; () => { var y = this; }; return x; } @@ -6485,8 +6485,8 @@ module caurinus { >caurinus : any >psilurus : psilurus >() => { var y = this; } : () => void ->y : mahaganus ->this : mahaganus +>y : this +>this : this >x : nigra.dolichurus simulus(): gabriellae.echinatus { var x: gabriellae.echinatus; () => { var y = this; }; return x; } @@ -6497,8 +6497,8 @@ module caurinus { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : mahaganus ->this : mahaganus +>y : this +>this : this >x : gabriellae.echinatus nigrovittatus(): caurinus.mahaganus>> { var x: caurinus.mahaganus>>; () => { var y = this; }; return x; } @@ -6533,8 +6533,8 @@ module caurinus { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : mahaganus ->this : mahaganus +>y : this +>this : this >x : mahaganus>> senegalensis(): gabriellae.klossii, dammermani.melanops> { var x: gabriellae.klossii, dammermani.melanops>; () => { var y = this; }; return x; } @@ -6561,8 +6561,8 @@ module caurinus { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : mahaganus ->this : mahaganus +>y : this +>this : this >x : gabriellae.klossii, dammermani.melanops> acticola(): argurus.luctuosa { var x: argurus.luctuosa; () => { var y = this; }; return x; } @@ -6573,8 +6573,8 @@ module caurinus { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : mahaganus ->this : mahaganus +>y : this +>this : this >x : argurus.luctuosa } } @@ -6594,8 +6594,8 @@ module macrorhinos { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : marmosurus ->this : marmosurus +>y : this +>this : this >x : lutreolus.punicus } } @@ -6618,8 +6618,8 @@ module howi { >howi : any >marcanoi : marcanoi >() => { var y = this; } : () => void ->y : angulatus ->this : angulatus +>y : this +>this : this >x : marcanoi } } @@ -6648,8 +6648,8 @@ module nigra { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : thalia ->this : thalia +>y : this +>this : this >x : quasiater.carolinensis arnuxii(): panamensis.linulus, lavali.beisa> { var x: panamensis.linulus, lavali.beisa>; () => { var y = this; }; return x; } @@ -6676,8 +6676,8 @@ module nigra { >lavali : any >beisa : lavali.beisa >() => { var y = this; } : () => void ->y : thalia ->this : thalia +>y : this +>this : this >x : panamensis.linulus, lavali.beisa> verheyeni(): lavali.xanthognathus { var x: lavali.xanthognathus; () => { var y = this; }; return x; } @@ -6688,8 +6688,8 @@ module nigra { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : thalia ->this : thalia +>y : this +>this : this >x : lavali.xanthognathus dauuricus(): gabriellae.amicus { var x: gabriellae.amicus; () => { var y = this; }; return x; } @@ -6700,8 +6700,8 @@ module nigra { >gabriellae : any >amicus : gabriellae.amicus >() => { var y = this; } : () => void ->y : thalia ->this : thalia +>y : this +>this : this >x : gabriellae.amicus tristriatus(): rionegrensis.veraecrucis> { var x: rionegrensis.veraecrucis>; () => { var y = this; }; return x; } @@ -6728,8 +6728,8 @@ module nigra { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : thalia ->this : thalia +>y : this +>this : this >x : rionegrensis.veraecrucis> lasiura(): panglima.abidi>, Lanthanum.nitidus> { var x: panglima.abidi>, Lanthanum.nitidus>; () => { var y = this; }; return x; } @@ -6772,8 +6772,8 @@ module nigra { >julianae : any >acariensis : julianae.acariensis >() => { var y = this; } : () => void ->y : thalia ->this : thalia +>y : this +>this : this >x : panglima.abidi>, Lanthanum.nitidus> gangetica(): argurus.luctuosa { var x: argurus.luctuosa; () => { var y = this; }; return x; } @@ -6784,8 +6784,8 @@ module nigra { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : thalia ->this : thalia +>y : this +>this : this >x : argurus.luctuosa brucei(): chrysaeolus.sarasinorum { var x: chrysaeolus.sarasinorum; () => { var y = this; }; return x; } @@ -6804,8 +6804,8 @@ module nigra { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : thalia ->this : thalia +>y : this +>this : this >x : chrysaeolus.sarasinorum } } @@ -6834,8 +6834,8 @@ module sagitta { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : walkeri ->this : walkeri +>y : this +>this : this >x : samarensis.cahirinus } } @@ -6870,8 +6870,8 @@ module minutus { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : inez ->this : inez +>y : this +>this : this >x : samarensis.cahirinus } } @@ -6924,8 +6924,8 @@ module panamensis { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : linulus ->this : linulus +>y : this +>this : this >x : daubentonii.arboreus taki(): patas.uralensis { var x: patas.uralensis; () => { var y = this; }; return x; } @@ -6936,8 +6936,8 @@ module panamensis { >patas : any >uralensis : patas.uralensis >() => { var y = this; } : () => void ->y : linulus ->this : linulus +>y : this +>this : this >x : patas.uralensis fumosus(): rendalli.moojeni, lavali.beisa> { var x: rendalli.moojeni, lavali.beisa>; () => { var y = this; }; return x; } @@ -6964,8 +6964,8 @@ module panamensis { >lavali : any >beisa : lavali.beisa >() => { var y = this; } : () => void ->y : linulus ->this : linulus +>y : this +>this : this >x : rendalli.moojeni, lavali.beisa> rufinus(): macrorhinos.konganensis { var x: macrorhinos.konganensis; () => { var y = this; }; return x; } @@ -6976,8 +6976,8 @@ module panamensis { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : linulus ->this : linulus +>y : this +>this : this >x : macrorhinos.konganensis lami(): nigra.thalia { var x: nigra.thalia; () => { var y = this; }; return x; } @@ -6996,8 +6996,8 @@ module panamensis { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : linulus ->this : linulus +>y : this +>this : this >x : nigra.thalia regina(): trivirgatus.oconnelli { var x: trivirgatus.oconnelli; () => { var y = this; }; return x; } @@ -7008,8 +7008,8 @@ module panamensis { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : linulus ->this : linulus +>y : this +>this : this >x : trivirgatus.oconnelli nanilla(): dammermani.siberu { var x: dammermani.siberu; () => { var y = this; }; return x; } @@ -7028,8 +7028,8 @@ module panamensis { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : linulus ->this : linulus +>y : this +>this : this >x : dammermani.siberu enganus(): petrophilus.sodyi { var x: petrophilus.sodyi; () => { var y = this; }; return x; } @@ -7048,8 +7048,8 @@ module panamensis { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : linulus ->this : linulus +>y : this +>this : this >x : petrophilus.sodyi gomantongensis(): rionegrensis.veraecrucis> { var x: rionegrensis.veraecrucis>; () => { var y = this; }; return x; } @@ -7076,8 +7076,8 @@ module panamensis { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : linulus ->this : linulus +>y : this +>this : this >x : rionegrensis.veraecrucis> } } @@ -7105,8 +7105,8 @@ module nigra { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : dolichurus echinothrix(): Lanthanum.nitidus, argurus.oreas> { var x: Lanthanum.nitidus, argurus.oreas>; () => { var y = this; }; return x; } @@ -7133,8 +7133,8 @@ module nigra { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : Lanthanum.nitidus, argurus.oreas> garridoi(): dogramacii.koepckeae { var x: dogramacii.koepckeae; () => { var y = this; }; return x; } @@ -7145,8 +7145,8 @@ module nigra { >dogramacii : any >koepckeae : dogramacii.koepckeae >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : dogramacii.koepckeae rouxii(): nigra.gracilis, nigra.thalia> { var x: nigra.gracilis, nigra.thalia>; () => { var y = this; }; return x; } @@ -7181,8 +7181,8 @@ module nigra { >julianae : any >galapagoensis : julianae.galapagoensis >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : gracilis, thalia> aurita(): sagitta.stolzmanni { var x: sagitta.stolzmanni; () => { var y = this; }; return x; } @@ -7193,8 +7193,8 @@ module nigra { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : sagitta.stolzmanni geoffrensis(): rionegrensis.caniventer { var x: rionegrensis.caniventer; () => { var y = this; }; return x; } @@ -7205,8 +7205,8 @@ module nigra { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : rionegrensis.caniventer theresa(): macrorhinos.marmosurus, argurus.luctuosa>, nigra.dolichurus> { var x: macrorhinos.marmosurus, argurus.luctuosa>, nigra.dolichurus>; () => { var y = this; }; return x; } @@ -7249,8 +7249,8 @@ module nigra { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : macrorhinos.marmosurus, argurus.luctuosa>, dolichurus> melanocarpus(): julianae.albidens, julianae.sumatrana> { var x: julianae.albidens, julianae.sumatrana>; () => { var y = this; }; return x; } @@ -7277,8 +7277,8 @@ module nigra { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : julianae.albidens, julianae.sumatrana> dubiaquercus(): dogramacii.robustulus { var x: dogramacii.robustulus; () => { var y = this; }; return x; } @@ -7289,8 +7289,8 @@ module nigra { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : dogramacii.robustulus pectoralis(): julianae.sumatrana { var x: julianae.sumatrana; () => { var y = this; }; return x; } @@ -7301,8 +7301,8 @@ module nigra { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : julianae.sumatrana apoensis(): caurinus.megaphyllus { var x: caurinus.megaphyllus; () => { var y = this; }; return x; } @@ -7313,8 +7313,8 @@ module nigra { >caurinus : any >megaphyllus : caurinus.megaphyllus >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : caurinus.megaphyllus grisescens(): Lanthanum.jugularis { var x: Lanthanum.jugularis; () => { var y = this; }; return x; } @@ -7325,8 +7325,8 @@ module nigra { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : Lanthanum.jugularis ramirohitra(): panglima.amphibius { var x: panglima.amphibius; () => { var y = this; }; return x; } @@ -7345,8 +7345,8 @@ module nigra { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : gracilis ->this : gracilis +>y : this +>this : this >x : panglima.amphibius } } @@ -7377,8 +7377,8 @@ module samarensis { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : panamensis.linulus castanea(): argurus.netscheri, julianae.oralis> { var x: argurus.netscheri, julianae.oralis>; () => { var y = this; }; return x; } @@ -7413,8 +7413,8 @@ module samarensis { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : argurus.netscheri, julianae.oralis> chamek(): argurus.pygmaea { var x: argurus.pygmaea; () => { var y = this; }; return x; } @@ -7433,8 +7433,8 @@ module samarensis { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : argurus.pygmaea nigriceps(): lutreolus.punicus { var x: lutreolus.punicus; () => { var y = this; }; return x; } @@ -7445,8 +7445,8 @@ module samarensis { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : lutreolus.punicus lunatus(): pelurus { var x: pelurus; () => { var y = this; }; return x; } @@ -7463,8 +7463,8 @@ module samarensis { >sagitta : any >walkeri : sagitta.walkeri >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : pelurus madurae(): rionegrensis.caniventer { var x: rionegrensis.caniventer; () => { var y = this; }; return x; } @@ -7475,8 +7475,8 @@ module samarensis { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : rionegrensis.caniventer chinchilla(): macrorhinos.daphaenodon { var x: macrorhinos.daphaenodon; () => { var y = this; }; return x; } @@ -7487,8 +7487,8 @@ module samarensis { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : macrorhinos.daphaenodon eliasi(): petrophilus.rosalia { var x: petrophilus.rosalia; () => { var y = this; }; return x; } @@ -7507,8 +7507,8 @@ module samarensis { >lavali : any >beisa : lavali.beisa >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : petrophilus.rosalia proditor(): panamensis.setulosus { var x: panamensis.setulosus; () => { var y = this; }; return x; } @@ -7527,8 +7527,8 @@ module samarensis { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : panamensis.setulosus gambianus(): quasiater.wattsi> { var x: quasiater.wattsi>; () => { var y = this; }; return x; } @@ -7555,8 +7555,8 @@ module samarensis { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : quasiater.wattsi> petteri(): dogramacii.kaiseri { var x: dogramacii.kaiseri; () => { var y = this; }; return x; } @@ -7567,8 +7567,8 @@ module samarensis { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : dogramacii.kaiseri nusatenggara(): panglima.amphibius { var x: panglima.amphibius; () => { var y = this; }; return x; } @@ -7587,8 +7587,8 @@ module samarensis { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : panglima.amphibius olitor(): rionegrensis.veraecrucis { var x: rionegrensis.veraecrucis; () => { var y = this; }; return x; } @@ -7607,8 +7607,8 @@ module samarensis { >quasiater : any >bobrinskoi : quasiater.bobrinskoi >() => { var y = this; } : () => void ->y : pelurus ->this : pelurus +>y : this +>this : this >x : rionegrensis.veraecrucis } export class fuscus extends macrorhinos.daphaenodon { @@ -7635,8 +7635,8 @@ module samarensis { >dogramacii : any >aurata : dogramacii.aurata >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : nigra.gracilis badia(): julianae.sumatrana { var x: julianae.sumatrana; () => { var y = this; }; return x; } @@ -7647,8 +7647,8 @@ module samarensis { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : julianae.sumatrana prymnolopha(): sagitta.walkeri { var x: sagitta.walkeri; () => { var y = this; }; return x; } @@ -7659,8 +7659,8 @@ module samarensis { >sagitta : any >walkeri : sagitta.walkeri >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : sagitta.walkeri natalensis(): trivirgatus.falconeri { var x: trivirgatus.falconeri; () => { var y = this; }; return x; } @@ -7671,8 +7671,8 @@ module samarensis { >trivirgatus : any >falconeri : trivirgatus.falconeri >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : trivirgatus.falconeri hunteri(): julianae.durangae { var x: julianae.durangae; () => { var y = this; }; return x; } @@ -7683,8 +7683,8 @@ module samarensis { >julianae : any >durangae : julianae.durangae >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : julianae.durangae sapiens(): pallidus { var x: pallidus; () => { var y = this; }; return x; } @@ -7693,8 +7693,8 @@ module samarensis { >x : pallidus >pallidus : pallidus >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : pallidus macrocercus(): panamensis.setulosus { var x: panamensis.setulosus; () => { var y = this; }; return x; } @@ -7713,8 +7713,8 @@ module samarensis { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : panamensis.setulosus nimbae(): lutreolus.punicus { var x: lutreolus.punicus; () => { var y = this; }; return x; } @@ -7725,8 +7725,8 @@ module samarensis { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : lutreolus.punicus suricatta(): daubentonii.nigricans { var x: daubentonii.nigricans; () => { var y = this; }; return x; } @@ -7745,8 +7745,8 @@ module samarensis { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : daubentonii.nigricans jagorii(): julianae.galapagoensis { var x: julianae.galapagoensis; () => { var y = this; }; return x; } @@ -7757,8 +7757,8 @@ module samarensis { >julianae : any >galapagoensis : julianae.galapagoensis >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : julianae.galapagoensis beecrofti(): sagitta.stolzmanni { var x: sagitta.stolzmanni; () => { var y = this; }; return x; } @@ -7769,8 +7769,8 @@ module samarensis { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : sagitta.stolzmanni imaizumii(): minutus.inez, gabriellae.echinatus>, dogramacii.aurata>, lavali.otion>, macrorhinos.konganensis> { var x: minutus.inez, gabriellae.echinatus>, dogramacii.aurata>, lavali.otion>, macrorhinos.konganensis>; () => { var y = this; }; return x; } @@ -7821,8 +7821,8 @@ module samarensis { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : minutus.inez, gabriellae.echinatus>, dogramacii.aurata>, lavali.otion>, macrorhinos.konganensis> colocolo(): quasiater.bobrinskoi { var x: quasiater.bobrinskoi; () => { var y = this; }; return x; } @@ -7833,8 +7833,8 @@ module samarensis { >quasiater : any >bobrinskoi : quasiater.bobrinskoi >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : quasiater.bobrinskoi wolfi(): petrophilus.rosalia> { var x: petrophilus.rosalia>; () => { var y = this; }; return x; } @@ -7861,8 +7861,8 @@ module samarensis { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : fuscus ->this : fuscus +>y : this +>this : this >x : petrophilus.rosalia> } export class pallidus { @@ -7876,8 +7876,8 @@ module samarensis { >trivirgatus : any >falconeri : trivirgatus.falconeri >() => { var y = this; } : () => void ->y : pallidus ->this : pallidus +>y : this +>this : this >x : trivirgatus.falconeri watersi(): lavali.wilsoni { var x: lavali.wilsoni; () => { var y = this; }; return x; } @@ -7888,8 +7888,8 @@ module samarensis { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : pallidus ->this : pallidus +>y : this +>this : this >x : lavali.wilsoni glacialis(): sagitta.cinereus, quasiater.wattsi>> { var x: sagitta.cinereus, quasiater.wattsi>>; () => { var y = this; }; return x; } @@ -7932,8 +7932,8 @@ module samarensis { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : pallidus ->this : pallidus +>y : this +>this : this >x : sagitta.cinereus, quasiater.wattsi>> viaria(): chrysaeolus.sarasinorum { var x: chrysaeolus.sarasinorum; () => { var y = this; }; return x; } @@ -7952,8 +7952,8 @@ module samarensis { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : pallidus ->this : pallidus +>y : this +>this : this >x : chrysaeolus.sarasinorum } export class cahirinus { @@ -7977,8 +7977,8 @@ module samarensis { >argurus : any >peninsulae : argurus.peninsulae >() => { var y = this; } : () => void ->y : cahirinus ->this : cahirinus +>y : this +>this : this >x : nigra.caucasica flaviventer(): trivirgatus.tumidifrons> { var x: trivirgatus.tumidifrons>; () => { var y = this; }; return x; } @@ -8005,8 +8005,8 @@ module samarensis { >argurus : any >peninsulae : argurus.peninsulae >() => { var y = this; } : () => void ->y : cahirinus ->this : cahirinus +>y : this +>this : this >x : trivirgatus.tumidifrons> bottai(): lutreolus.schlegeli { var x: lutreolus.schlegeli; () => { var y = this; }; return x; } @@ -8017,8 +8017,8 @@ module samarensis { >lutreolus : any >schlegeli : lutreolus.schlegeli >() => { var y = this; } : () => void ->y : cahirinus ->this : cahirinus +>y : this +>this : this >x : lutreolus.schlegeli pinetis(): argurus.oreas { var x: argurus.oreas; () => { var y = this; }; return x; } @@ -8029,8 +8029,8 @@ module samarensis { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : cahirinus ->this : cahirinus +>y : this +>this : this >x : argurus.oreas saussurei(): rendalli.crenulata, argurus.netscheri, julianae.oralis>> { var x: rendalli.crenulata, argurus.netscheri, julianae.oralis>>; () => { var y = this; }; return x; } @@ -8081,8 +8081,8 @@ module samarensis { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : cahirinus ->this : cahirinus +>y : this +>this : this >x : rendalli.crenulata, argurus.netscheri, julianae.oralis>> } } @@ -8113,8 +8113,8 @@ module sagitta { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : leptoceros ->this : leptoceros +>y : this +>this : this >x : rionegrensis.caniventer hoplomyoides(): panglima.fundatus, nigra.gracilis> { var x: panglima.fundatus, nigra.gracilis>; () => { var y = this; }; return x; } @@ -8149,8 +8149,8 @@ module sagitta { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : leptoceros ->this : leptoceros +>y : this +>this : this >x : panglima.fundatus, nigra.gracilis> gratiosus(): lavali.lepturus { var x: lavali.lepturus; () => { var y = this; }; return x; } @@ -8161,8 +8161,8 @@ module sagitta { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : leptoceros ->this : leptoceros +>y : this +>this : this >x : lavali.lepturus rex(): lavali.wilsoni { var x: lavali.wilsoni; () => { var y = this; }; return x; } @@ -8173,8 +8173,8 @@ module sagitta { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : leptoceros ->this : leptoceros +>y : this +>this : this >x : lavali.wilsoni bolami(): trivirgatus.tumidifrons { var x: trivirgatus.tumidifrons; () => { var y = this; }; return x; } @@ -8193,8 +8193,8 @@ module sagitta { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : leptoceros ->this : leptoceros +>y : this +>this : this >x : trivirgatus.tumidifrons } } @@ -8217,8 +8217,8 @@ module daubentonii { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : nigricans ->this : nigricans +>y : this +>this : this >x : dogramacii.robustulus } } @@ -8254,8 +8254,8 @@ module argurus { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : pygmaea ->this : pygmaea +>y : this +>this : this >x : gabriellae.echinatus capucinus(): rendalli.zuluensis { var x: rendalli.zuluensis; () => { var y = this; }; return x; } @@ -8266,8 +8266,8 @@ module argurus { >rendalli : any >zuluensis : rendalli.zuluensis >() => { var y = this; } : () => void ->y : pygmaea ->this : pygmaea +>y : this +>this : this >x : rendalli.zuluensis cuvieri(): rionegrensis.caniventer { var x: rionegrensis.caniventer; () => { var y = this; }; return x; } @@ -8278,8 +8278,8 @@ module argurus { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : pygmaea ->this : pygmaea +>y : this +>this : this >x : rionegrensis.caniventer } } @@ -8302,8 +8302,8 @@ module chrysaeolus { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : sarasinorum ->this : sarasinorum +>y : this +>this : this >x : samarensis.pallidus hinpoon(): nigra.caucasica { var x: nigra.caucasica; () => { var y = this; }; return x; } @@ -8322,8 +8322,8 @@ module chrysaeolus { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : sarasinorum ->this : sarasinorum +>y : this +>this : this >x : nigra.caucasica kandti(): quasiater.wattsi { var x: quasiater.wattsi; () => { var y = this; }; return x; } @@ -8342,8 +8342,8 @@ module chrysaeolus { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : sarasinorum ->this : sarasinorum +>y : this +>this : this >x : quasiater.wattsi cynosuros(): dammermani.melanops { var x: dammermani.melanops; () => { var y = this; }; return x; } @@ -8354,8 +8354,8 @@ module chrysaeolus { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : sarasinorum ->this : sarasinorum +>y : this +>this : this >x : dammermani.melanops Germanium(): lavali.beisa { var x: lavali.beisa; () => { var y = this; }; return x; } @@ -8366,8 +8366,8 @@ module chrysaeolus { >lavali : any >beisa : lavali.beisa >() => { var y = this; } : () => void ->y : sarasinorum ->this : sarasinorum +>y : this +>this : this >x : lavali.beisa Ununoctium(): nigra.gracilis { var x: nigra.gracilis; () => { var y = this; }; return x; } @@ -8386,8 +8386,8 @@ module chrysaeolus { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : sarasinorum ->this : sarasinorum +>y : this +>this : this >x : nigra.gracilis princeps(): minutus.portoricensis { var x: minutus.portoricensis; () => { var y = this; }; return x; } @@ -8398,8 +8398,8 @@ module chrysaeolus { >minutus : any >portoricensis : minutus.portoricensis >() => { var y = this; } : () => void ->y : sarasinorum ->this : sarasinorum +>y : this +>this : this >x : minutus.portoricensis } } @@ -8427,8 +8427,8 @@ module argurus { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : wetmorei ->this : wetmorei +>y : this +>this : this >x : petrophilus.rosalia ochraventer(): sagitta.walkeri { var x: sagitta.walkeri; () => { var y = this; }; return x; } @@ -8439,8 +8439,8 @@ module argurus { >sagitta : any >walkeri : sagitta.walkeri >() => { var y = this; } : () => void ->y : wetmorei ->this : wetmorei +>y : this +>this : this >x : sagitta.walkeri tephromelas(): Lanthanum.jugularis { var x: Lanthanum.jugularis; () => { var y = this; }; return x; } @@ -8451,8 +8451,8 @@ module argurus { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : wetmorei ->this : wetmorei +>y : this +>this : this >x : Lanthanum.jugularis cracens(): argurus.gilbertii { var x: argurus.gilbertii; () => { var y = this; }; return x; } @@ -8471,8 +8471,8 @@ module argurus { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : wetmorei ->this : wetmorei +>y : this +>this : this >x : gilbertii jamaicensis(): nigra.thalia> { var x: nigra.thalia>; () => { var y = this; }; return x; } @@ -8499,8 +8499,8 @@ module argurus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : wetmorei ->this : wetmorei +>y : this +>this : this >x : nigra.thalia> gymnocaudus(): dogramacii.aurata { var x: dogramacii.aurata; () => { var y = this; }; return x; } @@ -8511,8 +8511,8 @@ module argurus { >dogramacii : any >aurata : dogramacii.aurata >() => { var y = this; } : () => void ->y : wetmorei ->this : wetmorei +>y : this +>this : this >x : dogramacii.aurata mayori(): sagitta.stolzmanni { var x: sagitta.stolzmanni; () => { var y = this; }; return x; } @@ -8523,8 +8523,8 @@ module argurus { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : wetmorei ->this : wetmorei +>y : this +>this : this >x : sagitta.stolzmanni } } @@ -8545,8 +8545,8 @@ module argurus { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : oreas ->this : oreas +>y : this +>this : this >x : lavali.xanthognathus paniscus(): ruatanica.Praseodymium { var x: ruatanica.Praseodymium; () => { var y = this; }; return x; } @@ -8565,8 +8565,8 @@ module argurus { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : oreas ->this : oreas +>y : this +>this : this >x : ruatanica.Praseodymium fagani(): trivirgatus.oconnelli { var x: trivirgatus.oconnelli; () => { var y = this; }; return x; } @@ -8577,8 +8577,8 @@ module argurus { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : oreas ->this : oreas +>y : this +>this : this >x : trivirgatus.oconnelli papuanus(): panglima.fundatus { var x: panglima.fundatus; () => { var y = this; }; return x; } @@ -8597,8 +8597,8 @@ module argurus { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : oreas ->this : oreas +>y : this +>this : this >x : panglima.fundatus timidus(): dammermani.melanops { var x: dammermani.melanops; () => { var y = this; }; return x; } @@ -8609,8 +8609,8 @@ module argurus { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : oreas ->this : oreas +>y : this +>this : this >x : dammermani.melanops nghetinhensis(): gabriellae.klossii { var x: gabriellae.klossii; () => { var y = this; }; return x; } @@ -8629,8 +8629,8 @@ module argurus { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : oreas ->this : oreas +>y : this +>this : this >x : gabriellae.klossii barbei(): samarensis.cahirinus { var x: samarensis.cahirinus; () => { var y = this; }; return x; } @@ -8649,8 +8649,8 @@ module argurus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : oreas ->this : oreas +>y : this +>this : this >x : samarensis.cahirinus univittatus(): argurus.peninsulae { var x: argurus.peninsulae; () => { var y = this; }; return x; } @@ -8661,8 +8661,8 @@ module argurus { >argurus : any >peninsulae : peninsulae >() => { var y = this; } : () => void ->y : oreas ->this : oreas +>y : this +>this : this >x : peninsulae } } @@ -8698,8 +8698,8 @@ module daubentonii { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : arboreus ->this : arboreus +>y : this +>this : this >x : rendalli.crenulata, lavali.wilsoni> moreni(): panglima.abidi { var x: panglima.abidi; () => { var y = this; }; return x; } @@ -8718,8 +8718,8 @@ module daubentonii { >dogramacii : any >koepckeae : dogramacii.koepckeae >() => { var y = this; } : () => void ->y : arboreus ->this : arboreus +>y : this +>this : this >x : panglima.abidi hypoleucos(): nigra.gracilis { var x: nigra.gracilis; () => { var y = this; }; return x; } @@ -8738,8 +8738,8 @@ module daubentonii { >argurus : any >germaini : argurus.germaini >() => { var y = this; } : () => void ->y : arboreus ->this : arboreus +>y : this +>this : this >x : nigra.gracilis paedulcus(): minutus.portoricensis { var x: minutus.portoricensis; () => { var y = this; }; return x; } @@ -8750,8 +8750,8 @@ module daubentonii { >minutus : any >portoricensis : minutus.portoricensis >() => { var y = this; } : () => void ->y : arboreus ->this : arboreus +>y : this +>this : this >x : minutus.portoricensis pucheranii(): samarensis.fuscus { var x: samarensis.fuscus; () => { var y = this; }; return x; } @@ -8770,8 +8770,8 @@ module daubentonii { >caurinus : any >megaphyllus : caurinus.megaphyllus >() => { var y = this; } : () => void ->y : arboreus ->this : arboreus +>y : this +>this : this >x : samarensis.fuscus stella(): julianae.oralis { var x: julianae.oralis; () => { var y = this; }; return x; } @@ -8790,8 +8790,8 @@ module daubentonii { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : arboreus ->this : arboreus +>y : this +>this : this >x : julianae.oralis brasiliensis(): imperfecta.subspinosus { var x: imperfecta.subspinosus; () => { var y = this; }; return x; } @@ -8802,8 +8802,8 @@ module daubentonii { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : arboreus ->this : arboreus +>y : this +>this : this >x : imperfecta.subspinosus brevicaudata(): trivirgatus.oconnelli { var x: trivirgatus.oconnelli; () => { var y = this; }; return x; } @@ -8814,8 +8814,8 @@ module daubentonii { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : arboreus ->this : arboreus +>y : this +>this : this >x : trivirgatus.oconnelli vitticollis(): dogramacii.koepckeae { var x: dogramacii.koepckeae; () => { var y = this; }; return x; } @@ -8826,8 +8826,8 @@ module daubentonii { >dogramacii : any >koepckeae : dogramacii.koepckeae >() => { var y = this; } : () => void ->y : arboreus ->this : arboreus +>y : this +>this : this >x : dogramacii.koepckeae huangensis(): caurinus.psilurus { var x: caurinus.psilurus; () => { var y = this; }; return x; } @@ -8838,8 +8838,8 @@ module daubentonii { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : arboreus ->this : arboreus +>y : this +>this : this >x : caurinus.psilurus cameroni(): petrophilus.rosalia, imperfecta.ciliolabrum>, caurinus.psilurus> { var x: petrophilus.rosalia, imperfecta.ciliolabrum>, caurinus.psilurus>; () => { var y = this; }; return x; } @@ -8882,8 +8882,8 @@ module daubentonii { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : arboreus ->this : arboreus +>y : this +>this : this >x : petrophilus.rosalia, imperfecta.ciliolabrum>, caurinus.psilurus> tianshanica(): howi.marcanoi { var x: howi.marcanoi; () => { var y = this; }; return x; } @@ -8894,8 +8894,8 @@ module daubentonii { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : arboreus ->this : arboreus +>y : this +>this : this >x : howi.marcanoi } } @@ -8921,8 +8921,8 @@ module patas { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : Lanthanum.nitidus pyrrhinus(): lavali.beisa { var x: lavali.beisa; () => { var y = this; }; return x; } @@ -8933,8 +8933,8 @@ module patas { >lavali : any >beisa : lavali.beisa >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : lavali.beisa insulans(): Lanthanum.jugularis { var x: Lanthanum.jugularis; () => { var y = this; }; return x; } @@ -8945,8 +8945,8 @@ module patas { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : Lanthanum.jugularis nigricauda(): caurinus.johorensis, Lanthanum.jugularis> { var x: caurinus.johorensis, Lanthanum.jugularis>; () => { var y = this; }; return x; } @@ -8973,8 +8973,8 @@ module patas { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : caurinus.johorensis, Lanthanum.jugularis> muricauda(): panglima.fundatus> { var x: panglima.fundatus>; () => { var y = this; }; return x; } @@ -9001,8 +9001,8 @@ module patas { >julianae : any >acariensis : julianae.acariensis >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : panglima.fundatus> albicaudus(): sagitta.stolzmanni { var x: sagitta.stolzmanni; () => { var y = this; }; return x; } @@ -9013,8 +9013,8 @@ module patas { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : sagitta.stolzmanni fallax(): ruatanica.hector { var x: ruatanica.hector; () => { var y = this; }; return x; } @@ -9033,8 +9033,8 @@ module patas { >gabriellae : any >amicus : gabriellae.amicus >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : ruatanica.hector attenuata(): macrorhinos.marmosurus> { var x: macrorhinos.marmosurus>; () => { var y = this; }; return x; } @@ -9061,8 +9061,8 @@ module patas { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : macrorhinos.marmosurus> megalura(): howi.marcanoi { var x: howi.marcanoi; () => { var y = this; }; return x; } @@ -9073,8 +9073,8 @@ module patas { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : howi.marcanoi neblina(): samarensis.pelurus { var x: samarensis.pelurus; () => { var y = this; }; return x; } @@ -9093,8 +9093,8 @@ module patas { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : samarensis.pelurus citellus(): daubentonii.arboreus { var x: daubentonii.arboreus; () => { var y = this; }; return x; } @@ -9113,8 +9113,8 @@ module patas { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : daubentonii.arboreus tanezumi(): imperfecta.lasiurus { var x: imperfecta.lasiurus; () => { var y = this; }; return x; } @@ -9133,8 +9133,8 @@ module patas { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : imperfecta.lasiurus albiventer(): rendalli.crenulata { var x: rendalli.crenulata; () => { var y = this; }; return x; } @@ -9153,8 +9153,8 @@ module patas { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : uralensis ->this : uralensis +>y : this +>this : this >x : rendalli.crenulata } } @@ -9191,8 +9191,8 @@ module provocax { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : melanoleuca ->this : melanoleuca +>y : this +>this : this >x : macrorhinos.marmosurus, lutreolus.foina> baeri(): imperfecta.lasiurus { var x: imperfecta.lasiurus; () => { var y = this; }; return x; } @@ -9211,8 +9211,8 @@ module provocax { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : melanoleuca ->this : melanoleuca +>y : this +>this : this >x : imperfecta.lasiurus } } @@ -9248,8 +9248,8 @@ module sagitta { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : sicarius ->this : sicarius +>y : this +>this : this >x : samarensis.cahirinus, dogramacii.robustulus> simulator(): macrorhinos.marmosurus, macrorhinos.marmosurus, gabriellae.echinatus>, sagitta.stolzmanni>> { var x: macrorhinos.marmosurus, macrorhinos.marmosurus, gabriellae.echinatus>, sagitta.stolzmanni>>; () => { var y = this; }; return x; } @@ -9300,8 +9300,8 @@ module sagitta { >sagitta : any >stolzmanni : stolzmanni >() => { var y = this; } : () => void ->y : sicarius ->this : sicarius +>y : this +>this : this >x : macrorhinos.marmosurus, macrorhinos.marmosurus, gabriellae.echinatus>, stolzmanni>> } } @@ -9322,8 +9322,8 @@ module howi { >Lanthanum : any >megalonyx : Lanthanum.megalonyx >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : Lanthanum.megalonyx dudui(): lutreolus.punicus { var x: lutreolus.punicus; () => { var y = this; }; return x; } @@ -9334,8 +9334,8 @@ module howi { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : lutreolus.punicus leander(): daubentonii.nesiotes { var x: daubentonii.nesiotes; () => { var y = this; }; return x; } @@ -9354,8 +9354,8 @@ module howi { >minutus : any >portoricensis : minutus.portoricensis >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : daubentonii.nesiotes martinsi(): dogramacii.aurata { var x: dogramacii.aurata; () => { var y = this; }; return x; } @@ -9366,8 +9366,8 @@ module howi { >dogramacii : any >aurata : dogramacii.aurata >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : dogramacii.aurata beatrix(): imperfecta.ciliolabrum, gabriellae.echinatus>, dogramacii.aurata>, imperfecta.ciliolabrum>> { var x: imperfecta.ciliolabrum, gabriellae.echinatus>, dogramacii.aurata>, imperfecta.ciliolabrum>>; () => { var y = this; }; return x; } @@ -9426,8 +9426,8 @@ module howi { >lavali : any >beisa : lavali.beisa >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : imperfecta.ciliolabrum, gabriellae.echinatus>, dogramacii.aurata>, imperfecta.ciliolabrum>> griseoventer(): argurus.oreas { var x: argurus.oreas; () => { var y = this; }; return x; } @@ -9438,8 +9438,8 @@ module howi { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : argurus.oreas zerda(): quasiater.wattsi, howi.coludo>> { var x: quasiater.wattsi, howi.coludo>>; () => { var y = this; }; return x; } @@ -9482,8 +9482,8 @@ module howi { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : quasiater.wattsi, coludo>> yucatanicus(): julianae.nudicaudus { var x: julianae.nudicaudus; () => { var y = this; }; return x; } @@ -9494,8 +9494,8 @@ module howi { >julianae : any >nudicaudus : julianae.nudicaudus >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : julianae.nudicaudus nigrita(): argurus.peninsulae { var x: argurus.peninsulae; () => { var y = this; }; return x; } @@ -9506,8 +9506,8 @@ module howi { >argurus : any >peninsulae : argurus.peninsulae >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : argurus.peninsulae jouvenetae(): argurus.dauricus { var x: argurus.dauricus; () => { var y = this; }; return x; } @@ -9526,8 +9526,8 @@ module howi { >julianae : any >durangae : julianae.durangae >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : argurus.dauricus indefessus(): sagitta.walkeri { var x: sagitta.walkeri; () => { var y = this; }; return x; } @@ -9538,8 +9538,8 @@ module howi { >sagitta : any >walkeri : sagitta.walkeri >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : sagitta.walkeri vuquangensis(): macrorhinos.daphaenodon { var x: macrorhinos.daphaenodon; () => { var y = this; }; return x; } @@ -9550,8 +9550,8 @@ module howi { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : macrorhinos.daphaenodon Zirconium(): lavali.thaeleri { var x: lavali.thaeleri; () => { var y = this; }; return x; } @@ -9562,8 +9562,8 @@ module howi { >lavali : any >thaeleri : lavali.thaeleri >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : lavali.thaeleri hyaena(): julianae.oralis { var x: julianae.oralis; () => { var y = this; }; return x; } @@ -9582,8 +9582,8 @@ module howi { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : marcanoi ->this : marcanoi +>y : this +>this : this >x : julianae.oralis } } @@ -9603,8 +9603,8 @@ module argurus { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : gilbertii ->this : gilbertii +>y : this +>this : this >x : lavali.lepturus poecilops(): julianae.steerii { var x: julianae.steerii; () => { var y = this; }; return x; } @@ -9615,8 +9615,8 @@ module argurus { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : gilbertii ->this : gilbertii +>y : this +>this : this >x : julianae.steerii sondaicus(): samarensis.fuscus { var x: samarensis.fuscus; () => { var y = this; }; return x; } @@ -9635,8 +9635,8 @@ module argurus { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : gilbertii ->this : gilbertii +>y : this +>this : this >x : samarensis.fuscus auriventer(): petrophilus.rosalia { var x: petrophilus.rosalia; () => { var y = this; }; return x; } @@ -9655,8 +9655,8 @@ module argurus { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : gilbertii ->this : gilbertii +>y : this +>this : this >x : petrophilus.rosalia cherriei(): ruatanica.Praseodymium { var x: ruatanica.Praseodymium; () => { var y = this; }; return x; } @@ -9675,8 +9675,8 @@ module argurus { >argurus : any >oreas : oreas >() => { var y = this; } : () => void ->y : gilbertii ->this : gilbertii +>y : this +>this : this >x : ruatanica.Praseodymium lindberghi(): minutus.inez { var x: minutus.inez; () => { var y = this; }; return x; } @@ -9695,8 +9695,8 @@ module argurus { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : gilbertii ->this : gilbertii +>y : this +>this : this >x : minutus.inez pipistrellus(): quasiater.carolinensis { var x: quasiater.carolinensis; () => { var y = this; }; return x; } @@ -9707,8 +9707,8 @@ module argurus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : gilbertii ->this : gilbertii +>y : this +>this : this >x : quasiater.carolinensis paranus(): lutreolus.punicus { var x: lutreolus.punicus; () => { var y = this; }; return x; } @@ -9719,8 +9719,8 @@ module argurus { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : gilbertii ->this : gilbertii +>y : this +>this : this >x : lutreolus.punicus dubosti(): nigra.thalia { var x: nigra.thalia; () => { var y = this; }; return x; } @@ -9739,8 +9739,8 @@ module argurus { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : gilbertii ->this : gilbertii +>y : this +>this : this >x : nigra.thalia opossum(): nigra.dolichurus { var x: nigra.dolichurus; () => { var y = this; }; return x; } @@ -9759,8 +9759,8 @@ module argurus { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : gilbertii ->this : gilbertii +>y : this +>this : this >x : nigra.dolichurus oreopolus(): minutus.portoricensis { var x: minutus.portoricensis; () => { var y = this; }; return x; } @@ -9771,8 +9771,8 @@ module argurus { >minutus : any >portoricensis : minutus.portoricensis >() => { var y = this; } : () => void ->y : gilbertii ->this : gilbertii +>y : this +>this : this >x : minutus.portoricensis amurensis(): daubentonii.arboreus { var x: daubentonii.arboreus; () => { var y = this; }; return x; } @@ -9791,8 +9791,8 @@ module argurus { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : gilbertii ->this : gilbertii +>y : this +>this : this >x : daubentonii.arboreus } } @@ -9825,8 +9825,8 @@ module lutreolus { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : gabriellae.klossii lar(): caurinus.mahaganus { var x: caurinus.mahaganus; () => { var y = this; }; return x; } @@ -9845,8 +9845,8 @@ module lutreolus { >lavali : any >otion : lavali.otion >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : caurinus.mahaganus erica(): dogramacii.koepckeae { var x: dogramacii.koepckeae; () => { var y = this; }; return x; } @@ -9857,8 +9857,8 @@ module lutreolus { >dogramacii : any >koepckeae : dogramacii.koepckeae >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : dogramacii.koepckeae trichura(): macrorhinos.konganensis { var x: macrorhinos.konganensis; () => { var y = this; }; return x; } @@ -9869,8 +9869,8 @@ module lutreolus { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : macrorhinos.konganensis lemniscatus(): panglima.fundatus { var x: panglima.fundatus; () => { var y = this; }; return x; } @@ -9889,8 +9889,8 @@ module lutreolus { >lutreolus : any >foina : foina >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : panglima.fundatus aspalax(): panamensis.linulus { var x: panamensis.linulus; () => { var y = this; }; return x; } @@ -9909,8 +9909,8 @@ module lutreolus { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : panamensis.linulus marshalli(): julianae.nudicaudus { var x: julianae.nudicaudus; () => { var y = this; }; return x; } @@ -9921,8 +9921,8 @@ module lutreolus { >julianae : any >nudicaudus : julianae.nudicaudus >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : julianae.nudicaudus Zinc(): julianae.galapagoensis { var x: julianae.galapagoensis; () => { var y = this; }; return x; } @@ -9933,8 +9933,8 @@ module lutreolus { >julianae : any >galapagoensis : julianae.galapagoensis >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : julianae.galapagoensis monochromos(): howi.coludo { var x: howi.coludo; () => { var y = this; }; return x; } @@ -9953,8 +9953,8 @@ module lutreolus { >lutreolus : any >punicus : punicus >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : howi.coludo purinus(): ruatanica.hector { var x: ruatanica.hector; () => { var y = this; }; return x; } @@ -9973,8 +9973,8 @@ module lutreolus { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : ruatanica.hector ischyrus(): lavali.lepturus { var x: lavali.lepturus; () => { var y = this; }; return x; } @@ -9985,8 +9985,8 @@ module lutreolus { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : lavali.lepturus tenuis(): macrorhinos.daphaenodon { var x: macrorhinos.daphaenodon; () => { var y = this; }; return x; } @@ -9997,8 +9997,8 @@ module lutreolus { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : macrorhinos.daphaenodon Helium(): julianae.acariensis { var x: julianae.acariensis; () => { var y = this; }; return x; } @@ -10009,8 +10009,8 @@ module lutreolus { >julianae : any >acariensis : julianae.acariensis >() => { var y = this; } : () => void ->y : punicus ->this : punicus +>y : this +>this : this >x : julianae.acariensis } } @@ -10028,8 +10028,8 @@ module macrorhinos { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : daphaenodon ->this : daphaenodon +>y : this +>this : this >x : julianae.sumatrana othus(): howi.coludo { var x: howi.coludo; () => { var y = this; }; return x; } @@ -10048,8 +10048,8 @@ module macrorhinos { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : daphaenodon ->this : daphaenodon +>y : this +>this : this >x : howi.coludo hammondi(): julianae.gerbillus, gabriellae.echinatus>, dogramacii.aurata>, lavali.otion> { var x: julianae.gerbillus, gabriellae.echinatus>, dogramacii.aurata>, lavali.otion>; () => { var y = this; }; return x; } @@ -10092,8 +10092,8 @@ module macrorhinos { >lavali : any >otion : lavali.otion >() => { var y = this; } : () => void ->y : daphaenodon ->this : daphaenodon +>y : this +>this : this >x : julianae.gerbillus, gabriellae.echinatus>, dogramacii.aurata>, lavali.otion> aureocollaris(): quasiater.carolinensis { var x: quasiater.carolinensis; () => { var y = this; }; return x; } @@ -10104,8 +10104,8 @@ module macrorhinos { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : daphaenodon ->this : daphaenodon +>y : this +>this : this >x : quasiater.carolinensis flavipes(): petrophilus.minutilla { var x: petrophilus.minutilla; () => { var y = this; }; return x; } @@ -10116,8 +10116,8 @@ module macrorhinos { >petrophilus : any >minutilla : petrophilus.minutilla >() => { var y = this; } : () => void ->y : daphaenodon ->this : daphaenodon +>y : this +>this : this >x : petrophilus.minutilla callosus(): trivirgatus.lotor { var x: trivirgatus.lotor; () => { var y = this; }; return x; } @@ -10136,8 +10136,8 @@ module macrorhinos { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : daphaenodon ->this : daphaenodon +>y : this +>this : this >x : trivirgatus.lotor } } @@ -10173,8 +10173,8 @@ module sagitta { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : cinereus ->this : cinereus +>y : this +>this : this >x : rendalli.crenulata> microps(): daubentonii.nigricans> { var x: daubentonii.nigricans>; () => { var y = this; }; return x; } @@ -10201,8 +10201,8 @@ module sagitta { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : cinereus ->this : cinereus +>y : this +>this : this >x : daubentonii.nigricans> guaporensis(): daubentonii.arboreus { var x: daubentonii.arboreus; () => { var y = this; }; return x; } @@ -10221,8 +10221,8 @@ module sagitta { >argurus : any >germaini : argurus.germaini >() => { var y = this; } : () => void ->y : cinereus ->this : cinereus +>y : this +>this : this >x : daubentonii.arboreus tonkeana(): panglima.fundatus { var x: panglima.fundatus; () => { var y = this; }; return x; } @@ -10241,8 +10241,8 @@ module sagitta { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : cinereus ->this : cinereus +>y : this +>this : this >x : panglima.fundatus montensis(): dammermani.siberu { var x: dammermani.siberu; () => { var y = this; }; return x; } @@ -10261,8 +10261,8 @@ module sagitta { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : cinereus ->this : cinereus +>y : this +>this : this >x : dammermani.siberu sphinx(): minutus.portoricensis { var x: minutus.portoricensis; () => { var y = this; }; return x; } @@ -10273,8 +10273,8 @@ module sagitta { >minutus : any >portoricensis : minutus.portoricensis >() => { var y = this; } : () => void ->y : cinereus ->this : cinereus +>y : this +>this : this >x : minutus.portoricensis glis(): argurus.wetmorei { var x: argurus.wetmorei; () => { var y = this; }; return x; } @@ -10293,8 +10293,8 @@ module sagitta { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : cinereus ->this : cinereus +>y : this +>this : this >x : argurus.wetmorei dorsalis(): petrophilus.sodyi { var x: petrophilus.sodyi; () => { var y = this; }; return x; } @@ -10313,8 +10313,8 @@ module sagitta { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : cinereus ->this : cinereus +>y : this +>this : this >x : petrophilus.sodyi fimbriatus(): provocax.melanoleuca { var x: provocax.melanoleuca; () => { var y = this; }; return x; } @@ -10325,8 +10325,8 @@ module sagitta { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : cinereus ->this : cinereus +>y : this +>this : this >x : provocax.melanoleuca sara(): nigra.gracilis { var x: nigra.gracilis; () => { var y = this; }; return x; } @@ -10345,8 +10345,8 @@ module sagitta { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : cinereus ->this : cinereus +>y : this +>this : this >x : nigra.gracilis epimelas(): sagitta.stolzmanni { var x: sagitta.stolzmanni; () => { var y = this; }; return x; } @@ -10357,8 +10357,8 @@ module sagitta { >sagitta : any >stolzmanni : stolzmanni >() => { var y = this; } : () => void ->y : cinereus ->this : cinereus +>y : this +>this : this >x : stolzmanni pittieri(): samarensis.fuscus { var x: samarensis.fuscus; () => { var y = this; }; return x; } @@ -10377,8 +10377,8 @@ module sagitta { >sagitta : any >stolzmanni : stolzmanni >() => { var y = this; } : () => void ->y : cinereus ->this : cinereus +>y : this +>this : this >x : samarensis.fuscus } } @@ -10417,8 +10417,8 @@ module gabriellae { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : amicus ->this : amicus +>y : this +>this : this >x : argurus.luctuosa phaeura(): panglima.abidi { var x: panglima.abidi; () => { var y = this; }; return x; } @@ -10437,8 +10437,8 @@ module gabriellae { >argurus : any >peninsulae : argurus.peninsulae >() => { var y = this; } : () => void ->y : amicus ->this : amicus +>y : this +>this : this >x : panglima.abidi voratus(): lavali.thaeleri { var x: lavali.thaeleri; () => { var y = this; }; return x; } @@ -10449,8 +10449,8 @@ module gabriellae { >lavali : any >thaeleri : lavali.thaeleri >() => { var y = this; } : () => void ->y : amicus ->this : amicus +>y : this +>this : this >x : lavali.thaeleri satarae(): trivirgatus.lotor { var x: trivirgatus.lotor; () => { var y = this; }; return x; } @@ -10469,8 +10469,8 @@ module gabriellae { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : amicus ->this : amicus +>y : this +>this : this >x : trivirgatus.lotor hooperi(): caurinus.psilurus { var x: caurinus.psilurus; () => { var y = this; }; return x; } @@ -10481,8 +10481,8 @@ module gabriellae { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : amicus ->this : amicus +>y : this +>this : this >x : caurinus.psilurus perrensi(): rendalli.crenulata { var x: rendalli.crenulata; () => { var y = this; }; return x; } @@ -10501,8 +10501,8 @@ module gabriellae { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : amicus ->this : amicus +>y : this +>this : this >x : rendalli.crenulata ridei(): ruatanica.hector> { var x: ruatanica.hector>; () => { var y = this; }; return x; } @@ -10529,8 +10529,8 @@ module gabriellae { >sagitta : any >walkeri : sagitta.walkeri >() => { var y = this; } : () => void ->y : amicus ->this : amicus +>y : this +>this : this >x : ruatanica.hector> audeberti(): daubentonii.arboreus { var x: daubentonii.arboreus; () => { var y = this; }; return x; } @@ -10549,8 +10549,8 @@ module gabriellae { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : amicus ->this : amicus +>y : this +>this : this >x : daubentonii.arboreus Lutetium(): macrorhinos.marmosurus { var x: macrorhinos.marmosurus; () => { var y = this; }; return x; } @@ -10569,8 +10569,8 @@ module gabriellae { >lavali : any >thaeleri : lavali.thaeleri >() => { var y = this; } : () => void ->y : amicus ->this : amicus +>y : this +>this : this >x : macrorhinos.marmosurus atrox(): samarensis.fuscus, dogramacii.koepckeae> { var x: samarensis.fuscus, dogramacii.koepckeae>; () => { var y = this; }; return x; } @@ -10597,8 +10597,8 @@ module gabriellae { >dogramacii : any >koepckeae : dogramacii.koepckeae >() => { var y = this; } : () => void ->y : amicus ->this : amicus +>y : this +>this : this >x : samarensis.fuscus, dogramacii.koepckeae> } export class echinatus { @@ -10628,8 +10628,8 @@ module gabriellae { >patas : any >uralensis : patas.uralensis >() => { var y = this; } : () => void ->y : echinatus ->this : echinatus +>y : this +>this : this >x : howi.coludo> } } @@ -10649,8 +10649,8 @@ module imperfecta { >lavali : any >thaeleri : lavali.thaeleri >() => { var y = this; } : () => void ->y : lasiurus ->this : lasiurus +>y : this +>this : this >x : lavali.thaeleri fulvus(): argurus.germaini { var x: argurus.germaini; () => { var y = this; }; return x; } @@ -10661,8 +10661,8 @@ module imperfecta { >argurus : any >germaini : argurus.germaini >() => { var y = this; } : () => void ->y : lasiurus ->this : lasiurus +>y : this +>this : this >x : argurus.germaini paranaensis(): dogramacii.koepckeae { var x: dogramacii.koepckeae; () => { var y = this; }; return x; } @@ -10673,8 +10673,8 @@ module imperfecta { >dogramacii : any >koepckeae : dogramacii.koepckeae >() => { var y = this; } : () => void ->y : lasiurus ->this : lasiurus +>y : this +>this : this >x : dogramacii.koepckeae didactylus(): panglima.abidi> { var x: panglima.abidi>; () => { var y = this; }; return x; } @@ -10701,8 +10701,8 @@ module imperfecta { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : lasiurus ->this : lasiurus +>y : this +>this : this >x : panglima.abidi> schreibersii(): nigra.gracilis { var x: nigra.gracilis; () => { var y = this; }; return x; } @@ -10721,8 +10721,8 @@ module imperfecta { >ruatanica : any >americanus : ruatanica.americanus >() => { var y = this; } : () => void ->y : lasiurus ->this : lasiurus +>y : this +>this : this >x : nigra.gracilis orii(): dogramacii.kaiseri { var x: dogramacii.kaiseri; () => { var y = this; }; return x; } @@ -10733,8 +10733,8 @@ module imperfecta { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : lasiurus ->this : lasiurus +>y : this +>this : this >x : dogramacii.kaiseri } export class subspinosus { @@ -10748,8 +10748,8 @@ module imperfecta { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : subspinosus ->this : subspinosus +>y : this +>this : this >x : macrorhinos.konganensis Gadolinium(): nigra.caucasica { var x: nigra.caucasica; () => { var y = this; }; return x; } @@ -10768,8 +10768,8 @@ module imperfecta { >patas : any >uralensis : patas.uralensis >() => { var y = this; } : () => void ->y : subspinosus ->this : subspinosus +>y : this +>this : this >x : nigra.caucasica oasicus(): caurinus.johorensis> { var x: caurinus.johorensis>; () => { var y = this; }; return x; } @@ -10796,8 +10796,8 @@ module imperfecta { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : subspinosus ->this : subspinosus +>y : this +>this : this >x : caurinus.johorensis> paterculus(): lutreolus.punicus { var x: lutreolus.punicus; () => { var y = this; }; return x; } @@ -10808,8 +10808,8 @@ module imperfecta { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : subspinosus ->this : subspinosus +>y : this +>this : this >x : lutreolus.punicus punctata(): lavali.thaeleri { var x: lavali.thaeleri; () => { var y = this; }; return x; } @@ -10820,8 +10820,8 @@ module imperfecta { >lavali : any >thaeleri : lavali.thaeleri >() => { var y = this; } : () => void ->y : subspinosus ->this : subspinosus +>y : this +>this : this >x : lavali.thaeleri invictus(): sagitta.stolzmanni { var x: sagitta.stolzmanni; () => { var y = this; }; return x; } @@ -10832,8 +10832,8 @@ module imperfecta { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : subspinosus ->this : subspinosus +>y : this +>this : this >x : sagitta.stolzmanni stangeri(): petrophilus.minutilla { var x: petrophilus.minutilla; () => { var y = this; }; return x; } @@ -10844,8 +10844,8 @@ module imperfecta { >petrophilus : any >minutilla : petrophilus.minutilla >() => { var y = this; } : () => void ->y : subspinosus ->this : subspinosus +>y : this +>this : this >x : petrophilus.minutilla siskiyou(): minutus.inez { var x: minutus.inez; () => { var y = this; }; return x; } @@ -10864,8 +10864,8 @@ module imperfecta { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : subspinosus ->this : subspinosus +>y : this +>this : this >x : minutus.inez welwitschii(): rionegrensis.caniventer { var x: rionegrensis.caniventer; () => { var y = this; }; return x; } @@ -10876,8 +10876,8 @@ module imperfecta { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : subspinosus ->this : subspinosus +>y : this +>this : this >x : rionegrensis.caniventer Polonium(): lavali.wilsoni { var x: lavali.wilsoni; () => { var y = this; }; return x; } @@ -10888,8 +10888,8 @@ module imperfecta { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : subspinosus ->this : subspinosus +>y : this +>this : this >x : lavali.wilsoni harpia(): argurus.luctuosa { var x: argurus.luctuosa; () => { var y = this; }; return x; } @@ -10900,8 +10900,8 @@ module imperfecta { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : subspinosus ->this : subspinosus +>y : this +>this : this >x : argurus.luctuosa } export class ciliolabrum extends dogramacii.robustulus { @@ -10936,8 +10936,8 @@ module imperfecta { >caurinus : any >megaphyllus : caurinus.megaphyllus >() => { var y = this; } : () => void ->y : ciliolabrum ->this : ciliolabrum +>y : this +>this : this >x : argurus.dauricus> ludia(): caurinus.johorensis { var x: caurinus.johorensis; () => { var y = this; }; return x; } @@ -10956,8 +10956,8 @@ module imperfecta { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : ciliolabrum ->this : ciliolabrum +>y : this +>this : this >x : caurinus.johorensis sinicus(): macrorhinos.marmosurus { var x: macrorhinos.marmosurus; () => { var y = this; }; return x; } @@ -10976,8 +10976,8 @@ module imperfecta { >gabriellae : any >amicus : gabriellae.amicus >() => { var y = this; } : () => void ->y : ciliolabrum ->this : ciliolabrum +>y : this +>this : this >x : macrorhinos.marmosurus } } @@ -10997,8 +10997,8 @@ module quasiater { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : wattsi ->this : wattsi +>y : this +>this : this >x : lavali.xanthognathus hussoni(): lavali.wilsoni { var x: lavali.wilsoni; () => { var y = this; }; return x; } @@ -11009,8 +11009,8 @@ module quasiater { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : wattsi ->this : wattsi +>y : this +>this : this >x : lavali.wilsoni bilarni(): samarensis.cahirinus>, dogramacii.koepckeae> { var x: samarensis.cahirinus>, dogramacii.koepckeae>; () => { var y = this; }; return x; } @@ -11045,8 +11045,8 @@ module quasiater { >dogramacii : any >koepckeae : dogramacii.koepckeae >() => { var y = this; } : () => void ->y : wattsi ->this : wattsi +>y : this +>this : this >x : samarensis.cahirinus>, dogramacii.koepckeae> cabrerae(): lavali.lepturus { var x: lavali.lepturus; () => { var y = this; }; return x; } @@ -11057,8 +11057,8 @@ module quasiater { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : wattsi ->this : wattsi +>y : this +>this : this >x : lavali.lepturus } } @@ -11084,8 +11084,8 @@ module petrophilus { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : sodyi ->this : sodyi +>y : this +>this : this >x : samarensis.pallidus imberbis(): quasiater.carolinensis { var x: quasiater.carolinensis; () => { var y = this; }; return x; } @@ -11096,8 +11096,8 @@ module petrophilus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : sodyi ->this : sodyi +>y : this +>this : this >x : quasiater.carolinensis cansdalei(): dammermani.melanops { var x: dammermani.melanops; () => { var y = this; }; return x; } @@ -11108,8 +11108,8 @@ module petrophilus { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : sodyi ->this : sodyi +>y : this +>this : this >x : dammermani.melanops Lawrencium(): nigra.dolichurus { var x: nigra.dolichurus; () => { var y = this; }; return x; } @@ -11128,8 +11128,8 @@ module petrophilus { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : sodyi ->this : sodyi +>y : this +>this : this >x : nigra.dolichurus catta(): argurus.oreas { var x: argurus.oreas; () => { var y = this; }; return x; } @@ -11140,8 +11140,8 @@ module petrophilus { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : sodyi ->this : sodyi +>y : this +>this : this >x : argurus.oreas breviceps(): argurus.dauricus { var x: argurus.dauricus; () => { var y = this; }; return x; } @@ -11160,8 +11160,8 @@ module petrophilus { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : sodyi ->this : sodyi +>y : this +>this : this >x : argurus.dauricus transitionalis(): rendalli.zuluensis { var x: rendalli.zuluensis; () => { var y = this; }; return x; } @@ -11172,8 +11172,8 @@ module petrophilus { >rendalli : any >zuluensis : rendalli.zuluensis >() => { var y = this; } : () => void ->y : sodyi ->this : sodyi +>y : this +>this : this >x : rendalli.zuluensis heptneri(): argurus.germaini { var x: argurus.germaini; () => { var y = this; }; return x; } @@ -11184,8 +11184,8 @@ module petrophilus { >argurus : any >germaini : argurus.germaini >() => { var y = this; } : () => void ->y : sodyi ->this : sodyi +>y : this +>this : this >x : argurus.germaini bairdii(): lavali.beisa { var x: lavali.beisa; () => { var y = this; }; return x; } @@ -11196,8 +11196,8 @@ module petrophilus { >lavali : any >beisa : lavali.beisa >() => { var y = this; } : () => void ->y : sodyi ->this : sodyi +>y : this +>this : this >x : lavali.beisa } } @@ -11226,8 +11226,8 @@ module caurinus { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : megaphyllus ->this : megaphyllus +>y : this +>this : this >x : argurus.oreas amatus(): lutreolus.schlegeli { var x: lutreolus.schlegeli; () => { var y = this; }; return x; } @@ -11238,8 +11238,8 @@ module caurinus { >lutreolus : any >schlegeli : lutreolus.schlegeli >() => { var y = this; } : () => void ->y : megaphyllus ->this : megaphyllus +>y : this +>this : this >x : lutreolus.schlegeli bucculentus(): gabriellae.echinatus { var x: gabriellae.echinatus; () => { var y = this; }; return x; } @@ -11250,8 +11250,8 @@ module caurinus { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : megaphyllus ->this : megaphyllus +>y : this +>this : this >x : gabriellae.echinatus lepida(): rendalli.crenulata> { var x: rendalli.crenulata>; () => { var y = this; }; return x; } @@ -11278,8 +11278,8 @@ module caurinus { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : megaphyllus ->this : megaphyllus +>y : this +>this : this >x : rendalli.crenulata> graecus(): dogramacii.kaiseri { var x: dogramacii.kaiseri; () => { var y = this; }; return x; } @@ -11290,8 +11290,8 @@ module caurinus { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : megaphyllus ->this : megaphyllus +>y : this +>this : this >x : dogramacii.kaiseri forsteri(): petrophilus.minutilla { var x: petrophilus.minutilla; () => { var y = this; }; return x; } @@ -11302,8 +11302,8 @@ module caurinus { >petrophilus : any >minutilla : petrophilus.minutilla >() => { var y = this; } : () => void ->y : megaphyllus ->this : megaphyllus +>y : this +>this : this >x : petrophilus.minutilla perotensis(): samarensis.cahirinus { var x: samarensis.cahirinus; () => { var y = this; }; return x; } @@ -11322,8 +11322,8 @@ module caurinus { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : megaphyllus ->this : megaphyllus +>y : this +>this : this >x : samarensis.cahirinus cirrhosus(): quasiater.carolinensis { var x: quasiater.carolinensis; () => { var y = this; }; return x; } @@ -11334,8 +11334,8 @@ module caurinus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : megaphyllus ->this : megaphyllus +>y : this +>this : this >x : quasiater.carolinensis } } @@ -11353,8 +11353,8 @@ module minutus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : portoricensis ->this : portoricensis +>y : this +>this : this >x : quasiater.carolinensis aequatorianus(): gabriellae.klossii { var x: gabriellae.klossii; () => { var y = this; }; return x; } @@ -11373,8 +11373,8 @@ module minutus { >dogramacii : any >aurata : dogramacii.aurata >() => { var y = this; } : () => void ->y : portoricensis ->this : portoricensis +>y : this +>this : this >x : gabriellae.klossii rhinogradoides(): samarensis.cahirinus { var x: samarensis.cahirinus; () => { var y = this; }; return x; } @@ -11393,8 +11393,8 @@ module minutus { >julianae : any >durangae : julianae.durangae >() => { var y = this; } : () => void ->y : portoricensis ->this : portoricensis +>y : this +>this : this >x : samarensis.cahirinus } } @@ -11412,8 +11412,8 @@ module lutreolus { >lutreolus : any >punicus : punicus >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : punicus Promethium(): samarensis.pelurus { var x: samarensis.pelurus; () => { var y = this; }; return x; } @@ -11432,8 +11432,8 @@ module lutreolus { >julianae : any >durangae : julianae.durangae >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : samarensis.pelurus salinae(): gabriellae.klossii { var x: gabriellae.klossii; () => { var y = this; }; return x; } @@ -11452,8 +11452,8 @@ module lutreolus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : gabriellae.klossii kerri(): howi.coludo { var x: howi.coludo; () => { var y = this; }; return x; } @@ -11472,8 +11472,8 @@ module lutreolus { >minutus : any >portoricensis : minutus.portoricensis >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : howi.coludo scotti(): quasiater.wattsi { var x: quasiater.wattsi; () => { var y = this; }; return x; } @@ -11492,8 +11492,8 @@ module lutreolus { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : quasiater.wattsi camerunensis(): julianae.gerbillus { var x: julianae.gerbillus; () => { var y = this; }; return x; } @@ -11512,8 +11512,8 @@ module lutreolus { >julianae : any >durangae : julianae.durangae >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : julianae.gerbillus affinis(): argurus.germaini { var x: argurus.germaini; () => { var y = this; }; return x; } @@ -11524,8 +11524,8 @@ module lutreolus { >argurus : any >germaini : argurus.germaini >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : argurus.germaini siebersi(): trivirgatus.lotor> { var x: trivirgatus.lotor>; () => { var y = this; }; return x; } @@ -11552,8 +11552,8 @@ module lutreolus { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : trivirgatus.lotor> maquassiensis(): trivirgatus.oconnelli { var x: trivirgatus.oconnelli; () => { var y = this; }; return x; } @@ -11564,8 +11564,8 @@ module lutreolus { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : trivirgatus.oconnelli layardi(): julianae.albidens { var x: julianae.albidens; () => { var y = this; }; return x; } @@ -11584,8 +11584,8 @@ module lutreolus { >dogramacii : any >koepckeae : dogramacii.koepckeae >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : julianae.albidens bishopi(): dogramacii.aurata { var x: dogramacii.aurata; () => { var y = this; }; return x; } @@ -11596,8 +11596,8 @@ module lutreolus { >dogramacii : any >aurata : dogramacii.aurata >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : dogramacii.aurata apodemoides(): caurinus.psilurus { var x: caurinus.psilurus; () => { var y = this; }; return x; } @@ -11608,8 +11608,8 @@ module lutreolus { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : caurinus.psilurus argentiventer(): trivirgatus.mixtus { var x: trivirgatus.mixtus; () => { var y = this; }; return x; } @@ -11628,8 +11628,8 @@ module lutreolus { >lutreolus : any >punicus : punicus >() => { var y = this; } : () => void ->y : foina ->this : foina +>y : this +>this : this >x : trivirgatus.mixtus } } @@ -11672,8 +11672,8 @@ module lutreolus { >argurus : any >germaini : argurus.germaini >() => { var y = this; } : () => void ->y : cor ->this : cor +>y : this +>this : this >x : petrophilus.sodyi voi(): caurinus.johorensis { var x: caurinus.johorensis; () => { var y = this; }; return x; } @@ -11692,8 +11692,8 @@ module lutreolus { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : cor ->this : cor +>y : this +>this : this >x : caurinus.johorensis mussoi(): quasiater.carolinensis { var x: quasiater.carolinensis; () => { var y = this; }; return x; } @@ -11704,8 +11704,8 @@ module lutreolus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : cor ->this : cor +>y : this +>this : this >x : quasiater.carolinensis truncatus(): trivirgatus.lotor { var x: trivirgatus.lotor; () => { var y = this; }; return x; } @@ -11724,8 +11724,8 @@ module lutreolus { >lutreolus : any >foina : foina >() => { var y = this; } : () => void ->y : cor ->this : cor +>y : this +>this : this >x : trivirgatus.lotor achates(): provocax.melanoleuca { var x: provocax.melanoleuca; () => { var y = this; }; return x; } @@ -11736,8 +11736,8 @@ module lutreolus { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : cor ->this : cor +>y : this +>this : this >x : provocax.melanoleuca praedatrix(): howi.angulatus { var x: howi.angulatus; () => { var y = this; }; return x; } @@ -11756,8 +11756,8 @@ module lutreolus { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : cor ->this : cor +>y : this +>this : this >x : howi.angulatus mzabi(): quasiater.wattsi, minutus.inez> { var x: quasiater.wattsi, minutus.inez>; () => { var y = this; }; return x; } @@ -11792,8 +11792,8 @@ module lutreolus { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : cor ->this : cor +>y : this +>this : this >x : quasiater.wattsi, minutus.inez> xanthinus(): nigra.gracilis, howi.marcanoi> { var x: nigra.gracilis, howi.marcanoi>; () => { var y = this; }; return x; } @@ -11820,8 +11820,8 @@ module lutreolus { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : cor ->this : cor +>y : this +>this : this >x : nigra.gracilis, howi.marcanoi> tapoatafa(): caurinus.megaphyllus { var x: caurinus.megaphyllus; () => { var y = this; }; return x; } @@ -11832,8 +11832,8 @@ module lutreolus { >caurinus : any >megaphyllus : caurinus.megaphyllus >() => { var y = this; } : () => void ->y : cor ->this : cor +>y : this +>this : this >x : caurinus.megaphyllus castroviejoi(): Lanthanum.jugularis { var x: Lanthanum.jugularis; () => { var y = this; }; return x; } @@ -11844,8 +11844,8 @@ module lutreolus { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : cor ->this : cor +>y : this +>this : this >x : Lanthanum.jugularis } } @@ -11865,8 +11865,8 @@ module howi { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : coludo ->this : coludo +>y : this +>this : this >x : lutreolus.punicus isseli(): argurus.germaini { var x: argurus.germaini; () => { var y = this; }; return x; } @@ -11877,8 +11877,8 @@ module howi { >argurus : any >germaini : argurus.germaini >() => { var y = this; } : () => void ->y : coludo ->this : coludo +>y : this +>this : this >x : argurus.germaini } } @@ -11899,8 +11899,8 @@ module argurus { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : germaini ->this : germaini +>y : this +>this : this >x : lavali.wilsoni palmarum(): macrorhinos.marmosurus { var x: macrorhinos.marmosurus; () => { var y = this; }; return x; } @@ -11919,8 +11919,8 @@ module argurus { >lavali : any >thaeleri : lavali.thaeleri >() => { var y = this; } : () => void ->y : germaini ->this : germaini +>y : this +>this : this >x : macrorhinos.marmosurus } } @@ -11946,8 +11946,8 @@ module sagitta { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : stolzmanni ->this : stolzmanni +>y : this +>this : this >x : nigra.dolichurus dhofarensis(): lutreolus.foina { var x: lutreolus.foina; () => { var y = this; }; return x; } @@ -11958,8 +11958,8 @@ module sagitta { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : stolzmanni ->this : stolzmanni +>y : this +>this : this >x : lutreolus.foina tricolor(): argurus.germaini { var x: argurus.germaini; () => { var y = this; }; return x; } @@ -11970,8 +11970,8 @@ module sagitta { >argurus : any >germaini : argurus.germaini >() => { var y = this; } : () => void ->y : stolzmanni ->this : stolzmanni +>y : this +>this : this >x : argurus.germaini gardneri(): lavali.xanthognathus { var x: lavali.xanthognathus; () => { var y = this; }; return x; } @@ -11982,8 +11982,8 @@ module sagitta { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : stolzmanni ->this : stolzmanni +>y : this +>this : this >x : lavali.xanthognathus walleri(): rendalli.moojeni, gabriellae.echinatus> { var x: rendalli.moojeni, gabriellae.echinatus>; () => { var y = this; }; return x; } @@ -12010,8 +12010,8 @@ module sagitta { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : stolzmanni ->this : stolzmanni +>y : this +>this : this >x : rendalli.moojeni, gabriellae.echinatus> talpoides(): gabriellae.echinatus { var x: gabriellae.echinatus; () => { var y = this; }; return x; } @@ -12022,8 +12022,8 @@ module sagitta { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : stolzmanni ->this : stolzmanni +>y : this +>this : this >x : gabriellae.echinatus pallipes(): dammermani.melanops { var x: dammermani.melanops; () => { var y = this; }; return x; } @@ -12034,8 +12034,8 @@ module sagitta { >dammermani : any >melanops : dammermani.melanops >() => { var y = this; } : () => void ->y : stolzmanni ->this : stolzmanni +>y : this +>this : this >x : dammermani.melanops lagurus(): lavali.beisa { var x: lavali.beisa; () => { var y = this; }; return x; } @@ -12046,8 +12046,8 @@ module sagitta { >lavali : any >beisa : lavali.beisa >() => { var y = this; } : () => void ->y : stolzmanni ->this : stolzmanni +>y : this +>this : this >x : lavali.beisa hipposideros(): julianae.albidens { var x: julianae.albidens; () => { var y = this; }; return x; } @@ -12066,8 +12066,8 @@ module sagitta { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : stolzmanni ->this : stolzmanni +>y : this +>this : this >x : julianae.albidens griselda(): caurinus.psilurus { var x: caurinus.psilurus; () => { var y = this; }; return x; } @@ -12078,8 +12078,8 @@ module sagitta { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : stolzmanni ->this : stolzmanni +>y : this +>this : this >x : caurinus.psilurus florium(): rendalli.zuluensis { var x: rendalli.zuluensis; () => { var y = this; }; return x; } @@ -12090,8 +12090,8 @@ module sagitta { >rendalli : any >zuluensis : rendalli.zuluensis >() => { var y = this; } : () => void ->y : stolzmanni ->this : stolzmanni +>y : this +>this : this >x : rendalli.zuluensis } } @@ -12116,8 +12116,8 @@ module dammermani { >dammermani : any >melanops : melanops >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : melanops harwoodi(): rionegrensis.veraecrucis, lavali.wilsoni> { var x: rionegrensis.veraecrucis, lavali.wilsoni>; () => { var y = this; }; return x; } @@ -12144,8 +12144,8 @@ module dammermani { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : rionegrensis.veraecrucis, lavali.wilsoni> ashaninka(): julianae.nudicaudus { var x: julianae.nudicaudus; () => { var y = this; }; return x; } @@ -12156,8 +12156,8 @@ module dammermani { >julianae : any >nudicaudus : julianae.nudicaudus >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : julianae.nudicaudus wiedii(): julianae.steerii { var x: julianae.steerii; () => { var y = this; }; return x; } @@ -12168,8 +12168,8 @@ module dammermani { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : julianae.steerii godmani(): imperfecta.subspinosus { var x: imperfecta.subspinosus; () => { var y = this; }; return x; } @@ -12180,8 +12180,8 @@ module dammermani { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : imperfecta.subspinosus condorensis(): imperfecta.ciliolabrum { var x: imperfecta.ciliolabrum; () => { var y = this; }; return x; } @@ -12200,8 +12200,8 @@ module dammermani { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : imperfecta.ciliolabrum xerophila(): panglima.abidi { var x: panglima.abidi; () => { var y = this; }; return x; } @@ -12220,8 +12220,8 @@ module dammermani { >patas : any >uralensis : patas.uralensis >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : panglima.abidi laminatus(): panglima.fundatus>> { var x: panglima.fundatus>>; () => { var y = this; }; return x; } @@ -12256,8 +12256,8 @@ module dammermani { >imperfecta : any >subspinosus : imperfecta.subspinosus >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : panglima.fundatus>> archeri(): howi.marcanoi { var x: howi.marcanoi; () => { var y = this; }; return x; } @@ -12268,8 +12268,8 @@ module dammermani { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : howi.marcanoi hidalgo(): minutus.inez { var x: minutus.inez; () => { var y = this; }; return x; } @@ -12288,8 +12288,8 @@ module dammermani { >Lanthanum : any >jugularis : Lanthanum.jugularis >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : minutus.inez unicolor(): lutreolus.schlegeli { var x: lutreolus.schlegeli; () => { var y = this; }; return x; } @@ -12300,8 +12300,8 @@ module dammermani { >lutreolus : any >schlegeli : lutreolus.schlegeli >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : lutreolus.schlegeli philippii(): nigra.gracilis { var x: nigra.gracilis; () => { var y = this; }; return x; } @@ -12320,8 +12320,8 @@ module dammermani { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : nigra.gracilis bocagei(): julianae.albidens { var x: julianae.albidens; () => { var y = this; }; return x; } @@ -12340,8 +12340,8 @@ module dammermani { >lavali : any >thaeleri : lavali.thaeleri >() => { var y = this; } : () => void ->y : melanops ->this : melanops +>y : this +>this : this >x : julianae.albidens } } @@ -12386,8 +12386,8 @@ module argurus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : peninsulae ->this : peninsulae +>y : this +>this : this >x : trivirgatus.mixtus, panglima.amphibius> novaeangliae(): lavali.xanthognathus { var x: lavali.xanthognathus; () => { var y = this; }; return x; } @@ -12398,8 +12398,8 @@ module argurus { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : peninsulae ->this : peninsulae +>y : this +>this : this >x : lavali.xanthognathus olallae(): julianae.sumatrana { var x: julianae.sumatrana; () => { var y = this; }; return x; } @@ -12410,8 +12410,8 @@ module argurus { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : peninsulae ->this : peninsulae +>y : this +>this : this >x : julianae.sumatrana anselli(): dogramacii.aurata { var x: dogramacii.aurata; () => { var y = this; }; return x; } @@ -12422,8 +12422,8 @@ module argurus { >dogramacii : any >aurata : dogramacii.aurata >() => { var y = this; } : () => void ->y : peninsulae ->this : peninsulae +>y : this +>this : this >x : dogramacii.aurata timminsi(): macrorhinos.konganensis { var x: macrorhinos.konganensis; () => { var y = this; }; return x; } @@ -12434,8 +12434,8 @@ module argurus { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : peninsulae ->this : peninsulae +>y : this +>this : this >x : macrorhinos.konganensis sordidus(): rendalli.moojeni { var x: rendalli.moojeni; () => { var y = this; }; return x; } @@ -12454,8 +12454,8 @@ module argurus { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : peninsulae ->this : peninsulae +>y : this +>this : this >x : rendalli.moojeni telfordi(): trivirgatus.oconnelli { var x: trivirgatus.oconnelli; () => { var y = this; }; return x; } @@ -12466,8 +12466,8 @@ module argurus { >trivirgatus : any >oconnelli : trivirgatus.oconnelli >() => { var y = this; } : () => void ->y : peninsulae ->this : peninsulae +>y : this +>this : this >x : trivirgatus.oconnelli cavernarum(): minutus.inez { var x: minutus.inez; () => { var y = this; }; return x; } @@ -12486,8 +12486,8 @@ module argurus { >argurus : any >luctuosa : luctuosa >() => { var y = this; } : () => void ->y : peninsulae ->this : peninsulae +>y : this +>this : this >x : minutus.inez } } @@ -12523,8 +12523,8 @@ module argurus { >dogramacii : any >kaiseri : dogramacii.kaiseri >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : nigra.caucasica, dogramacii.kaiseri> ruschii(): imperfecta.lasiurus> { var x: imperfecta.lasiurus>; () => { var y = this; }; return x; } @@ -12551,8 +12551,8 @@ module argurus { >petrophilus : any >minutilla : petrophilus.minutilla >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : imperfecta.lasiurus> tricuspidatus(): lavali.wilsoni { var x: lavali.wilsoni; () => { var y = this; }; return x; } @@ -12563,8 +12563,8 @@ module argurus { >lavali : any >wilsoni : lavali.wilsoni >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : lavali.wilsoni fernandezi(): dammermani.siberu, panglima.abidi> { var x: dammermani.siberu, panglima.abidi>; () => { var y = this; }; return x; } @@ -12599,8 +12599,8 @@ module argurus { >argurus : any >peninsulae : peninsulae >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : dammermani.siberu, panglima.abidi> colletti(): samarensis.pallidus { var x: samarensis.pallidus; () => { var y = this; }; return x; } @@ -12611,8 +12611,8 @@ module argurus { >samarensis : any >pallidus : samarensis.pallidus >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : samarensis.pallidus microbullatus(): lutreolus.schlegeli { var x: lutreolus.schlegeli; () => { var y = this; }; return x; } @@ -12623,8 +12623,8 @@ module argurus { >lutreolus : any >schlegeli : lutreolus.schlegeli >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : lutreolus.schlegeli eburneae(): chrysaeolus.sarasinorum { var x: chrysaeolus.sarasinorum; () => { var y = this; }; return x; } @@ -12643,8 +12643,8 @@ module argurus { >julianae : any >acariensis : julianae.acariensis >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : chrysaeolus.sarasinorum tatei(): argurus.pygmaea> { var x: argurus.pygmaea>; () => { var y = this; }; return x; } @@ -12671,8 +12671,8 @@ module argurus { >macrorhinos : any >daphaenodon : macrorhinos.daphaenodon >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : pygmaea> millardi(): sagitta.walkeri { var x: sagitta.walkeri; () => { var y = this; }; return x; } @@ -12683,8 +12683,8 @@ module argurus { >sagitta : any >walkeri : sagitta.walkeri >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : sagitta.walkeri pruinosus(): trivirgatus.falconeri { var x: trivirgatus.falconeri; () => { var y = this; }; return x; } @@ -12695,8 +12695,8 @@ module argurus { >trivirgatus : any >falconeri : trivirgatus.falconeri >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : trivirgatus.falconeri delator(): argurus.netscheri { var x: argurus.netscheri; () => { var y = this; }; return x; } @@ -12715,8 +12715,8 @@ module argurus { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : netscheri nyikae(): trivirgatus.tumidifrons, petrophilus.minutilla>, julianae.acariensis> { var x: trivirgatus.tumidifrons, petrophilus.minutilla>, julianae.acariensis>; () => { var y = this; }; return x; } @@ -12751,8 +12751,8 @@ module argurus { >julianae : any >acariensis : julianae.acariensis >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : trivirgatus.tumidifrons, petrophilus.minutilla>, julianae.acariensis> ruemmleri(): panglima.amphibius, gabriellae.echinatus>, dogramacii.aurata>, imperfecta.ciliolabrum> { var x: panglima.amphibius, gabriellae.echinatus>, dogramacii.aurata>, imperfecta.ciliolabrum>; () => { var y = this; }; return x; } @@ -12803,8 +12803,8 @@ module argurus { >lavali : any >beisa : lavali.beisa >() => { var y = this; } : () => void ->y : netscheri ->this : netscheri +>y : this +>this : this >x : panglima.amphibius, gabriellae.echinatus>, dogramacii.aurata>, imperfecta.ciliolabrum> } } @@ -12855,8 +12855,8 @@ module ruatanica { >rionegrensis : any >caniventer : rionegrensis.caniventer >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : panglima.amphibius, argurus.dauricus> spectabilis(): petrophilus.sodyi { var x: petrophilus.sodyi; () => { var y = this; }; return x; } @@ -12875,8 +12875,8 @@ module ruatanica { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : petrophilus.sodyi kamensis(): trivirgatus.lotor, lavali.lepturus> { var x: trivirgatus.lotor, lavali.lepturus>; () => { var y = this; }; return x; } @@ -12903,8 +12903,8 @@ module ruatanica { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : trivirgatus.lotor, lavali.lepturus> ruddi(): lutreolus.foina { var x: lutreolus.foina; () => { var y = this; }; return x; } @@ -12915,8 +12915,8 @@ module ruatanica { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : lutreolus.foina bartelsii(): julianae.sumatrana { var x: julianae.sumatrana; () => { var y = this; }; return x; } @@ -12927,8 +12927,8 @@ module ruatanica { >julianae : any >sumatrana : julianae.sumatrana >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : julianae.sumatrana yerbabuenae(): dammermani.siberu, imperfecta.ciliolabrum> { var x: dammermani.siberu, imperfecta.ciliolabrum>; () => { var y = this; }; return x; } @@ -12963,8 +12963,8 @@ module ruatanica { >petrophilus : any >minutilla : petrophilus.minutilla >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : dammermani.siberu, imperfecta.ciliolabrum> davidi(): trivirgatus.mixtus { var x: trivirgatus.mixtus; () => { var y = this; }; return x; } @@ -12983,8 +12983,8 @@ module ruatanica { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : trivirgatus.mixtus pilirostris(): argurus.wetmorei>, sagitta.leptoceros>>, macrorhinos.konganensis> { var x: argurus.wetmorei>, sagitta.leptoceros>>, macrorhinos.konganensis>; () => { var y = this; }; return x; } @@ -13043,8 +13043,8 @@ module ruatanica { >macrorhinos : any >konganensis : macrorhinos.konganensis >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : argurus.wetmorei>, sagitta.leptoceros>>, macrorhinos.konganensis> catherinae(): imperfecta.lasiurus, petrophilus.sodyi> { var x: imperfecta.lasiurus, petrophilus.sodyi>; () => { var y = this; }; return x; } @@ -13079,8 +13079,8 @@ module ruatanica { >caurinus : any >psilurus : caurinus.psilurus >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : imperfecta.lasiurus, petrophilus.sodyi> frontata(): argurus.oreas { var x: argurus.oreas; () => { var y = this; }; return x; } @@ -13091,8 +13091,8 @@ module ruatanica { >argurus : any >oreas : argurus.oreas >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : argurus.oreas Terbium(): caurinus.mahaganus { var x: caurinus.mahaganus; () => { var y = this; }; return x; } @@ -13111,8 +13111,8 @@ module ruatanica { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : caurinus.mahaganus thomensis(): minutus.inez> { var x: minutus.inez>; () => { var y = this; }; return x; } @@ -13139,8 +13139,8 @@ module ruatanica { >gabriellae : any >echinatus : gabriellae.echinatus >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : minutus.inez> soricinus(): quasiater.carolinensis { var x: quasiater.carolinensis; () => { var y = this; }; return x; } @@ -13151,8 +13151,8 @@ module ruatanica { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : Praseodymium ->this : Praseodymium +>y : this +>this : this >x : quasiater.carolinensis } } @@ -13183,8 +13183,8 @@ module caurinus { >julianae : any >acariensis : julianae.acariensis >() => { var y = this; } : () => void ->y : johorensis ->this : johorensis +>y : this +>this : this >x : ruatanica.Praseodymium } } @@ -13234,8 +13234,8 @@ module argurus { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : luctuosa ->this : luctuosa +>y : this +>this : this >x : rendalli.moojeni, gabriellae.echinatus>, sagitta.stolzmanni>, lutreolus.punicus> } } @@ -13271,8 +13271,8 @@ module panamensis { >dogramacii : any >aurata : dogramacii.aurata >() => { var y = this; } : () => void ->y : setulosus ->this : setulosus +>y : this +>this : this >x : caurinus.mahaganus, dogramacii.aurata> guereza(): howi.coludo { var x: howi.coludo; () => { var y = this; }; return x; } @@ -13291,8 +13291,8 @@ module panamensis { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : setulosus ->this : setulosus +>y : this +>this : this >x : howi.coludo buselaphus(): daubentonii.nesiotes, dogramacii.koepckeae>, trivirgatus.mixtus> { var x: daubentonii.nesiotes, dogramacii.koepckeae>, trivirgatus.mixtus>; () => { var y = this; }; return x; } @@ -13335,8 +13335,8 @@ module panamensis { >lutreolus : any >punicus : lutreolus.punicus >() => { var y = this; } : () => void ->y : setulosus ->this : setulosus +>y : this +>this : this >x : daubentonii.nesiotes, dogramacii.koepckeae>, trivirgatus.mixtus> nuttalli(): sagitta.cinereus, chrysaeolus.sarasinorum> { var x: sagitta.cinereus, chrysaeolus.sarasinorum>; () => { var y = this; }; return x; } @@ -13371,8 +13371,8 @@ module panamensis { >lavali : any >xanthognathus : lavali.xanthognathus >() => { var y = this; } : () => void ->y : setulosus ->this : setulosus +>y : this +>this : this >x : sagitta.cinereus, chrysaeolus.sarasinorum> pelii(): rendalli.crenulata, julianae.steerii> { var x: rendalli.crenulata, julianae.steerii>; () => { var y = this; }; return x; } @@ -13399,8 +13399,8 @@ module panamensis { >julianae : any >steerii : julianae.steerii >() => { var y = this; } : () => void ->y : setulosus ->this : setulosus +>y : this +>this : this >x : rendalli.crenulata, julianae.steerii> tunneyi(): sagitta.stolzmanni { var x: sagitta.stolzmanni; () => { var y = this; }; return x; } @@ -13411,8 +13411,8 @@ module panamensis { >sagitta : any >stolzmanni : sagitta.stolzmanni >() => { var y = this; } : () => void ->y : setulosus ->this : setulosus +>y : this +>this : this >x : sagitta.stolzmanni lamula(): patas.uralensis { var x: patas.uralensis; () => { var y = this; }; return x; } @@ -13423,8 +13423,8 @@ module panamensis { >patas : any >uralensis : patas.uralensis >() => { var y = this; } : () => void ->y : setulosus ->this : setulosus +>y : this +>this : this >x : patas.uralensis vampyrus(): julianae.oralis { var x: julianae.oralis; () => { var y = this; }; return x; } @@ -13443,8 +13443,8 @@ module panamensis { >provocax : any >melanoleuca : provocax.melanoleuca >() => { var y = this; } : () => void ->y : setulosus ->this : setulosus +>y : this +>this : this >x : julianae.oralis } } @@ -13512,8 +13512,8 @@ module petrophilus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : rosalia ->this : rosalia +>y : this +>this : this >x : panglima.amphibius>, trivirgatus.mixtus, panglima.amphibius>> baeops(): Lanthanum.nitidus { var x: Lanthanum.nitidus; () => { var y = this; }; return x; } @@ -13532,8 +13532,8 @@ module petrophilus { >lavali : any >lepturus : lavali.lepturus >() => { var y = this; } : () => void ->y : rosalia ->this : rosalia +>y : this +>this : this >x : Lanthanum.nitidus ozensis(): imperfecta.lasiurus, lutreolus.foina> { var x: imperfecta.lasiurus, lutreolus.foina>; () => { var y = this; }; return x; } @@ -13560,8 +13560,8 @@ module petrophilus { >lutreolus : any >foina : lutreolus.foina >() => { var y = this; } : () => void ->y : rosalia ->this : rosalia +>y : this +>this : this >x : imperfecta.lasiurus, lutreolus.foina> creaghi(): argurus.luctuosa { var x: argurus.luctuosa; () => { var y = this; }; return x; } @@ -13572,8 +13572,8 @@ module petrophilus { >argurus : any >luctuosa : argurus.luctuosa >() => { var y = this; } : () => void ->y : rosalia ->this : rosalia +>y : this +>this : this >x : argurus.luctuosa montivaga(): panamensis.setulosus> { var x: panamensis.setulosus>; () => { var y = this; }; return x; } @@ -13600,8 +13600,8 @@ module petrophilus { >caurinus : any >megaphyllus : caurinus.megaphyllus >() => { var y = this; } : () => void ->y : rosalia ->this : rosalia +>y : this +>this : this >x : panamensis.setulosus> } } @@ -13630,8 +13630,8 @@ module caurinus { >caurinus : any >psilurus : psilurus >() => { var y = this; } : () => void ->y : psilurus ->this : psilurus +>y : this +>this : this >x : panglima.amphibius lundi(): petrophilus.sodyi { var x: petrophilus.sodyi; () => { var y = this; }; return x; } @@ -13650,8 +13650,8 @@ module caurinus { >quasiater : any >bobrinskoi : quasiater.bobrinskoi >() => { var y = this; } : () => void ->y : psilurus ->this : psilurus +>y : this +>this : this >x : petrophilus.sodyi araeum(): imperfecta.ciliolabrum { var x: imperfecta.ciliolabrum; () => { var y = this; }; return x; } @@ -13670,8 +13670,8 @@ module caurinus { >lavali : any >beisa : lavali.beisa >() => { var y = this; } : () => void ->y : psilurus ->this : psilurus +>y : this +>this : this >x : imperfecta.ciliolabrum calamianensis(): julianae.gerbillus { var x: julianae.gerbillus; () => { var y = this; }; return x; } @@ -13690,8 +13690,8 @@ module caurinus { >quasiater : any >carolinensis : quasiater.carolinensis >() => { var y = this; } : () => void ->y : psilurus ->this : psilurus +>y : this +>this : this >x : julianae.gerbillus petersoni(): panamensis.setulosus { var x: panamensis.setulosus; () => { var y = this; }; return x; } @@ -13710,8 +13710,8 @@ module caurinus { >dogramacii : any >robustulus : dogramacii.robustulus >() => { var y = this; } : () => void ->y : psilurus ->this : psilurus +>y : this +>this : this >x : panamensis.setulosus nitela(): panamensis.linulus { var x: panamensis.linulus; () => { var y = this; }; return x; } @@ -13730,8 +13730,8 @@ module caurinus { >howi : any >marcanoi : howi.marcanoi >() => { var y = this; } : () => void ->y : psilurus ->this : psilurus +>y : this +>this : this >x : panamensis.linulus } } diff --git a/tests/baselines/reference/returnStatements.symbols b/tests/baselines/reference/returnStatements.symbols index e12f3ba5d8a..7d8b6d69d82 100644 --- a/tests/baselines/reference/returnStatements.symbols +++ b/tests/baselines/reference/returnStatements.symbols @@ -18,8 +18,8 @@ function fn5(): boolean { return true; } function fn6(): Date { return new Date(12); } >fn6 : Symbol(fn6, Decl(returnStatements.ts, 5, 40)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) function fn7(): any { return null; } >fn7 : Symbol(fn7, Decl(returnStatements.ts, 6, 45)) diff --git a/tests/baselines/reference/returnTypeParameterWithModules.symbols b/tests/baselines/reference/returnTypeParameterWithModules.symbols index c4b354ad920..7f8fab382a3 100644 --- a/tests/baselines/reference/returnTypeParameterWithModules.symbols +++ b/tests/baselines/reference/returnTypeParameterWithModules.symbols @@ -8,17 +8,17 @@ module M1 { >ar : Symbol(ar, Decl(returnTypeParameterWithModules.ts, 1, 30)) >f : Symbol(f, Decl(returnTypeParameterWithModules.ts, 1, 33)) >e : Symbol(e, Decl(returnTypeParameterWithModules.ts, 1, 36)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >A : Symbol(A, Decl(returnTypeParameterWithModules.ts, 1, 27)) return Array.prototype.reduce.apply(ar, e ? [f, e] : [f]); ->Array.prototype.reduce.apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20)) ->Array.prototype.reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120)) ->Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) ->prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, 1167, 41)) ->reduce : Symbol(Array.reduce, Decl(lib.d.ts, 1129, 93), Decl(lib.d.ts, 1136, 120)) ->apply : Symbol(Function.apply, Decl(lib.d.ts, 228, 20)) +>Array.prototype.reduce.apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) +>Array.prototype.reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Array.prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>prototype : Symbol(ArrayConstructor.prototype, Decl(lib.d.ts, --, --)) +>reduce : Symbol(Array.reduce, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>apply : Symbol(Function.apply, Decl(lib.d.ts, --, --)) >ar : Symbol(ar, Decl(returnTypeParameterWithModules.ts, 1, 30)) >e : Symbol(e, Decl(returnTypeParameterWithModules.ts, 1, 36)) >f : Symbol(f, Decl(returnTypeParameterWithModules.ts, 1, 33)) diff --git a/tests/baselines/reference/reverseInferenceInContextualInstantiation.symbols b/tests/baselines/reference/reverseInferenceInContextualInstantiation.symbols index 9e72d85a7fe..48cf549efad 100644 --- a/tests/baselines/reference/reverseInferenceInContextualInstantiation.symbols +++ b/tests/baselines/reference/reverseInferenceInContextualInstantiation.symbols @@ -11,8 +11,8 @@ var x: number[]; >x : Symbol(x, Decl(reverseInferenceInContextualInstantiation.ts, 1, 3)) x.sort(compare); // Error, but shouldn't be ->x.sort : Symbol(Array.sort, Decl(lib.d.ts, 1054, 45)) +>x.sort : Symbol(Array.sort, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(reverseInferenceInContextualInstantiation.ts, 1, 3)) ->sort : Symbol(Array.sort, Decl(lib.d.ts, 1054, 45)) +>sort : Symbol(Array.sort, Decl(lib.d.ts, --, --)) >compare : Symbol(compare, Decl(reverseInferenceInContextualInstantiation.ts, 0, 0)) diff --git a/tests/baselines/reference/scopeResolutionIdentifiers.symbols b/tests/baselines/reference/scopeResolutionIdentifiers.symbols index c3547aab60c..3ba780b8290 100644 --- a/tests/baselines/reference/scopeResolutionIdentifiers.symbols +++ b/tests/baselines/reference/scopeResolutionIdentifiers.symbols @@ -51,7 +51,7 @@ class C { s: Date; >s : Symbol(s, Decl(scopeResolutionIdentifiers.ts, 21, 9)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) n = this.s; >n : Symbol(n, Decl(scopeResolutionIdentifiers.ts, 22, 12)) @@ -70,7 +70,7 @@ class C { var p: Date; >p : Symbol(p, Decl(scopeResolutionIdentifiers.ts, 25, 11), Decl(scopeResolutionIdentifiers.ts, 26, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/scopeResolutionIdentifiers.types b/tests/baselines/reference/scopeResolutionIdentifiers.types index 37fa897863d..7c4eae23813 100644 --- a/tests/baselines/reference/scopeResolutionIdentifiers.types +++ b/tests/baselines/reference/scopeResolutionIdentifiers.types @@ -56,7 +56,7 @@ class C { n = this.s; >n : Date >this.s : Date ->this : C +>this : this >s : Date x() { @@ -65,7 +65,7 @@ class C { var p = this.n; >p : Date >this.n : Date ->this : C +>this : this >n : Date var p: Date; diff --git a/tests/baselines/reference/selfInCallback.types b/tests/baselines/reference/selfInCallback.types index 0f9b0f3a671..6010a64d80f 100644 --- a/tests/baselines/reference/selfInCallback.types +++ b/tests/baselines/reference/selfInCallback.types @@ -18,12 +18,12 @@ class C { this.callback(()=>{this.p1+1}); >this.callback(()=>{this.p1+1}) : void >this.callback : (cb: () => void) => void ->this : C +>this : this >callback : (cb: () => void) => void >()=>{this.p1+1} : () => void >this.p1+1 : number >this.p1 : number ->this : C +>this : this >p1 : number >1 : number } diff --git a/tests/baselines/reference/selfInLambdas.types b/tests/baselines/reference/selfInLambdas.types index e8905432e75..3addf07c75a 100644 --- a/tests/baselines/reference/selfInLambdas.types +++ b/tests/baselines/reference/selfInLambdas.types @@ -79,7 +79,7 @@ class X { var x = this.value; >x : string >this.value : string ->this : X +>this : this >value : string var inner = () => { @@ -89,7 +89,7 @@ class X { var y = this.value; >y : string >this.value : string ->this : X +>this : this >value : string } diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt new file mode 100644 index 00000000000..7ac5fe9a26c --- /dev/null +++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.errors.txt @@ -0,0 +1,164 @@ +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 'number' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(46,12): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts(72,5): error TS2322: Type 'number' 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 'number' 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; }'. + Types of property 'x' are incompatible. + Type 'number' 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; }'. + 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 (12 errors) ==== + + + (function() { + var s0; + for ({ s0 = 5 } of [{ s0: 1 }]) { + } + }); + (function() { + var s0; + for ({ s0:s0 = 5 } of [{ s0: 1 }]) { + } + }); + + (function() { + var s1; + for ({ s1 = 5 } of [{}]) { + ~~ +!!! error TS2459: Type '{}' has no property 's1' and no string index signature. + } + }); + + (function() { + var s1; + for ({ s1:s1 = 5 } of [{}]) { + ~~ +!!! error TS2459: Type '{}' has no property 's1' and no string index signature. + } + }); + + (function() { + var s2; + for ({ s2 = 5 } of [{ s2: "" }]) { + } + }); + + (function() { + var s2; + for ({ s2:s2 = 5 } of [{ s2: "" }]) { + } + }); + + (function() { + var s3: string; + for ({ s3 = 5 } of [{ s3: "" }]) { + ~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + } + }); + + (function() { + var s3: string; + for ({ s3:s3 = 5 } of [{ s3: "" }]) { + ~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + } + }); + + (function() { + let y; + ({ y = 5 } = { y: 1 }) + }); + + (function() { + let y; + ({ y:y = 5 } = { y: 1 }) + }); + + (function() { + let y0: number; + ({ y0 = 5 } = { y0: 1 }) + }); + + (function() { + let y0: number; + ({ y0:y0 = 5 } = { y0: 1 }) + }); + + (function() { + let y1: string; + ({ y1 = 5 } = {}) + ~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + }); + + (function() { + let y1: string; + ({ y1:y1 = 5 } = {}) + ~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + }); + + (function() { + let y2: string, y3: { x: string }; + ({ y2 = 5, y3 = { x: 1 } } = {}) + ~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + ~~ +!!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. +!!! error TS2322: Types of property 'x' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + }); + + (function() { + let y2: string, y3: { x: string }; + ({ y2:y2 = 5, y3:y3 = { x: 1 } } = {}) + ~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + ~~ +!!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. +!!! error TS2322: Types of property 'x' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + }); + + (function() { + let y4: number, y5: { x: number }; + ({ y4 = 5, y5 = { x: 1 } } = {}) + }); + + (function() { + let y4: number, y5: { x: number }; + ({ y4:y4 = 5, y5:y5 = { x: 1 } } = {}) + }); + + + (function() { + let z; + ({ z = { x: 5 } } = { z: { x: 1 } }); + }); + + + (function() { + let z; + ({ z:z = { x: 5 } } = { z: { x: 1 } }); + }); + + (function() { + let a = { s = 5 }; + ~ +!!! error TS2304: Cannot find name 's'. + ~ +!!! error TS1312: '=' can only be used in an object literal property inside a destructuring assignment. + }); + + function foo({a = 4, b = { x: 5 }}) { + } \ No newline at end of file diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js new file mode 100644 index 00000000000..981ee08e20c --- /dev/null +++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring.js @@ -0,0 +1,242 @@ +//// [shorthandPropertyAssignmentsInDestructuring.ts] + + +(function() { + var s0; + for ({ s0 = 5 } of [{ s0: 1 }]) { + } +}); +(function() { + var s0; + for ({ s0:s0 = 5 } of [{ s0: 1 }]) { + } +}); + +(function() { + var s1; + for ({ s1 = 5 } of [{}]) { + } +}); + +(function() { + var s1; + for ({ s1:s1 = 5 } of [{}]) { + } +}); + +(function() { + var s2; + for ({ s2 = 5 } of [{ s2: "" }]) { + } +}); + +(function() { + var s2; + for ({ s2:s2 = 5 } of [{ s2: "" }]) { + } +}); + +(function() { + var s3: string; + for ({ s3 = 5 } of [{ s3: "" }]) { + } +}); + +(function() { + var s3: string; + for ({ s3:s3 = 5 } of [{ s3: "" }]) { + } +}); + +(function() { + let y; + ({ y = 5 } = { y: 1 }) +}); + +(function() { + let y; + ({ y:y = 5 } = { y: 1 }) +}); + +(function() { + let y0: number; + ({ y0 = 5 } = { y0: 1 }) +}); + +(function() { + let y0: number; + ({ y0:y0 = 5 } = { y0: 1 }) +}); + +(function() { + let y1: string; + ({ y1 = 5 } = {}) +}); + +(function() { + let y1: string; + ({ y1:y1 = 5 } = {}) +}); + +(function() { + let y2: string, y3: { x: string }; + ({ y2 = 5, y3 = { x: 1 } } = {}) +}); + +(function() { + let y2: string, y3: { x: string }; + ({ y2:y2 = 5, y3:y3 = { x: 1 } } = {}) +}); + +(function() { + let y4: number, y5: { x: number }; + ({ y4 = 5, y5 = { x: 1 } } = {}) +}); + +(function() { + let y4: number, y5: { x: number }; + ({ y4:y4 = 5, y5:y5 = { x: 1 } } = {}) +}); + + +(function() { + let z; + ({ z = { x: 5 } } = { z: { x: 1 } }); +}); + + +(function() { + let z; + ({ z:z = { x: 5 } } = { z: { x: 1 } }); +}); + +(function() { + let a = { s = 5 }; +}); + +function foo({a = 4, b = { x: 5 }}) { +} + +//// [shorthandPropertyAssignmentsInDestructuring.js] +(function () { + var s0; + for (var _i = 0, _a = [{ s0: 1 }]; _i < _a.length; _i++) { + _b = _a[_i].s0, s0 = _b === void 0 ? 5 : _b; + } + var _b; +}); +(function () { + var s0; + for (var _i = 0, _a = [{ s0: 1 }]; _i < _a.length; _i++) { + _b = _a[_i].s0, s0 = _b === void 0 ? 5 : _b; + } + var _b; +}); +(function () { + var s1; + for (var _i = 0, _a = [{}]; _i < _a.length; _i++) { + _b = _a[_i].s1, s1 = _b === void 0 ? 5 : _b; + } + var _b; +}); +(function () { + var s1; + for (var _i = 0, _a = [{}]; _i < _a.length; _i++) { + _b = _a[_i].s1, s1 = _b === void 0 ? 5 : _b; + } + var _b; +}); +(function () { + var s2; + for (var _i = 0, _a = [{ s2: "" }]; _i < _a.length; _i++) { + _b = _a[_i].s2, s2 = _b === void 0 ? 5 : _b; + } + var _b; +}); +(function () { + var s2; + for (var _i = 0, _a = [{ s2: "" }]; _i < _a.length; _i++) { + _b = _a[_i].s2, s2 = _b === void 0 ? 5 : _b; + } + var _b; +}); +(function () { + var s3; + for (var _i = 0, _a = [{ s3: "" }]; _i < _a.length; _i++) { + _b = _a[_i].s3, s3 = _b === void 0 ? 5 : _b; + } + var _b; +}); +(function () { + var s3; + for (var _i = 0, _a = [{ s3: "" }]; _i < _a.length; _i++) { + _b = _a[_i].s3, s3 = _b === void 0 ? 5 : _b; + } + var _b; +}); +(function () { + var y; + (_a = { y: 1 }, _b = _a.y, y = _b === void 0 ? 5 : _b, _a); + var _a, _b; +}); +(function () { + var y; + (_a = { y: 1 }, _b = _a.y, y = _b === void 0 ? 5 : _b, _a); + var _a, _b; +}); +(function () { + var y0; + (_a = { y0: 1 }, _b = _a.y0, y0 = _b === void 0 ? 5 : _b, _a); + var _a, _b; +}); +(function () { + var y0; + (_a = { y0: 1 }, _b = _a.y0, y0 = _b === void 0 ? 5 : _b, _a); + var _a, _b; +}); +(function () { + var y1; + (_a = {}, _b = _a.y1, y1 = _b === void 0 ? 5 : _b, _a); + var _a, _b; +}); +(function () { + var y1; + (_a = {}, _b = _a.y1, y1 = _b === void 0 ? 5 : _b, _a); + var _a, _b; +}); +(function () { + var y2, y3; + (_a = {}, _b = _a.y2, y2 = _b === void 0 ? 5 : _b, _c = _a.y3, y3 = _c === void 0 ? { x: 1 } : _c, _a); + var _a, _b, _c; +}); +(function () { + var y2, y3; + (_a = {}, _b = _a.y2, y2 = _b === void 0 ? 5 : _b, _c = _a.y3, y3 = _c === void 0 ? { x: 1 } : _c, _a); + var _a, _b, _c; +}); +(function () { + var y4, y5; + (_a = {}, _b = _a.y4, y4 = _b === void 0 ? 5 : _b, _c = _a.y5, y5 = _c === void 0 ? { x: 1 } : _c, _a); + var _a, _b, _c; +}); +(function () { + var y4, y5; + (_a = {}, _b = _a.y4, y4 = _b === void 0 ? 5 : _b, _c = _a.y5, y5 = _c === void 0 ? { x: 1 } : _c, _a); + var _a, _b, _c; +}); +(function () { + var z; + (_a = { z: { x: 1 } }, _b = _a.z, z = _b === void 0 ? { x: 5 } : _b, _a); + var _a, _b; +}); +(function () { + var z; + (_a = { z: { x: 1 } }, _b = _a.z, z = _b === void 0 ? { x: 5 } : _b, _a); + var _a, _b; +}); +(function () { + var a = { s: s }; +}); +function foo(_a) { + var _b = _a.a, a = _b === void 0 ? 4 : _b, _c = _a.b, b = _c === void 0 ? { x: 5 } : _c; +} diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt new file mode 100644 index 00000000000..7e6b6b35d7f --- /dev/null +++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.errors.txt @@ -0,0 +1,164 @@ +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 'number' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(46,12): error TS2322: Type 'number' is not assignable to type 'string'. +tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts(72,5): error TS2322: Type 'number' 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 'number' 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; }'. + 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 '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; }'. + 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 (12 errors) ==== + + + (function() { + var s0; + for ({ s0 = 5 } of [{ s0: 1 }]) { + } + }); + (function() { + var s0; + for ({ s0:s0 = 5 } of [{ s0: 1 }]) { + } + }); + + (function() { + var s1; + for ({ s1 = 5 } of [{}]) { + ~~ +!!! error TS2459: Type '{}' has no property 's1' and no string index signature. + } + }); + + (function() { + var s1; + for ({ s1:s1 = 5 } of [{}]) { + ~~ +!!! error TS2459: Type '{}' has no property 's1' and no string index signature. + } + }); + + (function() { + var s2; + for ({ s2 = 5 } of [{ s2: "" }]) { + } + }); + + (function() { + var s2; + for ({ s2:s2 = 5 } of [{ s2: "" }]) { + } + }); + + (function() { + var s3: string; + for ({ s3 = 5 } of [{ s3: "" }]) { + ~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + } + }); + + (function() { + var s3: string; + for ({ s3:s3 = 5 } of [{ s3: "" }]) { + ~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + } + }); + + (function() { + let y; + ({ y = 5 } = { y: 1 }) + }); + + (function() { + let y; + ({ y:y = 5 } = { y: 1 }) + }); + + (function() { + let y0: number; + ({ y0 = 5 } = { y0: 1 }) + }); + + (function() { + let y0: number; + ({ y0:y0 = 5 } = { y0: 1 }) + }); + + (function() { + let y1: string; + ({ y1 = 5 } = {}) + ~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + }); + + (function() { + let y1: string; + ({ y1:y1 = 5 } = {}) + ~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + }); + + (function() { + let y2: string, y3: { x: string }; + ({ y2 = 5, y3 = { x: 1 } } = {}) + ~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + ~~ +!!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. +!!! error TS2322: Types of property 'x' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + }); + + (function() { + let y2: string, y3: { x: string }; + ({ y2:y2 = 5, y3:y3 = { x: 1 } } = {}) + ~~ +!!! error TS2322: Type 'number' is not assignable to type 'string'. + ~~ +!!! error TS2322: Type '{ x: number; }' is not assignable to type '{ x: string; }'. +!!! error TS2322: Types of property 'x' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'string'. + }); + + (function() { + let y4: number, y5: { x: number }; + ({ y4 = 5, y5 = { x: 1 } } = {}) + }); + + (function() { + let y4: number, y5: { x: number }; + ({ y4:y4 = 5, y5:y5 = { x: 1 } } = {}) + }); + + + (function() { + let z; + ({ z = { x: 5 } } = { z: { x: 1 } }); + }); + + + (function() { + let z; + ({ z:z = { x: 5 } } = { z: { x: 1 } }); + }); + + (function() { + let a = { s = 5 }; + ~ +!!! error TS2304: Cannot find name 's'. + ~ +!!! error TS1312: '=' can only be used in an object literal property inside a destructuring assignment. + }); + + function foo({a = 4, b = { x: 5 }}) { + } \ No newline at end of file diff --git a/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js new file mode 100644 index 00000000000..11068708110 --- /dev/null +++ b/tests/baselines/reference/shorthandPropertyAssignmentsInDestructuring_ES6.js @@ -0,0 +1,213 @@ +//// [shorthandPropertyAssignmentsInDestructuring_ES6.ts] + + +(function() { + var s0; + for ({ s0 = 5 } of [{ s0: 1 }]) { + } +}); +(function() { + var s0; + for ({ s0:s0 = 5 } of [{ s0: 1 }]) { + } +}); + +(function() { + var s1; + for ({ s1 = 5 } of [{}]) { + } +}); + +(function() { + var s1; + for ({ s1:s1 = 5 } of [{}]) { + } +}); + +(function() { + var s2; + for ({ s2 = 5 } of [{ s2: "" }]) { + } +}); + +(function() { + var s2; + for ({ s2:s2 = 5 } of [{ s2: "" }]) { + } +}); + +(function() { + var s3: string; + for ({ s3 = 5 } of [{ s3: "" }]) { + } +}); + +(function() { + var s3: string; + for ({ s3:s3 = 5 } of [{ s3: "" }]) { + } +}); + +(function() { + let y; + ({ y = 5 } = { y: 1 }) +}); + +(function() { + let y; + ({ y:y = 5 } = { y: 1 }) +}); + +(function() { + let y0: number; + ({ y0 = 5 } = { y0: 1 }) +}); + +(function() { + let y0: number; + ({ y0:y0 = 5 } = { y0: 1 }) +}); + +(function() { + let y1: string; + ({ y1 = 5 } = {}) +}); + +(function() { + let y1: string; + ({ y1:y1 = 5 } = {}) +}); + +(function() { + let y2: string, y3: { x: string }; + ({ y2 = 5, y3 = { x: 1 } } = {}) +}); + +(function() { + let y2: string, y3: { x: string }; + ({ y2:y2 = 5, y3:y3 = { x: 1 } } = {}) +}); + +(function() { + let y4: number, y5: { x: number }; + ({ y4 = 5, y5 = { x: 1 } } = {}) +}); + +(function() { + let y4: number, y5: { x: number }; + ({ y4:y4 = 5, y5:y5 = { x: 1 } } = {}) +}); + + +(function() { + let z; + ({ z = { x: 5 } } = { z: { x: 1 } }); +}); + + +(function() { + let z; + ({ z:z = { x: 5 } } = { z: { x: 1 } }); +}); + +(function() { + let a = { s = 5 }; +}); + +function foo({a = 4, b = { x: 5 }}) { +} + +//// [shorthandPropertyAssignmentsInDestructuring_ES6.js] +(function () { + var s0; + for ({ s0 = 5 } of [{ s0: 1 }]) { + } +}); +(function () { + var s0; + for ({ s0: s0 = 5 } of [{ s0: 1 }]) { + } +}); +(function () { + var s1; + for ({ s1 = 5 } of [{}]) { + } +}); +(function () { + var s1; + for ({ s1: s1 = 5 } of [{}]) { + } +}); +(function () { + var s2; + for ({ s2 = 5 } of [{ s2: "" }]) { + } +}); +(function () { + var s2; + for ({ s2: s2 = 5 } of [{ s2: "" }]) { + } +}); +(function () { + var s3; + for ({ s3 = 5 } of [{ s3: "" }]) { + } +}); +(function () { + var s3; + for ({ s3: s3 = 5 } of [{ s3: "" }]) { + } +}); +(function () { + let y; + ({ y = 5 } = { y: 1 }); +}); +(function () { + let y; + ({ y: y = 5 } = { y: 1 }); +}); +(function () { + let y0; + ({ y0 = 5 } = { y0: 1 }); +}); +(function () { + let y0; + ({ y0: y0 = 5 } = { y0: 1 }); +}); +(function () { + let y1; + ({ y1 = 5 } = {}); +}); +(function () { + let y1; + ({ y1: y1 = 5 } = {}); +}); +(function () { + let y2, y3; + ({ y2 = 5, y3 = { x: 1 } } = {}); +}); +(function () { + let y2, y3; + ({ y2: y2 = 5, y3: y3 = { x: 1 } } = {}); +}); +(function () { + let y4, y5; + ({ y4 = 5, y5 = { x: 1 } } = {}); +}); +(function () { + let y4, y5; + ({ y4: y4 = 5, y5: y5 = { x: 1 } } = {}); +}); +(function () { + let z; + ({ z = { x: 5 } } = { z: { x: 1 } }); +}); +(function () { + let z; + ({ z: z = { x: 5 } } = { z: { x: 1 } }); +}); +(function () { + let a = { s = 5 }; +}); +function foo({ a = 4, b = { x: 5 } }) { +} diff --git a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols index ab79174a43a..49528257830 100644 --- a/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols +++ b/tests/baselines/reference/simpleArrowFunctionParameterReferencedInObjectLiteral1.symbols @@ -1,9 +1,9 @@ === tests/cases/compiler/simpleArrowFunctionParameterReferencedInObjectLiteral1.ts === [].map(() => [].map(p => ({ X: p }))); ->[].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) ->[].map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>[].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>[].map : Symbol(Array.map, Decl(lib.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >p : Symbol(p, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20)) >X : Symbol(X, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 27)) >p : Symbol(p, Decl(simpleArrowFunctionParameterReferencedInObjectLiteral1.ts, 0, 20)) diff --git a/tests/baselines/reference/sourceMap-FileWithComments.symbols b/tests/baselines/reference/sourceMap-FileWithComments.symbols index d065f6d4db8..50993547428 100644 --- a/tests/baselines/reference/sourceMap-FileWithComments.symbols +++ b/tests/baselines/reference/sourceMap-FileWithComments.symbols @@ -25,9 +25,9 @@ module Shapes { // Instance member getDist() { return Math.sqrt(this.x * this.x + this.y * this.y); } >getDist : Symbol(getDist, Decl(sourceMap-FileWithComments.ts, 12, 59)) ->Math.sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, 620, 27)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->sqrt : Symbol(Math.sqrt, Decl(lib.d.ts, 620, 27)) +>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(x, Decl(sourceMap-FileWithComments.ts, 12, 20)) >this : Symbol(Point, Decl(sourceMap-FileWithComments.ts, 7, 15)) >x : Symbol(x, Decl(sourceMap-FileWithComments.ts, 12, 20)) diff --git a/tests/baselines/reference/sourceMap-FileWithComments.types b/tests/baselines/reference/sourceMap-FileWithComments.types index f6b87c2e4c4..6f9ca201085 100644 --- a/tests/baselines/reference/sourceMap-FileWithComments.types +++ b/tests/baselines/reference/sourceMap-FileWithComments.types @@ -32,17 +32,17 @@ module Shapes { >this.x * this.x + this.y * this.y : number >this.x * this.x : number >this.x : number ->this : Point +>this : this >x : number >this.x : number ->this : Point +>this : this >x : number >this.y * this.y : number >this.y : number ->this : Point +>this : this >y : number >this.y : number ->this : Point +>this : this >y : number // Static member diff --git a/tests/baselines/reference/sourceMapValidationClass.types b/tests/baselines/reference/sourceMapValidationClass.types index e3b30a37227..3e5234b0d6e 100644 --- a/tests/baselines/reference/sourceMapValidationClass.types +++ b/tests/baselines/reference/sourceMapValidationClass.types @@ -14,7 +14,7 @@ class Greeter { >"

" + this.greeting : string >"

" : string >this.greeting : string ->this : Greeter +>this : this >greeting : string >"

" : string } @@ -30,7 +30,7 @@ class Greeter { return this.greeting; >this.greeting : string ->this : Greeter +>this : this >greeting : string } get greetings() { @@ -38,7 +38,7 @@ class Greeter { return this.greeting; >this.greeting : string ->this : Greeter +>this : this >greeting : string } set greetings(greetings: string) { @@ -48,7 +48,7 @@ class Greeter { this.greeting = greetings; >this.greeting = greetings : string >this.greeting : string ->this : Greeter +>this : this >greeting : string >greetings : string } diff --git a/tests/baselines/reference/sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.types b/tests/baselines/reference/sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.types index 266fe496193..a20410aa842 100644 --- a/tests/baselines/reference/sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.types +++ b/tests/baselines/reference/sourceMapValidationClassWithDefaultConstructorAndCapturedThisStatement.types @@ -10,6 +10,6 @@ class Greeter { >returnA : () => number >() => this.a : () => number >this.a : number ->this : Greeter +>this : this >a : number } diff --git a/tests/baselines/reference/sourceMapValidationClasses.symbols b/tests/baselines/reference/sourceMapValidationClasses.symbols index 7b5eb5ffdfa..8608cd4ed21 100644 --- a/tests/baselines/reference/sourceMapValidationClasses.symbols +++ b/tests/baselines/reference/sourceMapValidationClasses.symbols @@ -60,15 +60,15 @@ module Foo.Bar { for (var i = 0; i < restGreetings.length; i++) { >i : Symbol(i, Decl(sourceMapValidationClasses.ts, 23, 16)) >i : Symbol(i, Decl(sourceMapValidationClasses.ts, 23, 16)) ->restGreetings.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>restGreetings.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >restGreetings : Symbol(restGreetings, Decl(sourceMapValidationClasses.ts, 20, 35)) ->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >i : Symbol(i, Decl(sourceMapValidationClasses.ts, 23, 16)) greeters.push(new Greeter(restGreetings[i])); ->greeters.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>greeters.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >greeters : Symbol(greeters, Decl(sourceMapValidationClasses.ts, 21, 11)) ->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >Greeter : Symbol(Greeter, Decl(sourceMapValidationClasses.ts, 1, 17)) >restGreetings : Symbol(restGreetings, Decl(sourceMapValidationClasses.ts, 20, 35)) >i : Symbol(i, Decl(sourceMapValidationClasses.ts, 23, 16)) @@ -86,9 +86,9 @@ module Foo.Bar { for (var j = 0; j < b.length; j++) { >j : Symbol(j, Decl(sourceMapValidationClasses.ts, 32, 12)) >j : Symbol(j, Decl(sourceMapValidationClasses.ts, 32, 12)) ->b.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>b.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(sourceMapValidationClasses.ts, 30, 7)) ->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >j : Symbol(j, Decl(sourceMapValidationClasses.ts, 32, 12)) b[j].greet(); diff --git a/tests/baselines/reference/sourceMapValidationClasses.types b/tests/baselines/reference/sourceMapValidationClasses.types index 97e168d4701..5b3512c06c1 100644 --- a/tests/baselines/reference/sourceMapValidationClasses.types +++ b/tests/baselines/reference/sourceMapValidationClasses.types @@ -21,7 +21,7 @@ module Foo.Bar { >"

" + this.greeting : string >"

" : string >this.greeting : string ->this : Greeter +>this : this >greeting : string >"

" : string } diff --git a/tests/baselines/reference/sourceMapValidationDecorators.js b/tests/baselines/reference/sourceMapValidationDecorators.js index 5196d3b0dd8..04eb1d71078 100644 --- a/tests/baselines/reference/sourceMapValidationDecorators.js +++ b/tests/baselines/reference/sourceMapValidationDecorators.js @@ -56,12 +56,10 @@ class Greeter { //// [sourceMapValidationDecorators.js] var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { - if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); - switch (arguments.length) { - case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); - case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); - case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); - } + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; }; var __param = (this && this.__param) || function (paramIndex, decorator) { return function (target, key) { decorator(target, key, paramIndex); } @@ -91,31 +89,28 @@ var Greeter = (function () { configurable: true }); Greeter.x1 = 10; - Object.defineProperty(Greeter.prototype, "greet", - __decorate([ - PropertyDecorator1, - PropertyDecorator2(40) - ], Greeter.prototype, "greet", Object.getOwnPropertyDescriptor(Greeter.prototype, "greet"))); + __decorate([ + PropertyDecorator1, + PropertyDecorator2(40) + ], Greeter.prototype, "greet", null); __decorate([ PropertyDecorator1, PropertyDecorator2(50) - ], Greeter.prototype, "x"); - Object.defineProperty(Greeter.prototype, "fn", - __decorate([ - __param(0, ParameterDecorator1), - __param(0, ParameterDecorator2(70)) - ], Greeter.prototype, "fn", Object.getOwnPropertyDescriptor(Greeter.prototype, "fn"))); - Object.defineProperty(Greeter.prototype, "greetings", - __decorate([ - PropertyDecorator1, - PropertyDecorator2(80), - __param(0, ParameterDecorator1), - __param(0, ParameterDecorator2(90)) - ], Greeter.prototype, "greetings", Object.getOwnPropertyDescriptor(Greeter.prototype, "greetings"))); + ], Greeter.prototype, "x", void 0); + __decorate([ + __param(0, ParameterDecorator1), + __param(0, ParameterDecorator2(70)) + ], Greeter.prototype, "fn", null); + __decorate([ + PropertyDecorator1, + PropertyDecorator2(80), + __param(0, ParameterDecorator1), + __param(0, ParameterDecorator2(90)) + ], Greeter.prototype, "greetings", null); __decorate([ PropertyDecorator1, PropertyDecorator2(60) - ], Greeter, "x1"); + ], Greeter, "x1", void 0); Greeter = __decorate([ ClassDecorator1, ClassDecorator2(10), diff --git a/tests/baselines/reference/sourceMapValidationDecorators.js.map b/tests/baselines/reference/sourceMapValidationDecorators.js.map index 4cbb79f727d..4a8b3258659 100644 --- a/tests/baselines/reference/sourceMapValidationDecorators.js.map +++ b/tests/baselines/reference/sourceMapValidationDecorators.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationDecorators.js.map] -{"version":3,"file":"sourceMapValidationDecorators.js","sourceRoot":"","sources":["sourceMapValidationDecorators.ts"],"names":["Greeter","Greeter.constructor","Greeter.greet","Greeter.fn","Greeter.greetings"],"mappings":";;;;;;;;;;;AAOA;IAGIA,iBAGSA,QAAgBA;QAEvBC,WAEcA;aAFdA,WAEcA,CAFdA,sBAEcA,CAFdA,IAEcA;YAFdA,0BAEcA;;QAJPA,aAAQA,GAARA,QAAQA,CAAQA;IAKzBA,CAACA;IAIDD,uBAAKA,GAFLA;QAGIE,MAAMA,CAACA,MAAMA,GAAGA,IAAIA,CAACA,QAAQA,GAAGA,OAAOA,CAACA;IAC5CA,CAACA;IAUOF,oBAAEA,GAAVA,UAGEA,CAASA;QACPG,MAAMA,CAACA,IAAIA,CAACA,QAAQA,CAACA;IACzBA,CAACA;IAEDH,sBAEIA,8BAASA;aAFbA;YAGII,MAAMA,CAACA,IAAIA,CAACA,QAAQA,CAACA;QACzBA,CAACA;aAEDJ,UAGEA,SAAiBA;YACfI,IAAIA,CAACA,QAAQA,GAAGA,SAASA,CAACA;QAC9BA,CAACA;;;OAPAJ;IAbcA,UAAEA,GAAWA,EAAEA,CAACA;IAZ/BA,sBAEAA,0BAAKA;;YAFJA,kBAAkBA;YAClBA,kBAAkBA,CAACA,EAAEA,CAACA;WACvBA,0BAAKA,kCAALA,0BAAKA,IAEJA;IAEDA;QAACA,kBAAkBA;QAClBA,kBAAkBA,CAACA,EAAEA,CAACA;OACfA,sBAACA,EAASA;IAMlBA,sBAAQA,uBAAEA;;YACRA,WAACA,mBAAmBA,CAAAA;YACpBA,WAACA,mBAAmBA,CAACA,EAAEA,CAACA,CAAAA;WAFlBA,uBAAEA,kCAAFA,uBAAEA,IAKTA;IAEDA,sBAEIA,8BAASA;;YAFZA,kBAAkBA;YAClBA,kBAAkBA,CAACA,EAAEA,CAACA;YAMrBA,WAACA,mBAAmBA,CAAAA;YACpBA,WAACA,mBAAmBA,CAACA,EAAEA,CAACA,CAAAA;WANtBA,8BAASA,kCAATA,8BAASA,IAEZA;IAfDA;QAACA,kBAAkBA;QAClBA,kBAAkBA,CAACA,EAAEA,CAACA;OACRA,aAAEA,EAAcA;IAzBnCA;QAACA,eAAeA;QACfA,eAAeA,CAACA,EAAEA,CAACA;QAGdA,WAACA,mBAAmBA,CAAAA;QACpBA,WAACA,mBAAmBA,CAACA,EAAEA,CAACA,CAAAA;QAGxBA,WAACA,mBAAmBA,CAAAA;QACpBA,WAACA,mBAAmBA,CAACA,EAAEA,CAACA,CAAAA;gBAqC7BA;IAADA,cAACA;AAADA,CAACA,AA9CD,IA8CC"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationDecorators.js","sourceRoot":"","sources":["sourceMapValidationDecorators.ts"],"names":["Greeter","Greeter.constructor","Greeter.greet","Greeter.fn","Greeter.greetings"],"mappings":";;;;;;;;;AAOA;IAGIA,iBAGSA,QAAgBA;QAEvBC,WAEcA;aAFdA,WAEcA,CAFdA,sBAEcA,CAFdA,IAEcA;YAFdA,0BAEcA;;QAJPA,aAAQA,GAARA,QAAQA,CAAQA;IAKzBA,CAACA;IAIDD,uBAAKA,GAFLA;QAGIE,MAAMA,CAACA,MAAMA,GAAGA,IAAIA,CAACA,QAAQA,GAAGA,OAAOA,CAACA;IAC5CA,CAACA;IAUOF,oBAAEA,GAAVA,UAGEA,CAASA;QACPG,MAAMA,CAACA,IAAIA,CAACA,QAAQA,CAACA;IACzBA,CAACA;IAEDH,sBAEIA,8BAASA;aAFbA;YAGII,MAAMA,CAACA,IAAIA,CAACA,QAAQA,CAACA;QACzBA,CAACA;aAEDJ,UAGEA,SAAiBA;YACfI,IAAIA,CAACA,QAAQA,GAAGA,SAASA,CAACA;QAC9BA,CAACA;;;OAPAJ;IAbcA,UAAEA,GAAWA,EAAEA,CAACA;IAZ/BA;QAACA,kBAAkBA;QAClBA,kBAAkBA,CAACA,EAAEA,CAACA;OACvBA,0BAAKA,QAEJA;IAEDA;QAACA,kBAAkBA;QAClBA,kBAAkBA,CAACA,EAAEA,CAACA;OACfA,sBAACA,UAASA;IAMlBA;QACEA,WAACA,mBAAmBA,CAAAA;QACpBA,WAACA,mBAAmBA,CAACA,EAAEA,CAACA,CAAAA;OAFlBA,uBAAEA,QAKTA;IAEDA;QAACA,kBAAkBA;QAClBA,kBAAkBA,CAACA,EAAEA,CAACA;QAMrBA,WAACA,mBAAmBA,CAAAA;QACpBA,WAACA,mBAAmBA,CAACA,EAAEA,CAACA,CAAAA;OANtBA,8BAASA,QAEZA;IAfDA;QAACA,kBAAkBA;QAClBA,kBAAkBA,CAACA,EAAEA,CAACA;OACRA,aAAEA,UAAcA;IAzBnCA;QAACA,eAAeA;QACfA,eAAeA,CAACA,EAAEA,CAACA;QAGdA,WAACA,mBAAmBA,CAAAA;QACpBA,WAACA,mBAAmBA,CAACA,EAAEA,CAACA,CAAAA;QAGxBA,WAACA,mBAAmBA,CAAAA;QACpBA,WAACA,mBAAmBA,CAACA,EAAEA,CAACA,CAAAA;gBAqC7BA;IAADA,cAACA;AAADA,CAACA,AA9CD,IA8CC"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDecorators.sourcemap.txt b/tests/baselines/reference/sourceMapValidationDecorators.sourcemap.txt index b7036723a85..d9c8d0cc976 100644 --- a/tests/baselines/reference/sourceMapValidationDecorators.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationDecorators.sourcemap.txt @@ -9,12 +9,10 @@ emittedFile:tests/cases/compiler/sourceMapValidationDecorators.js sourceFile:sourceMapValidationDecorators.ts ------------------------------------------------------------------- >>>var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { ->>> if (typeof Reflect === "object" && typeof Reflect.decorate === "function") return Reflect.decorate(decorators, target, key, desc); ->>> switch (arguments.length) { ->>> case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target); ->>> case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0); ->>> case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc); ->>> } +>>> var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; +>>> if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); +>>> else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; +>>> return c > 3 && r && Object.defineProperty(target, key, r), r; >>>}; >>>var __param = (this && this.__param) || function (paramIndex, decorator) { >>> return function (target, key) { decorator(target, key, paramIndex); } @@ -30,7 +28,7 @@ sourceFile:sourceMapValidationDecorators.ts >declare function ParameterDecorator2(x: number): (target: Object, key: string | symbol, paramIndex: number) => void; > > -1 >Emitted(12, 1) Source(8, 1) + SourceIndex(0) +1 >Emitted(10, 1) Source(8, 1) + SourceIndex(0) --- >>> function Greeter(greeting) { 1->^^^^ @@ -45,9 +43,9 @@ sourceFile:sourceMapValidationDecorators.ts > @ParameterDecorator2(20) > public 3 > greeting: string -1->Emitted(13, 5) Source(11, 5) + SourceIndex(0) name (Greeter) -2 >Emitted(13, 22) Source(14, 14) + SourceIndex(0) name (Greeter) -3 >Emitted(13, 30) Source(14, 30) + SourceIndex(0) name (Greeter) +1->Emitted(11, 5) Source(11, 5) + SourceIndex(0) name (Greeter) +2 >Emitted(11, 22) Source(14, 14) + SourceIndex(0) name (Greeter) +3 >Emitted(11, 30) Source(14, 30) + SourceIndex(0) name (Greeter) --- >>> var b = []; 1 >^^^^^^^^ @@ -59,8 +57,8 @@ sourceFile:sourceMapValidationDecorators.ts 2 > @ParameterDecorator1 > @ParameterDecorator2(30) > ...b: string[] -1 >Emitted(14, 9) Source(16, 7) + SourceIndex(0) name (Greeter.constructor) -2 >Emitted(14, 20) Source(18, 21) + SourceIndex(0) name (Greeter.constructor) +1 >Emitted(12, 9) Source(16, 7) + SourceIndex(0) name (Greeter.constructor) +2 >Emitted(12, 20) Source(18, 21) + SourceIndex(0) name (Greeter.constructor) --- >>> for (var _i = 1; _i < arguments.length; _i++) { 1->^^^^^^^^^^^^^ @@ -81,12 +79,12 @@ sourceFile:sourceMapValidationDecorators.ts 6 > @ParameterDecorator1 > @ParameterDecorator2(30) > ...b: string[] -1->Emitted(15, 14) Source(16, 7) + SourceIndex(0) name (Greeter.constructor) -2 >Emitted(15, 25) Source(18, 21) + SourceIndex(0) name (Greeter.constructor) -3 >Emitted(15, 26) Source(16, 7) + SourceIndex(0) name (Greeter.constructor) -4 >Emitted(15, 48) Source(18, 21) + SourceIndex(0) name (Greeter.constructor) -5 >Emitted(15, 49) Source(16, 7) + SourceIndex(0) name (Greeter.constructor) -6 >Emitted(15, 53) Source(18, 21) + SourceIndex(0) name (Greeter.constructor) +1->Emitted(13, 14) Source(16, 7) + SourceIndex(0) name (Greeter.constructor) +2 >Emitted(13, 25) Source(18, 21) + SourceIndex(0) name (Greeter.constructor) +3 >Emitted(13, 26) Source(16, 7) + SourceIndex(0) name (Greeter.constructor) +4 >Emitted(13, 48) Source(18, 21) + SourceIndex(0) name (Greeter.constructor) +5 >Emitted(13, 49) Source(16, 7) + SourceIndex(0) name (Greeter.constructor) +6 >Emitted(13, 53) Source(18, 21) + SourceIndex(0) name (Greeter.constructor) --- >>> b[_i - 1] = arguments[_i]; 1 >^^^^^^^^^^^^ @@ -95,8 +93,8 @@ sourceFile:sourceMapValidationDecorators.ts 2 > @ParameterDecorator1 > @ParameterDecorator2(30) > ...b: string[] -1 >Emitted(16, 13) Source(16, 7) + SourceIndex(0) name (Greeter.constructor) -2 >Emitted(16, 39) Source(18, 21) + SourceIndex(0) name (Greeter.constructor) +1 >Emitted(14, 13) Source(16, 7) + SourceIndex(0) name (Greeter.constructor) +2 >Emitted(14, 39) Source(18, 21) + SourceIndex(0) name (Greeter.constructor) --- >>> } >>> this.greeting = greeting; @@ -110,11 +108,11 @@ sourceFile:sourceMapValidationDecorators.ts 3 > 4 > greeting 5 > : string -1 >Emitted(18, 9) Source(14, 14) + SourceIndex(0) name (Greeter.constructor) -2 >Emitted(18, 22) Source(14, 22) + SourceIndex(0) name (Greeter.constructor) -3 >Emitted(18, 25) Source(14, 14) + SourceIndex(0) name (Greeter.constructor) -4 >Emitted(18, 33) Source(14, 22) + SourceIndex(0) name (Greeter.constructor) -5 >Emitted(18, 34) Source(14, 30) + SourceIndex(0) name (Greeter.constructor) +1 >Emitted(16, 9) Source(14, 14) + SourceIndex(0) name (Greeter.constructor) +2 >Emitted(16, 22) Source(14, 22) + SourceIndex(0) name (Greeter.constructor) +3 >Emitted(16, 25) Source(14, 14) + SourceIndex(0) name (Greeter.constructor) +4 >Emitted(16, 33) Source(14, 22) + SourceIndex(0) name (Greeter.constructor) +5 >Emitted(16, 34) Source(14, 30) + SourceIndex(0) name (Greeter.constructor) --- >>> } 1 >^^^^ @@ -127,8 +125,8 @@ sourceFile:sourceMapValidationDecorators.ts > ...b: string[]) { > 2 > } -1 >Emitted(19, 5) Source(19, 5) + SourceIndex(0) name (Greeter.constructor) -2 >Emitted(19, 6) Source(19, 6) + SourceIndex(0) name (Greeter.constructor) +1 >Emitted(17, 5) Source(19, 5) + SourceIndex(0) name (Greeter.constructor) +2 >Emitted(17, 6) Source(19, 6) + SourceIndex(0) name (Greeter.constructor) --- >>> Greeter.prototype.greet = function () { 1->^^^^ @@ -142,9 +140,9 @@ sourceFile:sourceMapValidationDecorators.ts > 2 > greet 3 > -1->Emitted(20, 5) Source(23, 5) + SourceIndex(0) name (Greeter) -2 >Emitted(20, 28) Source(23, 10) + SourceIndex(0) name (Greeter) -3 >Emitted(20, 31) Source(21, 5) + SourceIndex(0) name (Greeter) +1->Emitted(18, 5) Source(23, 5) + SourceIndex(0) name (Greeter) +2 >Emitted(18, 28) Source(23, 10) + SourceIndex(0) name (Greeter) +3 >Emitted(18, 31) Source(21, 5) + SourceIndex(0) name (Greeter) --- >>> return "

" + this.greeting + "

"; 1->^^^^^^^^ @@ -172,17 +170,17 @@ sourceFile:sourceMapValidationDecorators.ts 9 > + 10> "" 11> ; -1->Emitted(21, 9) Source(24, 9) + SourceIndex(0) name (Greeter.greet) -2 >Emitted(21, 15) Source(24, 15) + SourceIndex(0) name (Greeter.greet) -3 >Emitted(21, 16) Source(24, 16) + SourceIndex(0) name (Greeter.greet) -4 >Emitted(21, 22) Source(24, 22) + SourceIndex(0) name (Greeter.greet) -5 >Emitted(21, 25) Source(24, 25) + SourceIndex(0) name (Greeter.greet) -6 >Emitted(21, 29) Source(24, 29) + SourceIndex(0) name (Greeter.greet) -7 >Emitted(21, 30) Source(24, 30) + SourceIndex(0) name (Greeter.greet) -8 >Emitted(21, 38) Source(24, 38) + SourceIndex(0) name (Greeter.greet) -9 >Emitted(21, 41) Source(24, 41) + SourceIndex(0) name (Greeter.greet) -10>Emitted(21, 48) Source(24, 48) + SourceIndex(0) name (Greeter.greet) -11>Emitted(21, 49) Source(24, 49) + SourceIndex(0) name (Greeter.greet) +1->Emitted(19, 9) Source(24, 9) + SourceIndex(0) name (Greeter.greet) +2 >Emitted(19, 15) Source(24, 15) + SourceIndex(0) name (Greeter.greet) +3 >Emitted(19, 16) Source(24, 16) + SourceIndex(0) name (Greeter.greet) +4 >Emitted(19, 22) Source(24, 22) + SourceIndex(0) name (Greeter.greet) +5 >Emitted(19, 25) Source(24, 25) + SourceIndex(0) name (Greeter.greet) +6 >Emitted(19, 29) Source(24, 29) + SourceIndex(0) name (Greeter.greet) +7 >Emitted(19, 30) Source(24, 30) + SourceIndex(0) name (Greeter.greet) +8 >Emitted(19, 38) Source(24, 38) + SourceIndex(0) name (Greeter.greet) +9 >Emitted(19, 41) Source(24, 41) + SourceIndex(0) name (Greeter.greet) +10>Emitted(19, 48) Source(24, 48) + SourceIndex(0) name (Greeter.greet) +11>Emitted(19, 49) Source(24, 49) + SourceIndex(0) name (Greeter.greet) --- >>> }; 1 >^^^^ @@ -191,8 +189,8 @@ sourceFile:sourceMapValidationDecorators.ts 1 > > 2 > } -1 >Emitted(22, 5) Source(25, 5) + SourceIndex(0) name (Greeter.greet) -2 >Emitted(22, 6) Source(25, 6) + SourceIndex(0) name (Greeter.greet) +1 >Emitted(20, 5) Source(25, 5) + SourceIndex(0) name (Greeter.greet) +2 >Emitted(20, 6) Source(25, 6) + SourceIndex(0) name (Greeter.greet) --- >>> Greeter.prototype.fn = function (x) { 1->^^^^ @@ -218,11 +216,11 @@ sourceFile:sourceMapValidationDecorators.ts > @ParameterDecorator2(70) > 5 > x: number -1->Emitted(23, 5) Source(35, 13) + SourceIndex(0) name (Greeter) -2 >Emitted(23, 25) Source(35, 15) + SourceIndex(0) name (Greeter) -3 >Emitted(23, 28) Source(35, 5) + SourceIndex(0) name (Greeter) -4 >Emitted(23, 38) Source(38, 7) + SourceIndex(0) name (Greeter) -5 >Emitted(23, 39) Source(38, 16) + SourceIndex(0) name (Greeter) +1->Emitted(21, 5) Source(35, 13) + SourceIndex(0) name (Greeter) +2 >Emitted(21, 25) Source(35, 15) + SourceIndex(0) name (Greeter) +3 >Emitted(21, 28) Source(35, 5) + SourceIndex(0) name (Greeter) +4 >Emitted(21, 38) Source(38, 7) + SourceIndex(0) name (Greeter) +5 >Emitted(21, 39) Source(38, 16) + SourceIndex(0) name (Greeter) --- >>> return this.greeting; 1 >^^^^^^^^ @@ -240,13 +238,13 @@ sourceFile:sourceMapValidationDecorators.ts 5 > . 6 > greeting 7 > ; -1 >Emitted(24, 9) Source(39, 9) + SourceIndex(0) name (Greeter.fn) -2 >Emitted(24, 15) Source(39, 15) + SourceIndex(0) name (Greeter.fn) -3 >Emitted(24, 16) Source(39, 16) + SourceIndex(0) name (Greeter.fn) -4 >Emitted(24, 20) Source(39, 20) + SourceIndex(0) name (Greeter.fn) -5 >Emitted(24, 21) Source(39, 21) + SourceIndex(0) name (Greeter.fn) -6 >Emitted(24, 29) Source(39, 29) + SourceIndex(0) name (Greeter.fn) -7 >Emitted(24, 30) Source(39, 30) + SourceIndex(0) name (Greeter.fn) +1 >Emitted(22, 9) Source(39, 9) + SourceIndex(0) name (Greeter.fn) +2 >Emitted(22, 15) Source(39, 15) + SourceIndex(0) name (Greeter.fn) +3 >Emitted(22, 16) Source(39, 16) + SourceIndex(0) name (Greeter.fn) +4 >Emitted(22, 20) Source(39, 20) + SourceIndex(0) name (Greeter.fn) +5 >Emitted(22, 21) Source(39, 21) + SourceIndex(0) name (Greeter.fn) +6 >Emitted(22, 29) Source(39, 29) + SourceIndex(0) name (Greeter.fn) +7 >Emitted(22, 30) Source(39, 30) + SourceIndex(0) name (Greeter.fn) --- >>> }; 1 >^^^^ @@ -255,8 +253,8 @@ sourceFile:sourceMapValidationDecorators.ts 1 > > 2 > } -1 >Emitted(25, 5) Source(40, 5) + SourceIndex(0) name (Greeter.fn) -2 >Emitted(25, 6) Source(40, 6) + SourceIndex(0) name (Greeter.fn) +1 >Emitted(23, 5) Source(40, 5) + SourceIndex(0) name (Greeter.fn) +2 >Emitted(23, 6) Source(40, 6) + SourceIndex(0) name (Greeter.fn) --- >>> Object.defineProperty(Greeter.prototype, "greetings", { 1->^^^^ @@ -269,15 +267,15 @@ sourceFile:sourceMapValidationDecorators.ts > @PropertyDecorator2(80) > get 3 > greetings -1->Emitted(26, 5) Source(42, 5) + SourceIndex(0) name (Greeter) -2 >Emitted(26, 27) Source(44, 9) + SourceIndex(0) name (Greeter) -3 >Emitted(26, 57) Source(44, 18) + SourceIndex(0) name (Greeter) +1->Emitted(24, 5) Source(42, 5) + SourceIndex(0) name (Greeter) +2 >Emitted(24, 27) Source(44, 9) + SourceIndex(0) name (Greeter) +3 >Emitted(24, 57) Source(44, 18) + SourceIndex(0) name (Greeter) --- >>> get: function () { 1 >^^^^^^^^^^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^-> 1 > -1 >Emitted(27, 14) Source(42, 5) + SourceIndex(0) name (Greeter) +1 >Emitted(25, 14) Source(42, 5) + SourceIndex(0) name (Greeter) --- >>> return this.greeting; 1->^^^^^^^^^^^^ @@ -297,13 +295,13 @@ sourceFile:sourceMapValidationDecorators.ts 5 > . 6 > greeting 7 > ; -1->Emitted(28, 13) Source(45, 9) + SourceIndex(0) name (Greeter.greetings) -2 >Emitted(28, 19) Source(45, 15) + SourceIndex(0) name (Greeter.greetings) -3 >Emitted(28, 20) Source(45, 16) + SourceIndex(0) name (Greeter.greetings) -4 >Emitted(28, 24) Source(45, 20) + SourceIndex(0) name (Greeter.greetings) -5 >Emitted(28, 25) Source(45, 21) + SourceIndex(0) name (Greeter.greetings) -6 >Emitted(28, 33) Source(45, 29) + SourceIndex(0) name (Greeter.greetings) -7 >Emitted(28, 34) Source(45, 30) + SourceIndex(0) name (Greeter.greetings) +1->Emitted(26, 13) Source(45, 9) + SourceIndex(0) name (Greeter.greetings) +2 >Emitted(26, 19) Source(45, 15) + SourceIndex(0) name (Greeter.greetings) +3 >Emitted(26, 20) Source(45, 16) + SourceIndex(0) name (Greeter.greetings) +4 >Emitted(26, 24) Source(45, 20) + SourceIndex(0) name (Greeter.greetings) +5 >Emitted(26, 25) Source(45, 21) + SourceIndex(0) name (Greeter.greetings) +6 >Emitted(26, 33) Source(45, 29) + SourceIndex(0) name (Greeter.greetings) +7 >Emitted(26, 34) Source(45, 30) + SourceIndex(0) name (Greeter.greetings) --- >>> }, 1 >^^^^^^^^ @@ -312,8 +310,8 @@ sourceFile:sourceMapValidationDecorators.ts 1 > > 2 > } -1 >Emitted(29, 9) Source(46, 5) + SourceIndex(0) name (Greeter.greetings) -2 >Emitted(29, 10) Source(46, 6) + SourceIndex(0) name (Greeter.greetings) +1 >Emitted(27, 9) Source(46, 5) + SourceIndex(0) name (Greeter.greetings) +2 >Emitted(27, 10) Source(46, 6) + SourceIndex(0) name (Greeter.greetings) --- >>> set: function (greetings) { 1->^^^^^^^^^^^^^ @@ -328,9 +326,9 @@ sourceFile:sourceMapValidationDecorators.ts > @ParameterDecorator2(90) > 3 > greetings: string -1->Emitted(30, 14) Source(48, 5) + SourceIndex(0) name (Greeter) -2 >Emitted(30, 24) Source(51, 7) + SourceIndex(0) name (Greeter) -3 >Emitted(30, 33) Source(51, 24) + SourceIndex(0) name (Greeter) +1->Emitted(28, 14) Source(48, 5) + SourceIndex(0) name (Greeter) +2 >Emitted(28, 24) Source(51, 7) + SourceIndex(0) name (Greeter) +3 >Emitted(28, 33) Source(51, 24) + SourceIndex(0) name (Greeter) --- >>> this.greeting = greetings; 1->^^^^^^^^^^^^ @@ -348,13 +346,13 @@ sourceFile:sourceMapValidationDecorators.ts 5 > = 6 > greetings 7 > ; -1->Emitted(31, 13) Source(52, 9) + SourceIndex(0) name (Greeter.greetings) -2 >Emitted(31, 17) Source(52, 13) + SourceIndex(0) name (Greeter.greetings) -3 >Emitted(31, 18) Source(52, 14) + SourceIndex(0) name (Greeter.greetings) -4 >Emitted(31, 26) Source(52, 22) + SourceIndex(0) name (Greeter.greetings) -5 >Emitted(31, 29) Source(52, 25) + SourceIndex(0) name (Greeter.greetings) -6 >Emitted(31, 38) Source(52, 34) + SourceIndex(0) name (Greeter.greetings) -7 >Emitted(31, 39) Source(52, 35) + SourceIndex(0) name (Greeter.greetings) +1->Emitted(29, 13) Source(52, 9) + SourceIndex(0) name (Greeter.greetings) +2 >Emitted(29, 17) Source(52, 13) + SourceIndex(0) name (Greeter.greetings) +3 >Emitted(29, 18) Source(52, 14) + SourceIndex(0) name (Greeter.greetings) +4 >Emitted(29, 26) Source(52, 22) + SourceIndex(0) name (Greeter.greetings) +5 >Emitted(29, 29) Source(52, 25) + SourceIndex(0) name (Greeter.greetings) +6 >Emitted(29, 38) Source(52, 34) + SourceIndex(0) name (Greeter.greetings) +7 >Emitted(29, 39) Source(52, 35) + SourceIndex(0) name (Greeter.greetings) --- >>> }, 1 >^^^^^^^^ @@ -363,8 +361,8 @@ sourceFile:sourceMapValidationDecorators.ts 1 > > 2 > } -1 >Emitted(32, 9) Source(53, 5) + SourceIndex(0) name (Greeter.greetings) -2 >Emitted(32, 10) Source(53, 6) + SourceIndex(0) name (Greeter.greetings) +1 >Emitted(30, 9) Source(53, 5) + SourceIndex(0) name (Greeter.greetings) +2 >Emitted(30, 10) Source(53, 6) + SourceIndex(0) name (Greeter.greetings) --- >>> enumerable: true, >>> configurable: true @@ -372,7 +370,7 @@ sourceFile:sourceMapValidationDecorators.ts 1->^^^^^^^ 2 > ^^^^^^^^^^^^^^-> 1-> -1->Emitted(35, 8) Source(46, 6) + SourceIndex(0) name (Greeter) +1->Emitted(33, 8) Source(46, 6) + SourceIndex(0) name (Greeter) --- >>> Greeter.x1 = 10; 1->^^^^ @@ -380,87 +378,22 @@ sourceFile:sourceMapValidationDecorators.ts 3 > ^^^ 4 > ^^ 5 > ^ -6 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> 1-> 2 > x1 3 > : number = 4 > 10 5 > ; -1->Emitted(36, 5) Source(33, 20) + SourceIndex(0) name (Greeter) -2 >Emitted(36, 15) Source(33, 22) + SourceIndex(0) name (Greeter) -3 >Emitted(36, 18) Source(33, 33) + SourceIndex(0) name (Greeter) -4 >Emitted(36, 20) Source(33, 35) + SourceIndex(0) name (Greeter) -5 >Emitted(36, 21) Source(33, 36) + SourceIndex(0) name (Greeter) ---- ->>> Object.defineProperty(Greeter.prototype, "greet", -1->^^^^ -2 > ^^^^^^^^^^^^^^^^^^^^^^ -3 > ^^^^^^^^^^^^^^^^^^^^^^^^^^ -1-> -2 > @PropertyDecorator1 - > @PropertyDecorator2(40) - > -3 > greet -1->Emitted(37, 5) Source(21, 5) + SourceIndex(0) name (Greeter) -2 >Emitted(37, 27) Source(23, 5) + SourceIndex(0) name (Greeter) -3 >Emitted(37, 53) Source(23, 10) + SourceIndex(0) name (Greeter) ---- ->>> __decorate([ ->>> PropertyDecorator1, -1 >^^^^^^^^^^^^ -2 > ^^^^^^^^^^^^^^^^^^ -3 > ^^^^^-> -1 > -2 > PropertyDecorator1 -1 >Emitted(39, 13) Source(21, 6) + SourceIndex(0) name (Greeter) -2 >Emitted(39, 31) Source(21, 24) + SourceIndex(0) name (Greeter) ---- ->>> PropertyDecorator2(40) -1->^^^^^^^^^^^^ -2 > ^^^^^^^^^^^^^^^^^^ -3 > ^ -4 > ^^ -5 > ^ -6 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1-> - > @ -2 > PropertyDecorator2 -3 > ( -4 > 40 -5 > ) -1->Emitted(40, 13) Source(22, 6) + SourceIndex(0) name (Greeter) -2 >Emitted(40, 31) Source(22, 24) + SourceIndex(0) name (Greeter) -3 >Emitted(40, 32) Source(22, 25) + SourceIndex(0) name (Greeter) -4 >Emitted(40, 34) Source(22, 27) + SourceIndex(0) name (Greeter) -5 >Emitted(40, 35) Source(22, 28) + SourceIndex(0) name (Greeter) ---- ->>> ], Greeter.prototype, "greet", Object.getOwnPropertyDescriptor(Greeter.prototype, "greet"))); -1->^^^^^^^^^^^ -2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^ -3 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -4 > ^^^^^^^^^^^^^^^^^^^^^^^^^^ -5 > ^^^^ -1-> - > -2 > greet -3 > -4 > greet -5 > () { - > return "

" + this.greeting + "

"; - > } -1->Emitted(41, 12) Source(23, 5) + SourceIndex(0) name (Greeter) -2 >Emitted(41, 38) Source(23, 10) + SourceIndex(0) name (Greeter) -3 >Emitted(41, 72) Source(23, 5) + SourceIndex(0) name (Greeter) -4 >Emitted(41, 98) Source(23, 10) + SourceIndex(0) name (Greeter) -5 >Emitted(41, 102) Source(25, 6) + SourceIndex(0) name (Greeter) +1->Emitted(34, 5) Source(33, 20) + SourceIndex(0) name (Greeter) +2 >Emitted(34, 15) Source(33, 22) + SourceIndex(0) name (Greeter) +3 >Emitted(34, 18) Source(33, 33) + SourceIndex(0) name (Greeter) +4 >Emitted(34, 20) Source(33, 35) + SourceIndex(0) name (Greeter) +5 >Emitted(34, 21) Source(33, 36) + SourceIndex(0) name (Greeter) --- >>> __decorate([ 1 >^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > - > - > -1 >Emitted(42, 5) Source(27, 5) + SourceIndex(0) name (Greeter) +1 > +1 >Emitted(35, 5) Source(21, 5) + SourceIndex(0) name (Greeter) --- >>> PropertyDecorator1, 1->^^^^^^^^ @@ -468,8 +401,58 @@ sourceFile:sourceMapValidationDecorators.ts 3 > ^^^^^-> 1->@ 2 > PropertyDecorator1 -1->Emitted(43, 9) Source(27, 6) + SourceIndex(0) name (Greeter) -2 >Emitted(43, 27) Source(27, 24) + SourceIndex(0) name (Greeter) +1->Emitted(36, 9) Source(21, 6) + SourceIndex(0) name (Greeter) +2 >Emitted(36, 27) Source(21, 24) + SourceIndex(0) name (Greeter) +--- +>>> PropertyDecorator2(40) +1->^^^^^^^^ +2 > ^^^^^^^^^^^^^^^^^^ +3 > ^ +4 > ^^ +5 > ^ +6 > ^^^^^^^^^^^^-> +1-> + > @ +2 > PropertyDecorator2 +3 > ( +4 > 40 +5 > ) +1->Emitted(37, 9) Source(22, 6) + SourceIndex(0) name (Greeter) +2 >Emitted(37, 27) Source(22, 24) + SourceIndex(0) name (Greeter) +3 >Emitted(37, 28) Source(22, 25) + SourceIndex(0) name (Greeter) +4 >Emitted(37, 30) Source(22, 27) + SourceIndex(0) name (Greeter) +5 >Emitted(37, 31) Source(22, 28) + SourceIndex(0) name (Greeter) +--- +>>> ], Greeter.prototype, "greet", null); +1->^^^^^^^ +2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^ +3 > ^^^^^^^^ +1-> + > +2 > greet +3 > () { + > return "

" + this.greeting + "

"; + > } +1->Emitted(38, 8) Source(23, 5) + SourceIndex(0) name (Greeter) +2 >Emitted(38, 34) Source(23, 10) + SourceIndex(0) name (Greeter) +3 >Emitted(38, 42) Source(25, 6) + SourceIndex(0) name (Greeter) +--- +>>> __decorate([ +1 >^^^^ +2 > ^^^^^^^^^^^^^^^^^^^^^^^^-> +1 > + > + > +1 >Emitted(39, 5) Source(27, 5) + SourceIndex(0) name (Greeter) +--- +>>> PropertyDecorator1, +1->^^^^^^^^ +2 > ^^^^^^^^^^^^^^^^^^ +3 > ^^^^^-> +1->@ +2 > PropertyDecorator1 +1->Emitted(40, 9) Source(27, 6) + SourceIndex(0) name (Greeter) +2 >Emitted(40, 27) Source(27, 24) + SourceIndex(0) name (Greeter) --- >>> PropertyDecorator2(50) 1->^^^^^^^^ @@ -477,163 +460,141 @@ sourceFile:sourceMapValidationDecorators.ts 3 > ^ 4 > ^^ 5 > ^ -6 > ^^-> +6 > ^^^^^^^^^^-> 1-> > @ 2 > PropertyDecorator2 3 > ( 4 > 50 5 > ) -1->Emitted(44, 9) Source(28, 6) + SourceIndex(0) name (Greeter) -2 >Emitted(44, 27) Source(28, 24) + SourceIndex(0) name (Greeter) -3 >Emitted(44, 28) Source(28, 25) + SourceIndex(0) name (Greeter) -4 >Emitted(44, 30) Source(28, 27) + SourceIndex(0) name (Greeter) -5 >Emitted(44, 31) Source(28, 28) + SourceIndex(0) name (Greeter) +1->Emitted(41, 9) Source(28, 6) + SourceIndex(0) name (Greeter) +2 >Emitted(41, 27) Source(28, 24) + SourceIndex(0) name (Greeter) +3 >Emitted(41, 28) Source(28, 25) + SourceIndex(0) name (Greeter) +4 >Emitted(41, 30) Source(28, 27) + SourceIndex(0) name (Greeter) +5 >Emitted(41, 31) Source(28, 28) + SourceIndex(0) name (Greeter) --- ->>> ], Greeter.prototype, "x"); +>>> ], Greeter.prototype, "x", void 0); 1->^^^^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^^ -3 > ^^ -4 > ^^^^^^^^^^^^^^^^^^^^-> +3 > ^^^^^^^^^^ 1-> > private 2 > x 3 > : string; -1->Emitted(45, 8) Source(29, 13) + SourceIndex(0) name (Greeter) -2 >Emitted(45, 30) Source(29, 14) + SourceIndex(0) name (Greeter) -3 >Emitted(45, 32) Source(29, 23) + SourceIndex(0) name (Greeter) +1->Emitted(42, 8) Source(29, 13) + SourceIndex(0) name (Greeter) +2 >Emitted(42, 30) Source(29, 14) + SourceIndex(0) name (Greeter) +3 >Emitted(42, 40) Source(29, 23) + SourceIndex(0) name (Greeter) --- ->>> Object.defineProperty(Greeter.prototype, "fn", -1->^^^^ -2 > ^^^^^^^^^^^^^^^^^^^^^^ -3 > ^^^^^^^^^^^^^^^^^^^^^^^ -1-> +>>> __decorate([ +1 >^^^^ +2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> +1 > > > @PropertyDecorator1 > @PropertyDecorator2(60) > private static x1: number = 10; > > -2 > private -3 > fn -1->Emitted(46, 5) Source(35, 5) + SourceIndex(0) name (Greeter) -2 >Emitted(46, 27) Source(35, 13) + SourceIndex(0) name (Greeter) -3 >Emitted(46, 50) Source(35, 15) + SourceIndex(0) name (Greeter) +1 >Emitted(43, 5) Source(35, 5) + SourceIndex(0) name (Greeter) --- ->>> __decorate([ ->>> __param(0, ParameterDecorator1), -1 >^^^^^^^^^^^^ -2 > ^^^^^^^^^^^ -3 > ^^^^^^^^^^^^^^^^^^^ -4 > ^ -5 > ^^^^^-> -1 >( +>>> __param(0, ParameterDecorator1), +1->^^^^^^^^ +2 > ^^^^^^^^^^^ +3 > ^^^^^^^^^^^^^^^^^^^ +4 > ^ +5 > ^^^^^-> +1->private fn( > -2 > @ -3 > ParameterDecorator1 -4 > -1 >Emitted(48, 13) Source(36, 7) + SourceIndex(0) name (Greeter) -2 >Emitted(48, 24) Source(36, 8) + SourceIndex(0) name (Greeter) -3 >Emitted(48, 43) Source(36, 27) + SourceIndex(0) name (Greeter) -4 >Emitted(48, 44) Source(36, 27) + SourceIndex(0) name (Greeter) +2 > @ +3 > ParameterDecorator1 +4 > +1->Emitted(44, 9) Source(36, 7) + SourceIndex(0) name (Greeter) +2 >Emitted(44, 20) Source(36, 8) + SourceIndex(0) name (Greeter) +3 >Emitted(44, 39) Source(36, 27) + SourceIndex(0) name (Greeter) +4 >Emitted(44, 40) Source(36, 27) + SourceIndex(0) name (Greeter) --- ->>> __param(0, ParameterDecorator2(70)) -1->^^^^^^^^^^^^ -2 > ^^^^^^^^^^^ -3 > ^^^^^^^^^^^^^^^^^^^ -4 > ^ -5 > ^^ -6 > ^ -7 > ^ -8 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> +>>> __param(0, ParameterDecorator2(70)) +1->^^^^^^^^ +2 > ^^^^^^^^^^^ +3 > ^^^^^^^^^^^^^^^^^^^ +4 > ^ +5 > ^^ +6 > ^ +7 > ^ 1-> > -2 > @ -3 > ParameterDecorator2 -4 > ( -5 > 70 -6 > ) -7 > -1->Emitted(49, 13) Source(37, 7) + SourceIndex(0) name (Greeter) -2 >Emitted(49, 24) Source(37, 8) + SourceIndex(0) name (Greeter) -3 >Emitted(49, 43) Source(37, 27) + SourceIndex(0) name (Greeter) -4 >Emitted(49, 44) Source(37, 28) + SourceIndex(0) name (Greeter) -5 >Emitted(49, 46) Source(37, 30) + SourceIndex(0) name (Greeter) -6 >Emitted(49, 47) Source(37, 31) + SourceIndex(0) name (Greeter) -7 >Emitted(49, 48) Source(37, 31) + SourceIndex(0) name (Greeter) +2 > @ +3 > ParameterDecorator2 +4 > ( +5 > 70 +6 > ) +7 > +1->Emitted(45, 9) Source(37, 7) + SourceIndex(0) name (Greeter) +2 >Emitted(45, 20) Source(37, 8) + SourceIndex(0) name (Greeter) +3 >Emitted(45, 39) Source(37, 27) + SourceIndex(0) name (Greeter) +4 >Emitted(45, 40) Source(37, 28) + SourceIndex(0) name (Greeter) +5 >Emitted(45, 42) Source(37, 30) + SourceIndex(0) name (Greeter) +6 >Emitted(45, 43) Source(37, 31) + SourceIndex(0) name (Greeter) +7 >Emitted(45, 44) Source(37, 31) + SourceIndex(0) name (Greeter) --- ->>> ], Greeter.prototype, "fn", Object.getOwnPropertyDescriptor(Greeter.prototype, "fn"))); -1->^^^^^^^^^^^ -2 > ^^^^^^^^^^^^^^^^^^^^^^^ -3 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -4 > ^^^^^^^^^^^^^^^^^^^^^^^ -5 > ^^^^ -1-> -2 > fn -3 > -4 > fn -5 > ( - > @ParameterDecorator1 - > @ParameterDecorator2(70) - > x: number) { - > return this.greeting; - > } -1->Emitted(50, 12) Source(35, 13) + SourceIndex(0) name (Greeter) -2 >Emitted(50, 35) Source(35, 15) + SourceIndex(0) name (Greeter) -3 >Emitted(50, 69) Source(35, 13) + SourceIndex(0) name (Greeter) -4 >Emitted(50, 92) Source(35, 15) + SourceIndex(0) name (Greeter) -5 >Emitted(50, 96) Source(40, 6) + SourceIndex(0) name (Greeter) +>>> ], Greeter.prototype, "fn", null); +1 >^^^^^^^ +2 > ^^^^^^^^^^^^^^^^^^^^^^^ +3 > ^^^^^^^^ +1 > +2 > fn +3 > ( + > @ParameterDecorator1 + > @ParameterDecorator2(70) + > x: number) { + > return this.greeting; + > } +1 >Emitted(46, 8) Source(35, 13) + SourceIndex(0) name (Greeter) +2 >Emitted(46, 31) Source(35, 15) + SourceIndex(0) name (Greeter) +3 >Emitted(46, 39) Source(40, 6) + SourceIndex(0) name (Greeter) --- ->>> Object.defineProperty(Greeter.prototype, "greetings", +>>> __decorate([ 1 >^^^^ -2 > ^^^^^^^^^^^^^^^^^^^^^^ -3 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +2 > ^^^^^^^^^^^^^^^^^^^^^^^^-> 1 > > > -2 > @PropertyDecorator1 - > @PropertyDecorator2(80) - > get -3 > greetings -1 >Emitted(51, 5) Source(42, 5) + SourceIndex(0) name (Greeter) -2 >Emitted(51, 27) Source(44, 9) + SourceIndex(0) name (Greeter) -3 >Emitted(51, 57) Source(44, 18) + SourceIndex(0) name (Greeter) +1 >Emitted(47, 5) Source(42, 5) + SourceIndex(0) name (Greeter) --- ->>> __decorate([ ->>> PropertyDecorator1, -1 >^^^^^^^^^^^^ -2 > ^^^^^^^^^^^^^^^^^^ -3 > ^^^^^^-> -1 > -2 > PropertyDecorator1 -1 >Emitted(53, 13) Source(42, 6) + SourceIndex(0) name (Greeter) -2 >Emitted(53, 31) Source(42, 24) + SourceIndex(0) name (Greeter) +>>> PropertyDecorator1, +1->^^^^^^^^ +2 > ^^^^^^^^^^^^^^^^^^ +3 > ^^^^^^-> +1->@ +2 > PropertyDecorator1 +1->Emitted(48, 9) Source(42, 6) + SourceIndex(0) name (Greeter) +2 >Emitted(48, 27) Source(42, 24) + SourceIndex(0) name (Greeter) --- ->>> PropertyDecorator2(80), -1->^^^^^^^^^^^^ -2 > ^^^^^^^^^^^^^^^^^^ -3 > ^ -4 > ^^ -5 > ^ -6 > ^^^^^^^^^^^-> +>>> PropertyDecorator2(80), +1->^^^^^^^^ +2 > ^^^^^^^^^^^^^^^^^^ +3 > ^ +4 > ^^ +5 > ^ +6 > ^^^^^^^^^^^-> 1-> > @ -2 > PropertyDecorator2 -3 > ( -4 > 80 -5 > ) -1->Emitted(54, 13) Source(43, 6) + SourceIndex(0) name (Greeter) -2 >Emitted(54, 31) Source(43, 24) + SourceIndex(0) name (Greeter) -3 >Emitted(54, 32) Source(43, 25) + SourceIndex(0) name (Greeter) -4 >Emitted(54, 34) Source(43, 27) + SourceIndex(0) name (Greeter) -5 >Emitted(54, 35) Source(43, 28) + SourceIndex(0) name (Greeter) +2 > PropertyDecorator2 +3 > ( +4 > 80 +5 > ) +1->Emitted(49, 9) Source(43, 6) + SourceIndex(0) name (Greeter) +2 >Emitted(49, 27) Source(43, 24) + SourceIndex(0) name (Greeter) +3 >Emitted(49, 28) Source(43, 25) + SourceIndex(0) name (Greeter) +4 >Emitted(49, 30) Source(43, 27) + SourceIndex(0) name (Greeter) +5 >Emitted(49, 31) Source(43, 28) + SourceIndex(0) name (Greeter) --- ->>> __param(0, ParameterDecorator1), -1->^^^^^^^^^^^^ -2 > ^^^^^^^^^^^ -3 > ^^^^^^^^^^^^^^^^^^^ -4 > ^ -5 > ^^^^^-> +>>> __param(0, ParameterDecorator1), +1->^^^^^^^^ +2 > ^^^^^^^^^^^ +3 > ^^^^^^^^^^^^^^^^^^^ +4 > ^ +5 > ^^^^^-> 1-> > get greetings() { > return this.greeting; @@ -641,63 +602,57 @@ sourceFile:sourceMapValidationDecorators.ts > > set greetings( > -2 > @ -3 > ParameterDecorator1 -4 > -1->Emitted(55, 13) Source(49, 7) + SourceIndex(0) name (Greeter) -2 >Emitted(55, 24) Source(49, 8) + SourceIndex(0) name (Greeter) -3 >Emitted(55, 43) Source(49, 27) + SourceIndex(0) name (Greeter) -4 >Emitted(55, 44) Source(49, 27) + SourceIndex(0) name (Greeter) +2 > @ +3 > ParameterDecorator1 +4 > +1->Emitted(50, 9) Source(49, 7) + SourceIndex(0) name (Greeter) +2 >Emitted(50, 20) Source(49, 8) + SourceIndex(0) name (Greeter) +3 >Emitted(50, 39) Source(49, 27) + SourceIndex(0) name (Greeter) +4 >Emitted(50, 40) Source(49, 27) + SourceIndex(0) name (Greeter) --- ->>> __param(0, ParameterDecorator2(90)) -1->^^^^^^^^^^^^ -2 > ^^^^^^^^^^^ -3 > ^^^^^^^^^^^^^^^^^^^ -4 > ^ -5 > ^^ -6 > ^ -7 > ^ -8 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> +>>> __param(0, ParameterDecorator2(90)) +1->^^^^^^^^ +2 > ^^^^^^^^^^^ +3 > ^^^^^^^^^^^^^^^^^^^ +4 > ^ +5 > ^^ +6 > ^ +7 > ^ +8 > ^^^-> 1-> > -2 > @ -3 > ParameterDecorator2 -4 > ( -5 > 90 -6 > ) -7 > -1->Emitted(56, 13) Source(50, 7) + SourceIndex(0) name (Greeter) -2 >Emitted(56, 24) Source(50, 8) + SourceIndex(0) name (Greeter) -3 >Emitted(56, 43) Source(50, 27) + SourceIndex(0) name (Greeter) -4 >Emitted(56, 44) Source(50, 28) + SourceIndex(0) name (Greeter) -5 >Emitted(56, 46) Source(50, 30) + SourceIndex(0) name (Greeter) -6 >Emitted(56, 47) Source(50, 31) + SourceIndex(0) name (Greeter) -7 >Emitted(56, 48) Source(50, 31) + SourceIndex(0) name (Greeter) +2 > @ +3 > ParameterDecorator2 +4 > ( +5 > 90 +6 > ) +7 > +1->Emitted(51, 9) Source(50, 7) + SourceIndex(0) name (Greeter) +2 >Emitted(51, 20) Source(50, 8) + SourceIndex(0) name (Greeter) +3 >Emitted(51, 39) Source(50, 27) + SourceIndex(0) name (Greeter) +4 >Emitted(51, 40) Source(50, 28) + SourceIndex(0) name (Greeter) +5 >Emitted(51, 42) Source(50, 30) + SourceIndex(0) name (Greeter) +6 >Emitted(51, 43) Source(50, 31) + SourceIndex(0) name (Greeter) +7 >Emitted(51, 44) Source(50, 31) + SourceIndex(0) name (Greeter) --- ->>> ], Greeter.prototype, "greetings", Object.getOwnPropertyDescriptor(Greeter.prototype, "greetings"))); -1->^^^^^^^^^^^ -2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -3 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -4 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -5 > ^^^^ +>>> ], Greeter.prototype, "greetings", null); +1->^^^^^^^ +2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +3 > ^^^^^^^^ 1-> -2 > greetings -3 > -4 > greetings -5 > () { - > return this.greeting; - > } -1->Emitted(57, 12) Source(44, 9) + SourceIndex(0) name (Greeter) -2 >Emitted(57, 42) Source(44, 18) + SourceIndex(0) name (Greeter) -3 >Emitted(57, 76) Source(44, 9) + SourceIndex(0) name (Greeter) -4 >Emitted(57, 106) Source(44, 18) + SourceIndex(0) name (Greeter) -5 >Emitted(57, 110) Source(46, 6) + SourceIndex(0) name (Greeter) +2 > greetings +3 > () { + > return this.greeting; + > } +1->Emitted(52, 8) Source(44, 9) + SourceIndex(0) name (Greeter) +2 >Emitted(52, 38) Source(44, 18) + SourceIndex(0) name (Greeter) +3 >Emitted(52, 46) Source(46, 6) + SourceIndex(0) name (Greeter) --- >>> __decorate([ 1 >^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^^^^-> 1 > -1 >Emitted(58, 5) Source(31, 5) + SourceIndex(0) name (Greeter) +1 >Emitted(53, 5) Source(31, 5) + SourceIndex(0) name (Greeter) --- >>> PropertyDecorator1, 1->^^^^^^^^ @@ -705,8 +660,8 @@ sourceFile:sourceMapValidationDecorators.ts 3 > ^^^^^-> 1->@ 2 > PropertyDecorator1 -1->Emitted(59, 9) Source(31, 6) + SourceIndex(0) name (Greeter) -2 >Emitted(59, 27) Source(31, 24) + SourceIndex(0) name (Greeter) +1->Emitted(54, 9) Source(31, 6) + SourceIndex(0) name (Greeter) +2 >Emitted(54, 27) Source(31, 24) + SourceIndex(0) name (Greeter) --- >>> PropertyDecorator2(60) 1->^^^^^^^^ @@ -714,36 +669,36 @@ sourceFile:sourceMapValidationDecorators.ts 3 > ^ 4 > ^^ 5 > ^ +6 > ^-> 1-> > @ 2 > PropertyDecorator2 3 > ( 4 > 60 5 > ) -1->Emitted(60, 9) Source(32, 6) + SourceIndex(0) name (Greeter) -2 >Emitted(60, 27) Source(32, 24) + SourceIndex(0) name (Greeter) -3 >Emitted(60, 28) Source(32, 25) + SourceIndex(0) name (Greeter) -4 >Emitted(60, 30) Source(32, 27) + SourceIndex(0) name (Greeter) -5 >Emitted(60, 31) Source(32, 28) + SourceIndex(0) name (Greeter) +1->Emitted(55, 9) Source(32, 6) + SourceIndex(0) name (Greeter) +2 >Emitted(55, 27) Source(32, 24) + SourceIndex(0) name (Greeter) +3 >Emitted(55, 28) Source(32, 25) + SourceIndex(0) name (Greeter) +4 >Emitted(55, 30) Source(32, 27) + SourceIndex(0) name (Greeter) +5 >Emitted(55, 31) Source(32, 28) + SourceIndex(0) name (Greeter) --- ->>> ], Greeter, "x1"); -1 >^^^^^^^ +>>> ], Greeter, "x1", void 0); +1->^^^^^^^ 2 > ^^^^^^^^^^^^^ -3 > ^^ -4 > ^^^^^-> -1 > +3 > ^^^^^^^^^^ +1-> > private static 2 > x1 3 > : number = 10; -1 >Emitted(61, 8) Source(33, 20) + SourceIndex(0) name (Greeter) -2 >Emitted(61, 21) Source(33, 22) + SourceIndex(0) name (Greeter) -3 >Emitted(61, 23) Source(33, 36) + SourceIndex(0) name (Greeter) +1->Emitted(56, 8) Source(33, 20) + SourceIndex(0) name (Greeter) +2 >Emitted(56, 21) Source(33, 22) + SourceIndex(0) name (Greeter) +3 >Emitted(56, 31) Source(33, 36) + SourceIndex(0) name (Greeter) --- >>> Greeter = __decorate([ -1->^^^^ +1 >^^^^ 2 > ^^^^^^^^^^^^^^^^^^^^^-> -1-> -1->Emitted(62, 5) Source(8, 1) + SourceIndex(0) name (Greeter) +1 > +1 >Emitted(57, 5) Source(8, 1) + SourceIndex(0) name (Greeter) --- >>> ClassDecorator1, 1->^^^^^^^^ @@ -751,8 +706,8 @@ sourceFile:sourceMapValidationDecorators.ts 3 > ^^^^^^-> 1->@ 2 > ClassDecorator1 -1->Emitted(63, 9) Source(8, 2) + SourceIndex(0) name (Greeter) -2 >Emitted(63, 24) Source(8, 17) + SourceIndex(0) name (Greeter) +1->Emitted(58, 9) Source(8, 2) + SourceIndex(0) name (Greeter) +2 >Emitted(58, 24) Source(8, 17) + SourceIndex(0) name (Greeter) --- >>> ClassDecorator2(10), 1->^^^^^^^^ @@ -767,11 +722,11 @@ sourceFile:sourceMapValidationDecorators.ts 3 > ( 4 > 10 5 > ) -1->Emitted(64, 9) Source(9, 2) + SourceIndex(0) name (Greeter) -2 >Emitted(64, 24) Source(9, 17) + SourceIndex(0) name (Greeter) -3 >Emitted(64, 25) Source(9, 18) + SourceIndex(0) name (Greeter) -4 >Emitted(64, 27) Source(9, 20) + SourceIndex(0) name (Greeter) -5 >Emitted(64, 28) Source(9, 21) + SourceIndex(0) name (Greeter) +1->Emitted(59, 9) Source(9, 2) + SourceIndex(0) name (Greeter) +2 >Emitted(59, 24) Source(9, 17) + SourceIndex(0) name (Greeter) +3 >Emitted(59, 25) Source(9, 18) + SourceIndex(0) name (Greeter) +4 >Emitted(59, 27) Source(9, 20) + SourceIndex(0) name (Greeter) +5 >Emitted(59, 28) Source(9, 21) + SourceIndex(0) name (Greeter) --- >>> __param(0, ParameterDecorator1), 1->^^^^^^^^ @@ -786,10 +741,10 @@ sourceFile:sourceMapValidationDecorators.ts 2 > @ 3 > ParameterDecorator1 4 > -1->Emitted(65, 9) Source(12, 7) + SourceIndex(0) name (Greeter) -2 >Emitted(65, 20) Source(12, 8) + SourceIndex(0) name (Greeter) -3 >Emitted(65, 39) Source(12, 27) + SourceIndex(0) name (Greeter) -4 >Emitted(65, 40) Source(12, 27) + SourceIndex(0) name (Greeter) +1->Emitted(60, 9) Source(12, 7) + SourceIndex(0) name (Greeter) +2 >Emitted(60, 20) Source(12, 8) + SourceIndex(0) name (Greeter) +3 >Emitted(60, 39) Source(12, 27) + SourceIndex(0) name (Greeter) +4 >Emitted(60, 40) Source(12, 27) + SourceIndex(0) name (Greeter) --- >>> __param(0, ParameterDecorator2(20)), 1->^^^^^^^^ @@ -807,13 +762,13 @@ sourceFile:sourceMapValidationDecorators.ts 5 > 20 6 > ) 7 > -1->Emitted(66, 9) Source(13, 7) + SourceIndex(0) name (Greeter) -2 >Emitted(66, 20) Source(13, 8) + SourceIndex(0) name (Greeter) -3 >Emitted(66, 39) Source(13, 27) + SourceIndex(0) name (Greeter) -4 >Emitted(66, 40) Source(13, 28) + SourceIndex(0) name (Greeter) -5 >Emitted(66, 42) Source(13, 30) + SourceIndex(0) name (Greeter) -6 >Emitted(66, 43) Source(13, 31) + SourceIndex(0) name (Greeter) -7 >Emitted(66, 44) Source(13, 31) + SourceIndex(0) name (Greeter) +1->Emitted(61, 9) Source(13, 7) + SourceIndex(0) name (Greeter) +2 >Emitted(61, 20) Source(13, 8) + SourceIndex(0) name (Greeter) +3 >Emitted(61, 39) Source(13, 27) + SourceIndex(0) name (Greeter) +4 >Emitted(61, 40) Source(13, 28) + SourceIndex(0) name (Greeter) +5 >Emitted(61, 42) Source(13, 30) + SourceIndex(0) name (Greeter) +6 >Emitted(61, 43) Source(13, 31) + SourceIndex(0) name (Greeter) +7 >Emitted(61, 44) Source(13, 31) + SourceIndex(0) name (Greeter) --- >>> __param(1, ParameterDecorator1), 1 >^^^^^^^^ @@ -828,10 +783,10 @@ sourceFile:sourceMapValidationDecorators.ts 2 > @ 3 > ParameterDecorator1 4 > -1 >Emitted(67, 9) Source(16, 7) + SourceIndex(0) name (Greeter) -2 >Emitted(67, 20) Source(16, 8) + SourceIndex(0) name (Greeter) -3 >Emitted(67, 39) Source(16, 27) + SourceIndex(0) name (Greeter) -4 >Emitted(67, 40) Source(16, 27) + SourceIndex(0) name (Greeter) +1 >Emitted(62, 9) Source(16, 7) + SourceIndex(0) name (Greeter) +2 >Emitted(62, 20) Source(16, 8) + SourceIndex(0) name (Greeter) +3 >Emitted(62, 39) Source(16, 27) + SourceIndex(0) name (Greeter) +4 >Emitted(62, 40) Source(16, 27) + SourceIndex(0) name (Greeter) --- >>> __param(1, ParameterDecorator2(30)) 1->^^^^^^^^ @@ -849,13 +804,13 @@ sourceFile:sourceMapValidationDecorators.ts 5 > 30 6 > ) 7 > -1->Emitted(68, 9) Source(17, 7) + SourceIndex(0) name (Greeter) -2 >Emitted(68, 20) Source(17, 8) + SourceIndex(0) name (Greeter) -3 >Emitted(68, 39) Source(17, 27) + SourceIndex(0) name (Greeter) -4 >Emitted(68, 40) Source(17, 28) + SourceIndex(0) name (Greeter) -5 >Emitted(68, 42) Source(17, 30) + SourceIndex(0) name (Greeter) -6 >Emitted(68, 43) Source(17, 31) + SourceIndex(0) name (Greeter) -7 >Emitted(68, 44) Source(17, 31) + SourceIndex(0) name (Greeter) +1->Emitted(63, 9) Source(17, 7) + SourceIndex(0) name (Greeter) +2 >Emitted(63, 20) Source(17, 8) + SourceIndex(0) name (Greeter) +3 >Emitted(63, 39) Source(17, 27) + SourceIndex(0) name (Greeter) +4 >Emitted(63, 40) Source(17, 28) + SourceIndex(0) name (Greeter) +5 >Emitted(63, 42) Source(17, 30) + SourceIndex(0) name (Greeter) +6 >Emitted(63, 43) Source(17, 31) + SourceIndex(0) name (Greeter) +7 >Emitted(63, 44) Source(17, 31) + SourceIndex(0) name (Greeter) --- >>> ], Greeter); 1 >^^^^^^^^^^^^^^^^ @@ -898,15 +853,15 @@ sourceFile:sourceMapValidationDecorators.ts > this.greeting = greetings; > } >} -1 >Emitted(69, 17) Source(54, 2) + SourceIndex(0) name (Greeter) +1 >Emitted(64, 17) Source(54, 2) + SourceIndex(0) name (Greeter) --- >>> return Greeter; 1->^^^^ 2 > ^^^^^^^^^^^^^^ 1-> 2 > } -1->Emitted(70, 5) Source(54, 1) + SourceIndex(0) name (Greeter) -2 >Emitted(70, 19) Source(54, 2) + SourceIndex(0) name (Greeter) +1->Emitted(65, 5) Source(54, 1) + SourceIndex(0) name (Greeter) +2 >Emitted(65, 19) Source(54, 2) + SourceIndex(0) name (Greeter) --- >>>})(); 1 > @@ -964,9 +919,9 @@ sourceFile:sourceMapValidationDecorators.ts > this.greeting = greetings; > } > } -1 >Emitted(71, 1) Source(54, 1) + SourceIndex(0) name (Greeter) -2 >Emitted(71, 2) Source(54, 2) + SourceIndex(0) name (Greeter) -3 >Emitted(71, 2) Source(8, 1) + SourceIndex(0) -4 >Emitted(71, 6) Source(54, 2) + SourceIndex(0) +1 >Emitted(66, 1) Source(54, 1) + SourceIndex(0) name (Greeter) +2 >Emitted(66, 2) Source(54, 2) + SourceIndex(0) name (Greeter) +3 >Emitted(66, 2) Source(8, 1) + SourceIndex(0) +4 >Emitted(66, 6) Source(54, 2) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationDecorators.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationDecorators.symbols b/tests/baselines/reference/sourceMapValidationDecorators.symbols index e22afb7b7fc..90204d0b71f 100644 --- a/tests/baselines/reference/sourceMapValidationDecorators.symbols +++ b/tests/baselines/reference/sourceMapValidationDecorators.symbols @@ -2,35 +2,35 @@ declare function ClassDecorator1(target: Function): void; >ClassDecorator1 : Symbol(ClassDecorator1, Decl(sourceMapValidationDecorators.ts, 0, 0)) >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 0, 33)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function ClassDecorator2(x: number): (target: Function) => void; >ClassDecorator2 : Symbol(ClassDecorator2, Decl(sourceMapValidationDecorators.ts, 0, 57)) >x : Symbol(x, Decl(sourceMapValidationDecorators.ts, 1, 33)) >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 1, 46)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) declare function PropertyDecorator1(target: Object, key: string | symbol, descriptor?: PropertyDescriptor): void; >PropertyDecorator1 : Symbol(PropertyDecorator1, Decl(sourceMapValidationDecorators.ts, 1, 72)) >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 2, 36)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >key : Symbol(key, Decl(sourceMapValidationDecorators.ts, 2, 51)) >descriptor : Symbol(descriptor, Decl(sourceMapValidationDecorators.ts, 2, 73)) ->PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66)) +>PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, --, --)) declare function PropertyDecorator2(x: number): (target: Object, key: string | symbol, descriptor?: PropertyDescriptor) => void; >PropertyDecorator2 : Symbol(PropertyDecorator2, Decl(sourceMapValidationDecorators.ts, 2, 113)) >x : Symbol(x, Decl(sourceMapValidationDecorators.ts, 3, 36)) >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 3, 49)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >key : Symbol(key, Decl(sourceMapValidationDecorators.ts, 3, 64)) >descriptor : Symbol(descriptor, Decl(sourceMapValidationDecorators.ts, 3, 86)) ->PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, 79, 66)) +>PropertyDescriptor : Symbol(PropertyDescriptor, Decl(lib.d.ts, --, --)) declare function ParameterDecorator1(target: Object, key: string | symbol, paramIndex: number): void; >ParameterDecorator1 : Symbol(ParameterDecorator1, Decl(sourceMapValidationDecorators.ts, 3, 128)) >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 4, 37)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >key : Symbol(key, Decl(sourceMapValidationDecorators.ts, 4, 52)) >paramIndex : Symbol(paramIndex, Decl(sourceMapValidationDecorators.ts, 4, 74)) @@ -38,7 +38,7 @@ declare function ParameterDecorator2(x: number): (target: Object, key: string | >ParameterDecorator2 : Symbol(ParameterDecorator2, Decl(sourceMapValidationDecorators.ts, 4, 101)) >x : Symbol(x, Decl(sourceMapValidationDecorators.ts, 5, 37)) >target : Symbol(target, Decl(sourceMapValidationDecorators.ts, 5, 50)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >key : Symbol(key, Decl(sourceMapValidationDecorators.ts, 5, 65)) >paramIndex : Symbol(paramIndex, Decl(sourceMapValidationDecorators.ts, 5, 87)) diff --git a/tests/baselines/reference/sourceMapValidationDecorators.types b/tests/baselines/reference/sourceMapValidationDecorators.types index 9e83bb03509..2fc05972307 100644 --- a/tests/baselines/reference/sourceMapValidationDecorators.types +++ b/tests/baselines/reference/sourceMapValidationDecorators.types @@ -93,7 +93,7 @@ class Greeter { >"

" + this.greeting : string >"

" : string >this.greeting : string ->this : Greeter +>this : this >greeting : string >"

" : string } @@ -137,7 +137,7 @@ class Greeter { return this.greeting; >this.greeting : string ->this : Greeter +>this : this >greeting : string } @@ -154,7 +154,7 @@ class Greeter { return this.greeting; >this.greeting : string ->this : Greeter +>this : this >greeting : string } @@ -175,7 +175,7 @@ class Greeter { this.greeting = greetings; >this.greeting = greetings : string >this.greeting : string ->this : Greeter +>this : this >greeting : string >greetings : string } diff --git a/tests/baselines/reference/sourceMapValidationTryCatchFinally.symbols b/tests/baselines/reference/sourceMapValidationTryCatchFinally.symbols index f2306df6827..321d262d9e7 100644 --- a/tests/baselines/reference/sourceMapValidationTryCatchFinally.symbols +++ b/tests/baselines/reference/sourceMapValidationTryCatchFinally.symbols @@ -26,7 +26,7 @@ try >x : Symbol(x, Decl(sourceMapValidationTryCatchFinally.ts, 0, 3)) throw new Error(); ->Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11)) +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } catch (e) >e : Symbol(e, Decl(sourceMapValidationTryCatchFinally.ts, 13, 7)) diff --git a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols index 9f03f8fca01..9114afccdf4 100644 --- a/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols +++ b/tests/baselines/reference/specializationsShouldNotAffectEachOther.symbols @@ -23,9 +23,9 @@ function foo() { >series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 12, 7)) series2.map(seriesExtent); ->series2.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>series2.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >series2 : Symbol(series2, Decl(specializationsShouldNotAffectEachOther.ts, 12, 7)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >seriesExtent : Symbol(seriesExtent, Decl(specializationsShouldNotAffectEachOther.ts, 10, 7)) return null; @@ -34,11 +34,11 @@ function foo() { var keyExtent2: any[] = series.data.map(function (d: string) { return d; }); >keyExtent2 : Symbol(keyExtent2, Decl(specializationsShouldNotAffectEachOther.ts, 19, 3)) ->series.data.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>series.data.map : Symbol(Array.map, 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)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50)) >d : Symbol(d, Decl(specializationsShouldNotAffectEachOther.ts, 19, 50)) diff --git a/tests/baselines/reference/specializedSignatureIsSubtypeOfNonSpecializedSignature.symbols b/tests/baselines/reference/specializedSignatureIsSubtypeOfNonSpecializedSignature.symbols index 0730ccaf409..8b1bbfb6aab 100644 --- a/tests/baselines/reference/specializedSignatureIsSubtypeOfNonSpecializedSignature.symbols +++ b/tests/baselines/reference/specializedSignatureIsSubtypeOfNonSpecializedSignature.symbols @@ -55,7 +55,7 @@ class C2 { class C3 { >C3 : Symbol(C3, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 18, 1)) >T : Symbol(T, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 20, 9)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo(x: 'a'); >foo : Symbol(foo, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 20, 28), Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 21, 16), Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 22, 19), Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 23, 14)) @@ -131,7 +131,7 @@ interface I2 { interface I3 { >I3 : Symbol(I3, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 43, 1)) >T : Symbol(T, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 45, 13)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) (x: 'a'); >x : Symbol(x, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 46, 5)) @@ -236,7 +236,7 @@ var a3: { foo(x: T); >foo : Symbol(foo, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 75, 16), Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 76, 19), Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 77, 16)) >T : Symbol(T, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 78, 8)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 78, 26)) >T : Symbol(T, Decl(specializedSignatureIsSubtypeOfNonSpecializedSignature.ts, 78, 8)) } diff --git a/tests/baselines/reference/staticInstanceResolution.symbols b/tests/baselines/reference/staticInstanceResolution.symbols index 69d1894679f..1b58989347d 100644 --- a/tests/baselines/reference/staticInstanceResolution.symbols +++ b/tests/baselines/reference/staticInstanceResolution.symbols @@ -14,17 +14,17 @@ class Comment { >Comment : Symbol(Comment, Decl(staticInstanceResolution.ts, 0, 0)) { comments[0].getDocCommentText(); ->comments[0].getDocCommentText : Symbol(getDocCommentText, Decl(staticInstanceResolution.ts, 0, 15)) +>comments[0].getDocCommentText : Symbol(Comment.getDocCommentText, Decl(staticInstanceResolution.ts, 0, 15)) >comments : Symbol(comments, Decl(staticInstanceResolution.ts, 7, 29)) ->getDocCommentText : Symbol(getDocCommentText, Decl(staticInstanceResolution.ts, 0, 15)) +>getDocCommentText : Symbol(Comment.getDocCommentText, Decl(staticInstanceResolution.ts, 0, 15)) var c: Comment; >c : Symbol(c, Decl(staticInstanceResolution.ts, 10, 11)) >Comment : Symbol(Comment, Decl(staticInstanceResolution.ts, 0, 0)) c.getDocCommentText(); ->c.getDocCommentText : Symbol(getDocCommentText, Decl(staticInstanceResolution.ts, 0, 15)) +>c.getDocCommentText : Symbol(Comment.getDocCommentText, Decl(staticInstanceResolution.ts, 0, 15)) >c : Symbol(c, Decl(staticInstanceResolution.ts, 10, 11)) ->getDocCommentText : Symbol(getDocCommentText, Decl(staticInstanceResolution.ts, 0, 15)) +>getDocCommentText : Symbol(Comment.getDocCommentText, Decl(staticInstanceResolution.ts, 0, 15)) } } diff --git a/tests/baselines/reference/staticInstanceResolution2.symbols b/tests/baselines/reference/staticInstanceResolution2.symbols index 349088f5ded..cb7b96445c2 100644 --- a/tests/baselines/reference/staticInstanceResolution2.symbols +++ b/tests/baselines/reference/staticInstanceResolution2.symbols @@ -3,9 +3,9 @@ class A { } >A : Symbol(A, Decl(staticInstanceResolution2.ts, 0, 0)) A.hasOwnProperty('foo'); ->A.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>A.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) >A : Symbol(A, Decl(staticInstanceResolution2.ts, 0, 0)) ->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) class B { >B : Symbol(B, Decl(staticInstanceResolution2.ts, 1, 24)) @@ -13,9 +13,9 @@ class B { constructor() { } } B.hasOwnProperty('foo'); ->B.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>B.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) >B : Symbol(B, Decl(staticInstanceResolution2.ts, 1, 24)) ->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/stringIncludes.symbols b/tests/baselines/reference/stringIncludes.symbols index 1348b62e566..1f1b2e55ccf 100644 --- a/tests/baselines/reference/stringIncludes.symbols +++ b/tests/baselines/reference/stringIncludes.symbols @@ -5,11 +5,11 @@ var includes: boolean; includes = "abcde".includes("cd"); >includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3)) ->"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, 4249, 37)) ->includes : Symbol(String.includes, Decl(lib.d.ts, 4249, 37)) +>"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, --, --)) +>includes : Symbol(String.includes, Decl(lib.d.ts, --, --)) includes = "abcde".includes("cd", 2); >includes : Symbol(includes, Decl(stringIncludes.ts, 1, 3)) ->"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, 4249, 37)) ->includes : Symbol(String.includes, Decl(lib.d.ts, 4249, 37)) +>"abcde".includes : Symbol(String.includes, Decl(lib.d.ts, --, --)) +>includes : Symbol(String.includes, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/stringPropCodeGen.symbols b/tests/baselines/reference/stringPropCodeGen.symbols index b0d9cb91fc2..d2c966f1b6e 100644 --- a/tests/baselines/reference/stringPropCodeGen.symbols +++ b/tests/baselines/reference/stringPropCodeGen.symbols @@ -15,9 +15,9 @@ a.foo(); >foo : Symbol("foo", Decl(stringPropCodeGen.ts, 0, 9)) a.bar.toString(); ->a.bar.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>a.bar.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >a.bar : Symbol("bar", Decl(stringPropCodeGen.ts, 2, 25)) >a : Symbol(a, Decl(stringPropCodeGen.ts, 0, 3)) >bar : Symbol("bar", Decl(stringPropCodeGen.ts, 2, 25)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/stringPropertyAccess.symbols b/tests/baselines/reference/stringPropertyAccess.symbols index 26a84d67d6f..ba239deee00 100644 --- a/tests/baselines/reference/stringPropertyAccess.symbols +++ b/tests/baselines/reference/stringPropertyAccess.symbols @@ -4,23 +4,23 @@ var x = ''; var a = x.charAt(0); >a : Symbol(a, Decl(stringPropertyAccess.ts, 1, 3)) ->x.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>x.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(stringPropertyAccess.ts, 0, 3)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) var b = x.hasOwnProperty('charAt'); >b : Symbol(b, Decl(stringPropertyAccess.ts, 2, 3)) ->x.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>x.hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(stringPropertyAccess.ts, 0, 3)) ->hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>hasOwnProperty : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) var c = x['charAt'](0); >c : Symbol(c, Decl(stringPropertyAccess.ts, 4, 3)) >x : Symbol(x, Decl(stringPropertyAccess.ts, 0, 3)) ->'charAt' : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>'charAt' : Symbol(String.charAt, Decl(lib.d.ts, --, --)) var e = x['hasOwnProperty']('toFixed'); >e : Symbol(e, Decl(stringPropertyAccess.ts, 5, 3)) >x : Symbol(x, Decl(stringPropertyAccess.ts, 0, 3)) ->'hasOwnProperty' : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, 105, 22)) +>'hasOwnProperty' : Symbol(Object.hasOwnProperty, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/subtypesOfAny.symbols b/tests/baselines/reference/subtypesOfAny.symbols index ff4874f1cec..85f5186f705 100644 --- a/tests/baselines/reference/subtypesOfAny.symbols +++ b/tests/baselines/reference/subtypesOfAny.symbols @@ -53,7 +53,7 @@ interface I5 { foo: Date; >foo : Symbol(foo, Decl(subtypesOfAny.ts, 27, 21)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } @@ -65,7 +65,7 @@ interface I6 { foo: RegExp; >foo : Symbol(foo, Decl(subtypesOfAny.ts, 33, 21)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } @@ -261,7 +261,7 @@ interface I19 { foo: Object; >foo : Symbol(foo, Decl(subtypesOfAny.ts, 124, 21)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/subtypingTransitivity.symbols b/tests/baselines/reference/subtypingTransitivity.symbols index 95e0a4bc9d6..7a1ee279bb3 100644 --- a/tests/baselines/reference/subtypingTransitivity.symbols +++ b/tests/baselines/reference/subtypingTransitivity.symbols @@ -4,7 +4,7 @@ class B { x: Object; >x : Symbol(x, Decl(subtypingTransitivity.ts, 0, 9)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } class D extends B { diff --git a/tests/baselines/reference/subtypingWithCallSignatures2.symbols b/tests/baselines/reference/subtypingWithCallSignatures2.symbols index 5aa1021d260..02f08016b31 100644 --- a/tests/baselines/reference/subtypingWithCallSignatures2.symbols +++ b/tests/baselines/reference/subtypingWithCallSignatures2.symbols @@ -173,12 +173,12 @@ declare function foo12(a: (x: Array, y: Array) => Array >foo12 : Symbol(foo12, Decl(subtypingWithCallSignatures2.ts, 38, 36), Decl(subtypingWithCallSignatures2.ts, 40, 92)) >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 40, 23)) >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 40, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 40, 42)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures2.ts, 3, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27)) >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 40, 23)) @@ -190,12 +190,12 @@ declare function foo13(a: (x: Array, y: Array) => Array) >foo13 : Symbol(foo13, Decl(subtypingWithCallSignatures2.ts, 41, 36), Decl(subtypingWithCallSignatures2.ts, 43, 91)) >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 43, 23)) >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 43, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 43, 42)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27)) >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 43, 23)) @@ -209,7 +209,7 @@ declare function foo14(a: (x: { a: string; b: number }) => Object): typeof a; >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 46, 27)) >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 46, 31)) >b : Symbol(b, Decl(subtypingWithCallSignatures2.ts, 46, 42)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 46, 23)) declare function foo14(a: any): any; @@ -297,8 +297,8 @@ declare function foo18(a: { (a: Date): Date; >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 74, 9)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) }): any[]; }): typeof a; @@ -680,25 +680,25 @@ var r11b = [r11arg2, r11arg1]; var r12arg1 = >(x: Array, y: T) => >null; >r12arg1 : Symbol(r12arg1, Decl(subtypingWithCallSignatures2.ts, 145, 3)) >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 145, 15)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0)) >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 145, 38)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 145, 53)) >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 145, 15)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27)) var r12arg2 = (x: Array, y: Array) => >null; >r12arg2 : Symbol(r12arg2, Decl(subtypingWithCallSignatures2.ts, 146, 3)) >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 146, 15)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 146, 30)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures2.ts, 3, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27)) var r12 = foo12(r12arg1); // any @@ -719,10 +719,10 @@ var r12b = [r12arg2, r12arg1]; var r13arg1 = >(x: Array, y: T) => y; >r13arg1 : Symbol(r13arg1, Decl(subtypingWithCallSignatures2.ts, 151, 3)) >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 151, 15)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27)) >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 151, 41)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 151, 56)) >T : Symbol(T, Decl(subtypingWithCallSignatures2.ts, 151, 15)) @@ -731,12 +731,12 @@ var r13arg1 = >(x: Array, y: T) => y; var r13arg2 = (x: Array, y: Array) => >null; >r13arg2 : Symbol(r13arg2, Decl(subtypingWithCallSignatures2.ts, 152, 3)) >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 152, 15)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithCallSignatures2.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithCallSignatures2.ts, 152, 30)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures2.ts, 2, 27)) var r13 = foo13(r13arg1); // any @@ -771,7 +771,7 @@ var r14arg2 = (x: { a: string; b: number }) => null; >x : Symbol(x, Decl(subtypingWithCallSignatures2.ts, 158, 15)) >a : Symbol(a, Decl(subtypingWithCallSignatures2.ts, 158, 19)) >b : Symbol(b, Decl(subtypingWithCallSignatures2.ts, 158, 30)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r14 = foo14(r14arg1); // any >r14 : Symbol(r14, Decl(subtypingWithCallSignatures2.ts, 159, 3)) diff --git a/tests/baselines/reference/subtypingWithCallSignatures3.symbols b/tests/baselines/reference/subtypingWithCallSignatures3.symbols index 666977c62d9..37e1c0423c4 100644 --- a/tests/baselines/reference/subtypingWithCallSignatures3.symbols +++ b/tests/baselines/reference/subtypingWithCallSignatures3.symbols @@ -101,12 +101,12 @@ module Errors { >foo12 : Symbol(foo12, Decl(subtypingWithCallSignatures3.ts, 22, 41), Decl(subtypingWithCallSignatures3.ts, 24, 98)) >a2 : Symbol(a2, Decl(subtypingWithCallSignatures3.ts, 24, 27)) >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 24, 32)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15)) >y : Symbol(y, Decl(subtypingWithCallSignatures3.ts, 24, 47)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures3.ts, 5, 47)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31)) >a2 : Symbol(a2, Decl(subtypingWithCallSignatures3.ts, 24, 27)) @@ -386,24 +386,24 @@ module Errors { var r6arg = (x: Array, y: Array) => >null; >r6arg : Symbol(r6arg, Decl(subtypingWithCallSignatures3.ts, 83, 7)) >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 83, 17)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15)) >y : Symbol(y, Decl(subtypingWithCallSignatures3.ts, 83, 32)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures3.ts, 5, 47)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithCallSignatures3.ts, 4, 31)) var r6arg2 = >(x: Array, y: Array) => null; >r6arg2 : Symbol(r6arg2, Decl(subtypingWithCallSignatures3.ts, 84, 7)) >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 84, 18)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(subtypingWithCallSignatures3.ts, 5, 47)) >x : Symbol(x, Decl(subtypingWithCallSignatures3.ts, 84, 45)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15)) >y : Symbol(y, Decl(subtypingWithCallSignatures3.ts, 84, 60)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithCallSignatures3.ts, 3, 15)) >T : Symbol(T, Decl(subtypingWithCallSignatures3.ts, 84, 18)) diff --git a/tests/baselines/reference/subtypingWithConstructSignatures2.symbols b/tests/baselines/reference/subtypingWithConstructSignatures2.symbols index 08f1e814b4d..2173aaa1392 100644 --- a/tests/baselines/reference/subtypingWithConstructSignatures2.symbols +++ b/tests/baselines/reference/subtypingWithConstructSignatures2.symbols @@ -173,12 +173,12 @@ declare function foo12(a: new (x: Array, y: Array) => Arrayfoo12 : Symbol(foo12, Decl(subtypingWithConstructSignatures2.ts, 38, 36), Decl(subtypingWithConstructSignatures2.ts, 40, 96)) >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 40, 23)) >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 40, 31)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithConstructSignatures2.ts, 40, 46)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(subtypingWithConstructSignatures2.ts, 3, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27)) >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 40, 23)) @@ -190,12 +190,12 @@ declare function foo13(a: new (x: Array, y: Array) => Arrayfoo13 : Symbol(foo13, Decl(subtypingWithConstructSignatures2.ts, 41, 36), Decl(subtypingWithConstructSignatures2.ts, 43, 95)) >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 43, 23)) >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 43, 31)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithConstructSignatures2.ts, 43, 46)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27)) >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 43, 23)) @@ -209,7 +209,7 @@ declare function foo14(a: new (x: { a: string; b: number }) => Object): typeof a >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 46, 31)) >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 46, 35)) >b : Symbol(b, Decl(subtypingWithConstructSignatures2.ts, 46, 46)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 46, 23)) declare function foo14(a: any): any; @@ -297,8 +297,8 @@ declare function foo18(a: { new (a: Date): Date; >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 74, 13)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) }): any[]; }): typeof a; @@ -680,25 +680,25 @@ var r11b = [r11arg2, r11arg1]; var r12arg1: new >(x: Array, y: T) => Array; >r12arg1 : Symbol(r12arg1, Decl(subtypingWithConstructSignatures2.ts, 145, 3)) >T : Symbol(T, Decl(subtypingWithConstructSignatures2.ts, 145, 18)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0)) >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 145, 41)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithConstructSignatures2.ts, 145, 56)) >T : Symbol(T, Decl(subtypingWithConstructSignatures2.ts, 145, 18)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27)) var r12arg2: new (x: Array, y: Array) => Array; >r12arg2 : Symbol(r12arg2, Decl(subtypingWithConstructSignatures2.ts, 146, 3)) >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 146, 18)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithConstructSignatures2.ts, 146, 33)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(subtypingWithConstructSignatures2.ts, 3, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27)) var r12 = foo12(r12arg1); // any @@ -719,10 +719,10 @@ var r12b = [r12arg2, r12arg1]; var r13arg1: new >(x: Array, y: T) => T; >r13arg1 : Symbol(r13arg1, Decl(subtypingWithConstructSignatures2.ts, 151, 3)) >T : Symbol(T, Decl(subtypingWithConstructSignatures2.ts, 151, 18)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27)) >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 151, 44)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithConstructSignatures2.ts, 151, 59)) >T : Symbol(T, Decl(subtypingWithConstructSignatures2.ts, 151, 18)) @@ -731,12 +731,12 @@ var r13arg1: new >(x: Array, y: T) => T; var r13arg2: new (x: Array, y: Array) => Array; >r13arg2 : Symbol(r13arg2, Decl(subtypingWithConstructSignatures2.ts, 152, 3)) >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 152, 18)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures2.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithConstructSignatures2.ts, 152, 33)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures2.ts, 2, 27)) var r13 = foo13(r13arg1); // any @@ -769,7 +769,7 @@ var r14arg2: new (x: { a: string; b: number }) => Object; >x : Symbol(x, Decl(subtypingWithConstructSignatures2.ts, 158, 18)) >a : Symbol(a, Decl(subtypingWithConstructSignatures2.ts, 158, 22)) >b : Symbol(b, Decl(subtypingWithConstructSignatures2.ts, 158, 33)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r14 = foo14(r14arg1); // any >r14 : Symbol(r14, Decl(subtypingWithConstructSignatures2.ts, 159, 3)) diff --git a/tests/baselines/reference/subtypingWithConstructSignatures3.symbols b/tests/baselines/reference/subtypingWithConstructSignatures3.symbols index ce8eda2dcf6..3adce566f95 100644 --- a/tests/baselines/reference/subtypingWithConstructSignatures3.symbols +++ b/tests/baselines/reference/subtypingWithConstructSignatures3.symbols @@ -101,12 +101,12 @@ module Errors { >foo12 : Symbol(foo12, Decl(subtypingWithConstructSignatures3.ts, 22, 41), Decl(subtypingWithConstructSignatures3.ts, 24, 102)) >a2 : Symbol(a2, Decl(subtypingWithConstructSignatures3.ts, 24, 27)) >x : Symbol(x, Decl(subtypingWithConstructSignatures3.ts, 24, 36)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures3.ts, 3, 15)) >y : Symbol(y, Decl(subtypingWithConstructSignatures3.ts, 24, 51)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(subtypingWithConstructSignatures3.ts, 5, 47)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures3.ts, 4, 31)) >a2 : Symbol(a2, Decl(subtypingWithConstructSignatures3.ts, 24, 27)) @@ -386,24 +386,24 @@ module Errors { var r6arg1: new (x: Array, y: Array) => Array; >r6arg1 : Symbol(r6arg1, Decl(subtypingWithConstructSignatures3.ts, 85, 7)) >x : Symbol(x, Decl(subtypingWithConstructSignatures3.ts, 85, 21)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures3.ts, 3, 15)) >y : Symbol(y, Decl(subtypingWithConstructSignatures3.ts, 85, 36)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(subtypingWithConstructSignatures3.ts, 5, 47)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures3.ts, 4, 31)) var r6arg2: new >(x: Array, y: Array) => T; >r6arg2 : Symbol(r6arg2, Decl(subtypingWithConstructSignatures3.ts, 86, 7)) >T : Symbol(T, Decl(subtypingWithConstructSignatures3.ts, 86, 21)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(subtypingWithConstructSignatures3.ts, 5, 47)) >x : Symbol(x, Decl(subtypingWithConstructSignatures3.ts, 86, 48)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures3.ts, 3, 15)) >y : Symbol(y, Decl(subtypingWithConstructSignatures3.ts, 86, 63)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures3.ts, 3, 15)) >T : Symbol(T, Decl(subtypingWithConstructSignatures3.ts, 86, 21)) diff --git a/tests/baselines/reference/subtypingWithConstructSignatures5.symbols b/tests/baselines/reference/subtypingWithConstructSignatures5.symbols index ab20c2b7a3f..634f31ff783 100644 --- a/tests/baselines/reference/subtypingWithConstructSignatures5.symbols +++ b/tests/baselines/reference/subtypingWithConstructSignatures5.symbols @@ -111,23 +111,23 @@ interface A { // T a12: new (x: Array, y: Array) => Array; >a12 : Symbol(a12, Decl(subtypingWithConstructSignatures5.ts, 20, 75)) >x : Symbol(x, Decl(subtypingWithConstructSignatures5.ts, 21, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures5.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithConstructSignatures5.ts, 21, 29)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived2 : Symbol(Derived2, Decl(subtypingWithConstructSignatures5.ts, 4, 43)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures5.ts, 3, 27)) a13: new (x: Array, y: Array) => Array; >a13 : Symbol(a13, Decl(subtypingWithConstructSignatures5.ts, 21, 68)) >x : Symbol(x, Decl(subtypingWithConstructSignatures5.ts, 22, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures5.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithConstructSignatures5.ts, 22, 29)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures5.ts, 3, 27)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures5.ts, 3, 27)) a14: new (x: { a: string; b: number }) => Object; @@ -135,7 +135,7 @@ interface A { // T >x : Symbol(x, Decl(subtypingWithConstructSignatures5.ts, 23, 14)) >a : Symbol(a, Decl(subtypingWithConstructSignatures5.ts, 23, 18)) >b : Symbol(b, Decl(subtypingWithConstructSignatures5.ts, 23, 29)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface B extends A { @@ -280,23 +280,23 @@ interface I extends B { a12: new >(x: Array, y: T) => Array; // ok, less specific parameter type >a12 : Symbol(a12, Decl(subtypingWithConstructSignatures5.ts, 43, 47)) >T : Symbol(T, Decl(subtypingWithConstructSignatures5.ts, 44, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures5.ts, 0, 0)) >x : Symbol(x, Decl(subtypingWithConstructSignatures5.ts, 44, 37)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures5.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithConstructSignatures5.ts, 44, 52)) >T : Symbol(T, Decl(subtypingWithConstructSignatures5.ts, 44, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures5.ts, 3, 27)) a13: new >(x: Array, y: T) => T; // ok, T = Array, satisfies constraint, contextual signature instantiation succeeds >a13 : Symbol(a13, Decl(subtypingWithConstructSignatures5.ts, 44, 77)) >T : Symbol(T, Decl(subtypingWithConstructSignatures5.ts, 45, 14)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Derived : Symbol(Derived, Decl(subtypingWithConstructSignatures5.ts, 3, 27)) >x : Symbol(x, Decl(subtypingWithConstructSignatures5.ts, 45, 40)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(subtypingWithConstructSignatures5.ts, 0, 0)) >y : Symbol(y, Decl(subtypingWithConstructSignatures5.ts, 45, 55)) >T : Symbol(T, Decl(subtypingWithConstructSignatures5.ts, 45, 14)) diff --git a/tests/baselines/reference/subtypingWithOptionalProperties.symbols b/tests/baselines/reference/subtypingWithOptionalProperties.symbols index 44ebbe99fd7..a7a8b97e9f0 100644 --- a/tests/baselines/reference/subtypingWithOptionalProperties.symbols +++ b/tests/baselines/reference/subtypingWithOptionalProperties.symbols @@ -21,15 +21,15 @@ var r = f({ s: new Object() }); // ok >r : Symbol(r, Decl(subtypingWithOptionalProperties.ts, 8, 3)) >f : Symbol(f, Decl(subtypingWithOptionalProperties.ts, 0, 0)) >s : Symbol(s, Decl(subtypingWithOptionalProperties.ts, 8, 11)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) r.s && r.s.toFixed(); // would blow up at runtime >r.s : Symbol(s, Decl(subtypingWithOptionalProperties.ts, 4, 12)) >r : Symbol(r, Decl(subtypingWithOptionalProperties.ts, 8, 3)) >s : Symbol(s, Decl(subtypingWithOptionalProperties.ts, 4, 12)) ->r.s.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>r.s.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >r.s : Symbol(s, Decl(subtypingWithOptionalProperties.ts, 4, 12)) >r : Symbol(r, Decl(subtypingWithOptionalProperties.ts, 8, 3)) >s : Symbol(s, Decl(subtypingWithOptionalProperties.ts, 4, 12)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/superAccessInFatArrow1.types b/tests/baselines/reference/superAccessInFatArrow1.types index 0c50015c051..95f0d769655 100644 --- a/tests/baselines/reference/superAccessInFatArrow1.types +++ b/tests/baselines/reference/superAccessInFatArrow1.types @@ -23,7 +23,7 @@ module test { this.bar(() => { >this.bar(() => { super.foo(); }) : void >this.bar : (callback: () => void) => void ->this : B +>this : this >bar : (callback: () => void) => void >() => { super.foo(); } : () => void diff --git a/tests/baselines/reference/superCallParameterContextualTyping1.symbols b/tests/baselines/reference/superCallParameterContextualTyping1.symbols index 80876e2ee9d..ed845b7cd4e 100644 --- a/tests/baselines/reference/superCallParameterContextualTyping1.symbols +++ b/tests/baselines/reference/superCallParameterContextualTyping1.symbols @@ -22,9 +22,9 @@ class B extends A { constructor() { super(value => String(value.toExponential())); } >super : Symbol(A, Decl(superCallParameterContextualTyping1.ts, 0, 0)) >value : Symbol(value, Decl(superCallParameterContextualTyping1.ts, 9, 26)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) ->value.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>String : Symbol(String, 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)) ->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/superCallParameterContextualTyping3.symbols b/tests/baselines/reference/superCallParameterContextualTyping3.symbols index 04bc148ac0f..e51687b4539 100644 --- a/tests/baselines/reference/superCallParameterContextualTyping3.symbols +++ b/tests/baselines/reference/superCallParameterContextualTyping3.symbols @@ -42,9 +42,9 @@ class C extends CBase { >p : Symbol(p, Decl(superCallParameterContextualTyping3.ts, 17, 19)) p.length; ->p.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>p.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >p : Symbol(p, Decl(superCallParameterContextualTyping3.ts, 17, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } }); @@ -60,9 +60,9 @@ class C extends CBase { >p : Symbol(p, Decl(superCallParameterContextualTyping3.ts, 25, 19)) p.length; ->p.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>p.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >p : Symbol(p, Decl(superCallParameterContextualTyping3.ts, 25, 19)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } }); } diff --git a/tests/baselines/reference/superSymbolIndexedAccess1.symbols b/tests/baselines/reference/superSymbolIndexedAccess1.symbols index 416ac465e24..47131f231cb 100644 --- a/tests/baselines/reference/superSymbolIndexedAccess1.symbols +++ b/tests/baselines/reference/superSymbolIndexedAccess1.symbols @@ -1,9 +1,9 @@ === tests/cases/conformance/expressions/superPropertyAccess/superSymbolIndexedAccess1.ts === var symbol = Symbol.for('myThing'); >symbol : Symbol(symbol, Decl(superSymbolIndexedAccess1.ts, 0, 3)) ->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3862, 42)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3862, 42)) +>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, --, --)) class Foo { >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess1.ts, 0, 35)) diff --git a/tests/baselines/reference/superSymbolIndexedAccess2.symbols b/tests/baselines/reference/superSymbolIndexedAccess2.symbols index 726abb3fdc5..9b65ce358bb 100644 --- a/tests/baselines/reference/superSymbolIndexedAccess2.symbols +++ b/tests/baselines/reference/superSymbolIndexedAccess2.symbols @@ -4,9 +4,9 @@ class Foo { >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0)) [Symbol.isConcatSpreadable]() { ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) return 0; } @@ -17,14 +17,14 @@ class Bar extends Foo { >Foo : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0)) [Symbol.isConcatSpreadable]() { ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) return super[Symbol.isConcatSpreadable](); >super : Symbol(Foo, Decl(superSymbolIndexedAccess2.ts, 0, 0)) ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/symbolDeclarationEmit1.symbols b/tests/baselines/reference/symbolDeclarationEmit1.symbols index 9a7d93c7246..0b1999cf606 100644 --- a/tests/baselines/reference/symbolDeclarationEmit1.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit1.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit1.ts, 0, 0)) [Symbol.toPrimitive]: number; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit10.symbols b/tests/baselines/reference/symbolDeclarationEmit10.symbols index 63602f4fd2c..7d7cbf257df 100644 --- a/tests/baselines/reference/symbolDeclarationEmit10.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit10.symbols @@ -3,13 +3,13 @@ var obj = { >obj : Symbol(obj, Decl(symbolDeclarationEmit10.ts, 0, 3)) get [Symbol.isConcatSpreadable]() { return '' }, ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) set [Symbol.isConcatSpreadable](x) { } ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolDeclarationEmit10.ts, 2, 36)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit11.symbols b/tests/baselines/reference/symbolDeclarationEmit11.symbols index 850bde66c49..a8b9ab0757d 100644 --- a/tests/baselines/reference/symbolDeclarationEmit11.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit11.symbols @@ -3,23 +3,23 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit11.ts, 0, 0)) static [Symbol.iterator] = 0; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) static [Symbol.isConcatSpreadable]() { } ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) static get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) static set [Symbol.toPrimitive](x) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolDeclarationEmit11.ts, 4, 36)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit13.symbols b/tests/baselines/reference/symbolDeclarationEmit13.symbols index accb92a8c52..9ac140cbcc4 100644 --- a/tests/baselines/reference/symbolDeclarationEmit13.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit13.symbols @@ -3,13 +3,13 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit13.ts, 0, 0)) get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) set [Symbol.toStringTag](x) { } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolDeclarationEmit13.ts, 2, 29)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit14.symbols b/tests/baselines/reference/symbolDeclarationEmit14.symbols index 91a5cfdd760..4ee1d1d2ebd 100644 --- a/tests/baselines/reference/symbolDeclarationEmit14.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit14.symbols @@ -3,12 +3,12 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit14.ts, 0, 0)) get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) get [Symbol.toStringTag]() { return ""; } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit2.symbols b/tests/baselines/reference/symbolDeclarationEmit2.symbols index 1993e369aea..f3d7253f1af 100644 --- a/tests/baselines/reference/symbolDeclarationEmit2.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit2.symbols @@ -3,7 +3,7 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit2.ts, 0, 0)) [Symbol.toPrimitive] = ""; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit3.symbols b/tests/baselines/reference/symbolDeclarationEmit3.symbols index 84f39f363f1..4a75ecac742 100644 --- a/tests/baselines/reference/symbolDeclarationEmit3.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit3.symbols @@ -3,20 +3,20 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit3.ts, 0, 0)) [Symbol.toPrimitive](x: number); ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 1, 25)) [Symbol.toPrimitive](x: string); ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 2, 25)) [Symbol.toPrimitive](x: any) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolDeclarationEmit3.ts, 3, 25)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit4.symbols b/tests/baselines/reference/symbolDeclarationEmit4.symbols index 655a91fc88b..eec0912d6ee 100644 --- a/tests/baselines/reference/symbolDeclarationEmit4.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit4.symbols @@ -3,13 +3,13 @@ class C { >C : Symbol(C, Decl(symbolDeclarationEmit4.ts, 0, 0)) get [Symbol.toPrimitive]() { return ""; } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) set [Symbol.toPrimitive](x) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolDeclarationEmit4.ts, 2, 29)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit5.symbols b/tests/baselines/reference/symbolDeclarationEmit5.symbols index 1436f9b9f69..e9ee78e4a7d 100644 --- a/tests/baselines/reference/symbolDeclarationEmit5.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit5.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(symbolDeclarationEmit5.ts, 0, 0)) [Symbol.isConcatSpreadable](): string; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit6.symbols b/tests/baselines/reference/symbolDeclarationEmit6.symbols index f07ebd532fa..64da887014c 100644 --- a/tests/baselines/reference/symbolDeclarationEmit6.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit6.symbols @@ -3,7 +3,7 @@ interface I { >I : Symbol(I, Decl(symbolDeclarationEmit6.ts, 0, 0)) [Symbol.isConcatSpreadable]: string; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit7.symbols b/tests/baselines/reference/symbolDeclarationEmit7.symbols index 0435dc15df2..3bfaee5316c 100644 --- a/tests/baselines/reference/symbolDeclarationEmit7.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit7.symbols @@ -3,7 +3,7 @@ var obj: { >obj : Symbol(obj, Decl(symbolDeclarationEmit7.ts, 0, 3)) [Symbol.isConcatSpreadable]: string; ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit8.symbols b/tests/baselines/reference/symbolDeclarationEmit8.symbols index 7e95754b1eb..9eead633343 100644 --- a/tests/baselines/reference/symbolDeclarationEmit8.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit8.symbols @@ -3,7 +3,7 @@ var obj = { >obj : Symbol(obj, Decl(symbolDeclarationEmit8.ts, 0, 3)) [Symbol.isConcatSpreadable]: 0 ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/symbolDeclarationEmit9.symbols b/tests/baselines/reference/symbolDeclarationEmit9.symbols index d4f08115a21..ec49c196d02 100644 --- a/tests/baselines/reference/symbolDeclarationEmit9.symbols +++ b/tests/baselines/reference/symbolDeclarationEmit9.symbols @@ -3,7 +3,7 @@ var obj = { >obj : Symbol(obj, Decl(symbolDeclarationEmit9.ts, 0, 3)) [Symbol.isConcatSpreadable]() { } ->Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, 3884, 24)) +>Symbol.isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>isConcatSpreadable : Symbol(SymbolConstructor.isConcatSpreadable, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/symbolProperty11.symbols b/tests/baselines/reference/symbolProperty11.symbols index 3db0f7012cb..b064d11b9de 100644 --- a/tests/baselines/reference/symbolProperty11.symbols +++ b/tests/baselines/reference/symbolProperty11.symbols @@ -6,9 +6,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty11.ts, 0, 11)) [Symbol.iterator]?: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty11.ts, 2, 25)) } diff --git a/tests/baselines/reference/symbolProperty13.symbols b/tests/baselines/reference/symbolProperty13.symbols index 62ce887a731..a48f02fdacf 100644 --- a/tests/baselines/reference/symbolProperty13.symbols +++ b/tests/baselines/reference/symbolProperty13.symbols @@ -3,9 +3,9 @@ class C { >C : Symbol(C, Decl(symbolProperty13.ts, 0, 0)) [Symbol.iterator]: { x; y }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty13.ts, 1, 24)) >y : Symbol(y, Decl(symbolProperty13.ts, 1, 27)) } @@ -13,9 +13,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty13.ts, 2, 1)) [Symbol.iterator]: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty13.ts, 4, 24)) } diff --git a/tests/baselines/reference/symbolProperty14.symbols b/tests/baselines/reference/symbolProperty14.symbols index c48bd271c87..459b2699e42 100644 --- a/tests/baselines/reference/symbolProperty14.symbols +++ b/tests/baselines/reference/symbolProperty14.symbols @@ -3,9 +3,9 @@ class C { >C : Symbol(C, Decl(symbolProperty14.ts, 0, 0)) [Symbol.iterator]: { x; y }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty14.ts, 1, 24)) >y : Symbol(y, Decl(symbolProperty14.ts, 1, 27)) } @@ -13,9 +13,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty14.ts, 2, 1)) [Symbol.iterator]?: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty14.ts, 4, 25)) } diff --git a/tests/baselines/reference/symbolProperty15.symbols b/tests/baselines/reference/symbolProperty15.symbols index 56f722c523b..83a3f4630fe 100644 --- a/tests/baselines/reference/symbolProperty15.symbols +++ b/tests/baselines/reference/symbolProperty15.symbols @@ -6,9 +6,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty15.ts, 0, 11)) [Symbol.iterator]?: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty15.ts, 2, 25)) } diff --git a/tests/baselines/reference/symbolProperty16.symbols b/tests/baselines/reference/symbolProperty16.symbols index 092d766034e..d54002167a1 100644 --- a/tests/baselines/reference/symbolProperty16.symbols +++ b/tests/baselines/reference/symbolProperty16.symbols @@ -3,18 +3,18 @@ class C { >C : Symbol(C, Decl(symbolProperty16.ts, 0, 0)) private [Symbol.iterator]: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty16.ts, 1, 32)) } interface I { >I : Symbol(I, Decl(symbolProperty16.ts, 2, 1)) [Symbol.iterator]: { x }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty16.ts, 4, 24)) } diff --git a/tests/baselines/reference/symbolProperty18.symbols b/tests/baselines/reference/symbolProperty18.symbols index b5d930b4005..8f863572639 100644 --- a/tests/baselines/reference/symbolProperty18.symbols +++ b/tests/baselines/reference/symbolProperty18.symbols @@ -3,39 +3,39 @@ var i = { >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) [Symbol.iterator]: 0, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) [Symbol.toStringTag]() { return "" }, ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) set [Symbol.toPrimitive](p: boolean) { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) >p : Symbol(p, Decl(symbolProperty18.ts, 3, 29)) } var it = i[Symbol.iterator]; >it : Symbol(it, Decl(symbolProperty18.ts, 6, 3)) >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) var str = i[Symbol.toStringTag](); >str : Symbol(str, Decl(symbolProperty18.ts, 7, 3)) >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) i[Symbol.toPrimitive] = false; >i : Symbol(i, Decl(symbolProperty18.ts, 0, 3)) ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/symbolProperty19.symbols b/tests/baselines/reference/symbolProperty19.symbols index eae891f2e22..a2c7dd7dcfd 100644 --- a/tests/baselines/reference/symbolProperty19.symbols +++ b/tests/baselines/reference/symbolProperty19.symbols @@ -3,15 +3,15 @@ var i = { >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3)) [Symbol.iterator]: { p: null }, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >p : Symbol(p, Decl(symbolProperty19.ts, 1, 24)) [Symbol.toStringTag]() { return { p: undefined }; } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) >p : Symbol(p, Decl(symbolProperty19.ts, 2, 37)) >undefined : Symbol(undefined) } @@ -19,14 +19,14 @@ var i = { var it = i[Symbol.iterator]; >it : Symbol(it, Decl(symbolProperty19.ts, 5, 3)) >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) var str = i[Symbol.toStringTag](); >str : Symbol(str, Decl(symbolProperty19.ts, 6, 3)) >i : Symbol(i, Decl(symbolProperty19.ts, 0, 3)) ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/symbolProperty2.symbols b/tests/baselines/reference/symbolProperty2.symbols index d03ca9a4c51..a9bc4a440e0 100644 --- a/tests/baselines/reference/symbolProperty2.symbols +++ b/tests/baselines/reference/symbolProperty2.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/es6/Symbols/symbolProperty2.ts === var s = Symbol(); >s : Symbol(s, Decl(symbolProperty2.ts, 0, 3)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var x = { >x : Symbol(x, Decl(symbolProperty2.ts, 1, 3)) diff --git a/tests/baselines/reference/symbolProperty20.symbols b/tests/baselines/reference/symbolProperty20.symbols index 110067abda5..97bb4164c2f 100644 --- a/tests/baselines/reference/symbolProperty20.symbols +++ b/tests/baselines/reference/symbolProperty20.symbols @@ -3,15 +3,15 @@ interface I { >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0)) [Symbol.iterator]: (s: string) => string; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(symbolProperty20.ts, 1, 24)) [Symbol.toStringTag](s: number): number; ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(symbolProperty20.ts, 2, 25)) } @@ -20,16 +20,16 @@ var i: I = { >I : Symbol(I, Decl(symbolProperty20.ts, 0, 0)) [Symbol.iterator]: s => s, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22)) >s : Symbol(s, Decl(symbolProperty20.ts, 6, 22)) [Symbol.toStringTag](n) { return n; } ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25)) >n : Symbol(n, Decl(symbolProperty20.ts, 7, 25)) } diff --git a/tests/baselines/reference/symbolProperty22.symbols b/tests/baselines/reference/symbolProperty22.symbols index 2288537456c..1d7f46fa897 100644 --- a/tests/baselines/reference/symbolProperty22.symbols +++ b/tests/baselines/reference/symbolProperty22.symbols @@ -5,9 +5,9 @@ interface I { >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14)) [Symbol.unscopables](x: T): U; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty22.ts, 1, 25)) >T : Symbol(T, Decl(symbolProperty22.ts, 0, 12)) >U : Symbol(U, Decl(symbolProperty22.ts, 0, 14)) @@ -27,11 +27,11 @@ declare function foo(p1: T, p2: I): U; foo("", { [Symbol.unscopables]: s => s.length }); >foo : Symbol(foo, Decl(symbolProperty22.ts, 2, 1)) ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31)) ->s.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>s.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(symbolProperty22.ts, 6, 31)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/symbolProperty23.symbols b/tests/baselines/reference/symbolProperty23.symbols index 152048a95a8..06fce65875c 100644 --- a/tests/baselines/reference/symbolProperty23.symbols +++ b/tests/baselines/reference/symbolProperty23.symbols @@ -3,9 +3,9 @@ interface I { >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0)) [Symbol.toPrimitive]: () => boolean; ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) } class C implements I { @@ -13,9 +13,9 @@ class C implements I { >I : Symbol(I, Decl(symbolProperty23.ts, 0, 0)) [Symbol.toPrimitive]() { ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) return true; } diff --git a/tests/baselines/reference/symbolProperty26.symbols b/tests/baselines/reference/symbolProperty26.symbols index 7a2e443368f..ae8f95d5859 100644 --- a/tests/baselines/reference/symbolProperty26.symbols +++ b/tests/baselines/reference/symbolProperty26.symbols @@ -3,9 +3,9 @@ class C1 { >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) return ""; } @@ -16,9 +16,9 @@ class C2 extends C1 { >C1 : Symbol(C1, Decl(symbolProperty26.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) return ""; } diff --git a/tests/baselines/reference/symbolProperty27.symbols b/tests/baselines/reference/symbolProperty27.symbols index 306802cdff2..d5fcf7ec224 100644 --- a/tests/baselines/reference/symbolProperty27.symbols +++ b/tests/baselines/reference/symbolProperty27.symbols @@ -3,9 +3,9 @@ class C1 { >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) return {}; } @@ -16,9 +16,9 @@ class C2 extends C1 { >C1 : Symbol(C1, Decl(symbolProperty27.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) return ""; } diff --git a/tests/baselines/reference/symbolProperty28.symbols b/tests/baselines/reference/symbolProperty28.symbols index 77b476c6ea3..d8c9daba0d9 100644 --- a/tests/baselines/reference/symbolProperty28.symbols +++ b/tests/baselines/reference/symbolProperty28.symbols @@ -3,9 +3,9 @@ class C1 { >C1 : Symbol(C1, Decl(symbolProperty28.ts, 0, 0)) [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) return { x: "" }; >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16)) @@ -24,8 +24,8 @@ var obj = c[Symbol.toStringTag]().x; >obj : Symbol(obj, Decl(symbolProperty28.ts, 9, 3)) >c[Symbol.toStringTag]().x : Symbol(x, Decl(symbolProperty28.ts, 2, 16)) >c : Symbol(c, Decl(symbolProperty28.ts, 8, 3)) ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty28.ts, 2, 16)) diff --git a/tests/baselines/reference/symbolProperty4.symbols b/tests/baselines/reference/symbolProperty4.symbols index c159cc756d8..7817a7c6fd0 100644 --- a/tests/baselines/reference/symbolProperty4.symbols +++ b/tests/baselines/reference/symbolProperty4.symbols @@ -3,13 +3,13 @@ var x = { >x : Symbol(x, Decl(symbolProperty4.ts, 0, 3)) [Symbol()]: 0, ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) [Symbol()]() { }, ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) get [Symbol()]() { ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) return 0; } diff --git a/tests/baselines/reference/symbolProperty40.symbols b/tests/baselines/reference/symbolProperty40.symbols index 29b66c96f1f..26a5dc36ed5 100644 --- a/tests/baselines/reference/symbolProperty40.symbols +++ b/tests/baselines/reference/symbolProperty40.symbols @@ -3,21 +3,21 @@ class C { >C : Symbol(C, Decl(symbolProperty40.ts, 0, 0)) [Symbol.iterator](x: string): string; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty40.ts, 1, 22)) [Symbol.iterator](x: number): number; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty40.ts, 2, 22)) [Symbol.iterator](x: any) { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty40.ts, 3, 22)) return undefined; @@ -31,13 +31,13 @@ var c = new C; c[Symbol.iterator](""); >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) c[Symbol.iterator](0); >c : Symbol(c, Decl(symbolProperty40.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/symbolProperty41.symbols b/tests/baselines/reference/symbolProperty41.symbols index 129c856b804..7db66e5862e 100644 --- a/tests/baselines/reference/symbolProperty41.symbols +++ b/tests/baselines/reference/symbolProperty41.symbols @@ -3,24 +3,24 @@ class C { >C : Symbol(C, Decl(symbolProperty41.ts, 0, 0)) [Symbol.iterator](x: string): { x: string }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty41.ts, 1, 22)) >x : Symbol(x, Decl(symbolProperty41.ts, 1, 35)) [Symbol.iterator](x: "hello"): { x: string; hello: string }; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty41.ts, 2, 22)) >x : Symbol(x, Decl(symbolProperty41.ts, 2, 36)) >hello : Symbol(hello, Decl(symbolProperty41.ts, 2, 47)) [Symbol.iterator](x: any) { ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(symbolProperty41.ts, 3, 22)) return undefined; @@ -34,13 +34,13 @@ var c = new C; c[Symbol.iterator](""); >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) c[Symbol.iterator]("hello"); >c : Symbol(c, Decl(symbolProperty41.ts, 8, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/symbolProperty45.symbols b/tests/baselines/reference/symbolProperty45.symbols index 34bb5ad967f..46ecb0a6414 100644 --- a/tests/baselines/reference/symbolProperty45.symbols +++ b/tests/baselines/reference/symbolProperty45.symbols @@ -3,16 +3,16 @@ class C { >C : Symbol(C, Decl(symbolProperty45.ts, 0, 0)) get [Symbol.hasInstance]() { ->Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 3876, 32)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, 3876, 32)) +>Symbol.hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>hasInstance : Symbol(SymbolConstructor.hasInstance, Decl(lib.d.ts, --, --)) return ""; } get [Symbol.toPrimitive]() { ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) return ""; } diff --git a/tests/baselines/reference/symbolProperty5.symbols b/tests/baselines/reference/symbolProperty5.symbols index 063ae8d3d34..00e47c461ee 100644 --- a/tests/baselines/reference/symbolProperty5.symbols +++ b/tests/baselines/reference/symbolProperty5.symbols @@ -3,19 +3,19 @@ var x = { >x : Symbol(x, Decl(symbolProperty5.ts, 0, 3)) [Symbol.iterator]: 0, ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) [Symbol.toPrimitive]() { }, ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) get [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) return 0; } diff --git a/tests/baselines/reference/symbolProperty50.symbols b/tests/baselines/reference/symbolProperty50.symbols index 64472f3c71a..f5197627846 100644 --- a/tests/baselines/reference/symbolProperty50.symbols +++ b/tests/baselines/reference/symbolProperty50.symbols @@ -9,8 +9,8 @@ module M { >C : Symbol(C, Decl(symbolProperty50.ts, 1, 24)) [Symbol.iterator]() { } ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/symbolProperty51.symbols b/tests/baselines/reference/symbolProperty51.symbols index 45a56260828..4be31dd0a56 100644 --- a/tests/baselines/reference/symbolProperty51.symbols +++ b/tests/baselines/reference/symbolProperty51.symbols @@ -9,8 +9,8 @@ module M { >C : Symbol(C, Decl(symbolProperty51.ts, 1, 21)) [Symbol.iterator]() { } ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/symbolProperty55.symbols b/tests/baselines/reference/symbolProperty55.symbols index 98f4a7769b2..e6a9c304abe 100644 --- a/tests/baselines/reference/symbolProperty55.symbols +++ b/tests/baselines/reference/symbolProperty55.symbols @@ -3,9 +3,9 @@ var obj = { >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3)) [Symbol.iterator]: 0 ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) }; @@ -14,13 +14,13 @@ module M { var Symbol: SymbolConstructor; >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7)) ->SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, 3850, 1)) +>SymbolConstructor : Symbol(SymbolConstructor, Decl(lib.d.ts, --, --)) // The following should be of type 'any'. This is because even though obj has a property keyed by Symbol.iterator, // the key passed in here is the *wrong* Symbol.iterator. It is not the iterator property of the global Symbol. obj[Symbol.iterator]; >obj : Symbol(obj, Decl(symbolProperty55.ts, 0, 3)) ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) >Symbol : Symbol(Symbol, Decl(symbolProperty55.ts, 5, 7)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/symbolProperty56.symbols b/tests/baselines/reference/symbolProperty56.symbols index fe73fb9f330..6ff465daa98 100644 --- a/tests/baselines/reference/symbolProperty56.symbols +++ b/tests/baselines/reference/symbolProperty56.symbols @@ -3,9 +3,9 @@ var obj = { >obj : Symbol(obj, Decl(symbolProperty56.ts, 0, 3)) [Symbol.iterator]: 0 ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) }; diff --git a/tests/baselines/reference/symbolProperty57.symbols b/tests/baselines/reference/symbolProperty57.symbols index eaf5be2a07c..b256ba651c4 100644 --- a/tests/baselines/reference/symbolProperty57.symbols +++ b/tests/baselines/reference/symbolProperty57.symbols @@ -3,14 +3,14 @@ var obj = { >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3)) [Symbol.iterator]: 0 ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) }; // Should give type 'any'. obj[Symbol["nonsense"]]; >obj : Symbol(obj, Decl(symbolProperty57.ts, 0, 3)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/symbolProperty6.symbols b/tests/baselines/reference/symbolProperty6.symbols index 04b89f43652..d0eedccf4fa 100644 --- a/tests/baselines/reference/symbolProperty6.symbols +++ b/tests/baselines/reference/symbolProperty6.symbols @@ -3,24 +3,24 @@ class C { >C : Symbol(C, Decl(symbolProperty6.ts, 0, 0)) [Symbol.iterator] = 0; ->Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, 3890, 31)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.d.ts, --, --)) [Symbol.unscopables]: number; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --)) [Symbol.toPrimitive]() { } ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) get [Symbol.toStringTag]() { ->Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, 3932, 24)) +>Symbol.toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toStringTag : Symbol(SymbolConstructor.toStringTag, Decl(lib.d.ts, --, --)) return 0; } diff --git a/tests/baselines/reference/symbolProperty8.symbols b/tests/baselines/reference/symbolProperty8.symbols index 541833d686a..8d26d193ef5 100644 --- a/tests/baselines/reference/symbolProperty8.symbols +++ b/tests/baselines/reference/symbolProperty8.symbols @@ -3,12 +3,12 @@ interface I { >I : Symbol(I, Decl(symbolProperty8.ts, 0, 0)) [Symbol.unscopables]: number; ->Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, 3938, 24)) +>Symbol.unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>unscopables : Symbol(SymbolConstructor.unscopables, Decl(lib.d.ts, --, --)) [Symbol.toPrimitive](); ->Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, 3926, 18)) +>Symbol.toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>toPrimitive : Symbol(SymbolConstructor.toPrimitive, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/symbolType11.symbols b/tests/baselines/reference/symbolType11.symbols index bbccd2a0f8b..d5c19af7844 100644 --- a/tests/baselines/reference/symbolType11.symbols +++ b/tests/baselines/reference/symbolType11.symbols @@ -1,9 +1,9 @@ === tests/cases/conformance/es6/Symbols/symbolType11.ts === var s = Symbol.for("logical"); >s : Symbol(s, Decl(symbolType11.ts, 0, 3)) ->Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3862, 42)) ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11)) ->for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, 3862, 42)) +>Symbol.for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>for : Symbol(SymbolConstructor.for, Decl(lib.d.ts, --, --)) s && s; >s : Symbol(s, Decl(symbolType11.ts, 0, 3)) diff --git a/tests/baselines/reference/symbolType16.symbols b/tests/baselines/reference/symbolType16.symbols index 9a25d9ad152..a31a4e5c677 100644 --- a/tests/baselines/reference/symbolType16.symbols +++ b/tests/baselines/reference/symbolType16.symbols @@ -1,6 +1,6 @@ === tests/cases/conformance/es6/Symbols/symbolType16.ts === interface Symbol { ->Symbol : Symbol(Symbol, Decl(lib.d.ts, 3840, 52), Decl(lib.d.ts, 3946, 11), Decl(symbolType16.ts, 0, 0)) +>Symbol : Symbol(Symbol, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(symbolType16.ts, 0, 0)) newSymbolProp: number; >newSymbolProp : Symbol(newSymbolProp, Decl(symbolType16.ts, 0, 18)) diff --git a/tests/baselines/reference/systemModule1.errors.txt b/tests/baselines/reference/systemModule1.errors.txt deleted file mode 100644 index 18b64607455..00000000000 --- a/tests/baselines/reference/systemModule1.errors.txt +++ /dev/null @@ -1,7 +0,0 @@ -error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. - - -!!! error TS1204: Cannot compile modules into 'commonjs', 'amd', 'system' or 'umd' when targeting 'ES6' or higher. -==== tests/cases/compiler/systemModule1.ts (0 errors) ==== - - export var x = 1; \ No newline at end of file diff --git a/tests/baselines/reference/systemModule1.js b/tests/baselines/reference/systemModule1.js index 9731106471c..573a7ae04c8 100644 --- a/tests/baselines/reference/systemModule1.js +++ b/tests/baselines/reference/systemModule1.js @@ -3,4 +3,12 @@ export var x = 1; //// [systemModule1.js] -export var x = 1; +System.register([], function(exports_1) { + var x; + return { + setters:[], + execute: function() { + x = 1; + } + } +}); diff --git a/tests/baselines/reference/systemModule1.symbols b/tests/baselines/reference/systemModule1.symbols new file mode 100644 index 00000000000..d6293c21fd9 --- /dev/null +++ b/tests/baselines/reference/systemModule1.symbols @@ -0,0 +1,5 @@ +=== tests/cases/compiler/systemModule1.ts === + +export var x = 1; +>x : Symbol(x, Decl(systemModule1.ts, 1, 10)) + diff --git a/tests/baselines/reference/systemModule1.types b/tests/baselines/reference/systemModule1.types new file mode 100644 index 00000000000..2adf73d116f --- /dev/null +++ b/tests/baselines/reference/systemModule1.types @@ -0,0 +1,6 @@ +=== tests/cases/compiler/systemModule1.ts === + +export var x = 1; +>x : number +>1 : number + diff --git a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols index f042978fa8c..2de45d16379 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping1.symbols +++ b/tests/baselines/reference/taggedTemplateContextualTyping1.symbols @@ -13,7 +13,7 @@ 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)) >T : Symbol(T, Decl(taggedTemplateContextualTyping1.ts, 3, 18)) >templateStrs : Symbol(templateStrs, Decl(taggedTemplateContextualTyping1.ts, 3, 21)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.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)) @@ -24,7 +24,7 @@ function tempTag1(templateStrs: TemplateStringsArray, f: FuncType, h: FuncTyp >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.d.ts, 518, 38)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.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)) diff --git a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols index 6918c5606a8..240cc344de7 100644 --- a/tests/baselines/reference/taggedTemplateContextualTyping2.symbols +++ b/tests/baselines/reference/taggedTemplateContextualTyping2.symbols @@ -22,7 +22,7 @@ type FuncType2 = (x: (p: T) => T) => typeof x; 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)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) >f : Symbol(f, Decl(taggedTemplateContextualTyping2.ts, 4, 53)) >FuncType1 : Symbol(FuncType1, Decl(taggedTemplateContextualTyping2.ts, 0, 0)) >x : Symbol(x, Decl(taggedTemplateContextualTyping2.ts, 4, 67)) @@ -30,7 +30,7 @@ function tempTag2(templateStrs: TemplateStringsArray, f: FuncType1, x: number): 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)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.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)) diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols index c4f538d3254..52b8f3ab6f0 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2.symbols @@ -3,7 +3,7 @@ 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)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 1, 41)) function foo1(strs: string[], x: number): number; @@ -35,7 +35,7 @@ function foo2(strs: string[], x: number): number; 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)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2.ts, 11, 41)) function foo2(...stuff: any[]): any { diff --git a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols index 0da33002d31..e96912ec3bb 100644 --- a/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols +++ b/tests/baselines/reference/taggedTemplateStringsWithOverloadResolution2_ES6.symbols @@ -2,7 +2,7 @@ function foo1(strs: TemplateStringsArray, x: number): string; >foo1 : Symbol(foo1, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 0), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 61), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 1, 49)) >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 14)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 0, 41)) function foo1(strs: string[], x: number): number; @@ -34,7 +34,7 @@ function foo2(strs: string[], x: number): number; function foo2(strs: TemplateStringsArray, x: number): string; >foo2 : Symbol(foo2, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 7, 20), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 9, 49), Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 10, 61)) >strs : Symbol(strs, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 10, 14)) ->TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, 518, 38)) +>TemplateStringsArray : Symbol(TemplateStringsArray, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(taggedTemplateStringsWithOverloadResolution2_ES6.ts, 10, 41)) function foo2(...stuff: any[]): any { diff --git a/tests/baselines/reference/targetTypeArgs.symbols b/tests/baselines/reference/targetTypeArgs.symbols index 6c1b2cd9cfe..b0d825ddd50 100644 --- a/tests/baselines/reference/targetTypeArgs.symbols +++ b/tests/baselines/reference/targetTypeArgs.symbols @@ -14,44 +14,44 @@ foo(function(x) { x }); >x : Symbol(x, Decl(targetTypeArgs.ts, 4, 13)) [1].forEach(function(v,i,a) { v }); ->[1].forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95)) ->forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95)) +>[1].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) +>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) >v : Symbol(v, Decl(targetTypeArgs.ts, 6, 21)) >i : Symbol(i, Decl(targetTypeArgs.ts, 6, 23)) >a : Symbol(a, Decl(targetTypeArgs.ts, 6, 25)) >v : Symbol(v, Decl(targetTypeArgs.ts, 6, 21)) ["hello"].every(function(v,i,a) {return true;}); ->["hello"].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62)) ->every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62)) +>["hello"].every : Symbol(Array.every, Decl(lib.d.ts, --, --)) +>every : Symbol(Array.every, Decl(lib.d.ts, --, --)) >v : Symbol(v, Decl(targetTypeArgs.ts, 7, 25)) >i : Symbol(i, Decl(targetTypeArgs.ts, 7, 27)) >a : Symbol(a, Decl(targetTypeArgs.ts, 7, 29)) [1].every(function(v,i,a) {return true;}); ->[1].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62)) ->every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62)) +>[1].every : Symbol(Array.every, Decl(lib.d.ts, --, --)) +>every : Symbol(Array.every, Decl(lib.d.ts, --, --)) >v : Symbol(v, Decl(targetTypeArgs.ts, 8, 19)) >i : Symbol(i, Decl(targetTypeArgs.ts, 8, 21)) >a : Symbol(a, Decl(targetTypeArgs.ts, 8, 23)) [1].every(function(v,i,a) {return true;}); ->[1].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62)) ->every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62)) +>[1].every : Symbol(Array.every, Decl(lib.d.ts, --, --)) +>every : Symbol(Array.every, Decl(lib.d.ts, --, --)) >v : Symbol(v, Decl(targetTypeArgs.ts, 9, 19)) >i : Symbol(i, Decl(targetTypeArgs.ts, 9, 21)) >a : Symbol(a, Decl(targetTypeArgs.ts, 9, 23)) ["s"].every(function(v,i,a) {return true;}); ->["s"].every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62)) ->every : Symbol(Array.every, Decl(lib.d.ts, 1094, 62)) +>["s"].every : Symbol(Array.every, Decl(lib.d.ts, --, --)) +>every : Symbol(Array.every, Decl(lib.d.ts, --, --)) >v : Symbol(v, Decl(targetTypeArgs.ts, 10, 21)) >i : Symbol(i, Decl(targetTypeArgs.ts, 10, 23)) >a : Symbol(a, Decl(targetTypeArgs.ts, 10, 25)) ["s"].forEach(function(v,i,a) { v }); ->["s"].forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95)) ->forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95)) +>["s"].forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) +>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) >v : Symbol(v, Decl(targetTypeArgs.ts, 11, 23)) >i : Symbol(i, Decl(targetTypeArgs.ts, 11, 25)) >a : Symbol(a, Decl(targetTypeArgs.ts, 11, 27)) diff --git a/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols b/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols index dbac3b57366..6df8d8ac2ad 100644 --- a/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols +++ b/tests/baselines/reference/targetTypeObjectLiteralToAny.symbols @@ -9,9 +9,9 @@ function suggest(){ >result : Symbol(result, Decl(targetTypeObjectLiteralToAny.ts, 2, 4)) TypeScriptKeywords.forEach(function(keyword) { ->TypeScriptKeywords.forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95)) +>TypeScriptKeywords.forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) >TypeScriptKeywords : Symbol(TypeScriptKeywords, Decl(targetTypeObjectLiteralToAny.ts, 1, 4)) ->forEach : Symbol(Array.forEach, Decl(lib.d.ts, 1108, 95)) +>forEach : Symbol(Array.forEach, Decl(lib.d.ts, --, --)) >keyword : Symbol(keyword, Decl(targetTypeObjectLiteralToAny.ts, 4, 37)) result.push({text:keyword, type:"keyword"}); // this should not cause a crash - push should be typed to any diff --git a/tests/baselines/reference/targetTypingOnFunctions.symbols b/tests/baselines/reference/targetTypingOnFunctions.symbols index ccf669ffa67..19dfda36f79 100644 --- a/tests/baselines/reference/targetTypingOnFunctions.symbols +++ b/tests/baselines/reference/targetTypingOnFunctions.symbols @@ -3,15 +3,15 @@ var fu: (s: string) => string = function (s) { return s.toLowerCase() }; >fu : Symbol(fu, Decl(targetTypingOnFunctions.ts, 0, 3)) >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 0, 9)) >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 0, 42)) ->s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 0, 42)) ->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) var zu = fu = function (s) { return s.toLowerCase() }; >zu : Symbol(zu, Decl(targetTypingOnFunctions.ts, 2, 3)) >fu : Symbol(fu, Decl(targetTypingOnFunctions.ts, 0, 3)) >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 2, 24)) ->s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>s.toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >s : Symbol(s, Decl(targetTypingOnFunctions.ts, 2, 24)) ->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperator.symbols b/tests/baselines/reference/templateStringWithEmbeddedNewOperator.symbols index ef18ef3df64..ed7ef9dbc63 100644 --- a/tests/baselines/reference/templateStringWithEmbeddedNewOperator.symbols +++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperator.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperator.ts === var x = `abc${ new String("Hi") }def`; >x : Symbol(x, Decl(templateStringWithEmbeddedNewOperator.ts, 0, 3)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols index 9d8b6024e0c..a7240d4fd22 100644 --- a/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols +++ b/tests/baselines/reference/templateStringWithEmbeddedNewOperatorES6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringWithEmbeddedNewOperatorES6.ts === var x = `abc${ new String("Hi") }def`; >x : Symbol(x, Decl(templateStringWithEmbeddedNewOperatorES6.ts, 0, 3)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11), Decl(lib.d.ts, 4236, 1)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.symbols b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.symbols index 7deee379f23..22af33732cf 100644 --- a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.symbols +++ b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlus.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlus.ts === var x = `abc${ +Infinity }def`; >x : Symbol(x, Decl(templateStringWithEmbeddedUnaryPlus.ts, 0, 3)) ->Infinity : Symbol(Infinity, Decl(lib.d.ts, 22, 11)) +>Infinity : Symbol(Infinity, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.symbols b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.symbols index 39f2cf60c8a..5d27cedede1 100644 --- a/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.symbols +++ b/tests/baselines/reference/templateStringWithEmbeddedUnaryPlusES6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringWithEmbeddedUnaryPlusES6.ts === var x = `abc${ +Infinity }def`; >x : Symbol(x, Decl(templateStringWithEmbeddedUnaryPlusES6.ts, 0, 3)) ->Infinity : Symbol(Infinity, Decl(lib.d.ts, 22, 11)) +>Infinity : Symbol(Infinity, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/templateStringWithPropertyAccess.symbols b/tests/baselines/reference/templateStringWithPropertyAccess.symbols index fc5464f1eff..16b090fe5ff 100644 --- a/tests/baselines/reference/templateStringWithPropertyAccess.symbols +++ b/tests/baselines/reference/templateStringWithPropertyAccess.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringWithPropertyAccess.ts === `abc${0}abc`.indexOf(`abc`); ->`abc${0}abc`.indexOf : Symbol(String.indexOf, Decl(lib.d.ts, 297, 41)) ->indexOf : Symbol(String.indexOf, Decl(lib.d.ts, 297, 41)) +>`abc${0}abc`.indexOf : Symbol(String.indexOf, Decl(lib.d.ts, --, --)) +>indexOf : Symbol(String.indexOf, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/templateStringWithPropertyAccessES6.symbols b/tests/baselines/reference/templateStringWithPropertyAccessES6.symbols index 22518032fc4..9259aff2a31 100644 --- a/tests/baselines/reference/templateStringWithPropertyAccessES6.symbols +++ b/tests/baselines/reference/templateStringWithPropertyAccessES6.symbols @@ -1,5 +1,5 @@ === tests/cases/conformance/es6/templates/templateStringWithPropertyAccessES6.ts === `abc${0}abc`.indexOf(`abc`); ->`abc${0}abc`.indexOf : Symbol(String.indexOf, Decl(lib.d.ts, 297, 41)) ->indexOf : Symbol(String.indexOf, Decl(lib.d.ts, 297, 41)) +>`abc${0}abc`.indexOf : Symbol(String.indexOf, Decl(lib.d.ts, --, --)) +>indexOf : Symbol(String.indexOf, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/thisBinding2.types b/tests/baselines/reference/thisBinding2.types index 5b6b5213524..99668ca4901 100644 --- a/tests/baselines/reference/thisBinding2.types +++ b/tests/baselines/reference/thisBinding2.types @@ -9,7 +9,7 @@ class C { this.x = (() => { >this.x = (() => { var x = 1; return this.x; })() : number >this.x : number ->this : C +>this : this >x : number >(() => { var x = 1; return this.x; })() : number >(() => { var x = 1; return this.x; }) : () => number @@ -21,14 +21,14 @@ class C { return this.x; >this.x : number ->this : C +>this : this >x : number })(); this.x = function() { >this.x = function() { var x = 1; return this.x; }() : any >this.x : number ->this : C +>this : this >x : number >function() { var x = 1; return this.x; }() : any >function() { var x = 1; return this.x; } : () => any diff --git a/tests/baselines/reference/thisCapture1.types b/tests/baselines/reference/thisCapture1.types index 05eabf5c914..eb4501203ca 100644 --- a/tests/baselines/reference/thisCapture1.types +++ b/tests/baselines/reference/thisCapture1.types @@ -25,7 +25,7 @@ class X { this.y = 0; >this.y = 0 : number >this.y : number ->this : X +>this : this >y : number >0 : number diff --git a/tests/baselines/reference/thisExpressionOfGenericObject.types b/tests/baselines/reference/thisExpressionOfGenericObject.types index 0a8e147f073..f7031d6cf80 100644 --- a/tests/baselines/reference/thisExpressionOfGenericObject.types +++ b/tests/baselines/reference/thisExpressionOfGenericObject.types @@ -9,8 +9,8 @@ class MyClass1 { constructor() { () => this; ->() => this : () => MyClass1 ->this : MyClass1 +>() => this : () => this +>this : this } } diff --git a/tests/baselines/reference/thisInInstanceMemberInitializer.types b/tests/baselines/reference/thisInInstanceMemberInitializer.types index 9c64929ca89..c7fcc69d006 100644 --- a/tests/baselines/reference/thisInInstanceMemberInitializer.types +++ b/tests/baselines/reference/thisInInstanceMemberInitializer.types @@ -3,8 +3,8 @@ class C { >C : C x = this; ->x : C ->this : C +>x : this +>this : this } class D { @@ -12,8 +12,8 @@ class D { >T : T x = this; ->x : D ->this : D +>x : this +>this : this y: T; >y : T diff --git a/tests/baselines/reference/thisInInvalidContexts.errors.txt b/tests/baselines/reference/thisInInvalidContexts.errors.txt index d6f24cbcfdc..76b90ed7c20 100644 --- a/tests/baselines/reference/thisInInvalidContexts.errors.txt +++ b/tests/baselines/reference/thisInInvalidContexts.errors.txt @@ -1,12 +1,13 @@ tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts(3,16): error TS2334: 'this' cannot be referenced in a static property initializer. tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts(22,15): error TS2332: 'this' cannot be referenced in current location. 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 (6 errors) ==== +==== tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts (7 errors) ==== //'this' in static member initializer class ErrClass1 { static t = this; // Error @@ -49,6 +50,8 @@ tests/cases/conformance/expressions/thisKeyword/thisInInvalidContexts.ts(45,9): //'this' as a type argument function genericFunc(x: T) { } genericFunc(undefined); // Should be an error + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. class ErrClass3 extends this { ~~~~ diff --git a/tests/baselines/reference/thisInInvalidContexts.js b/tests/baselines/reference/thisInInvalidContexts.js index 84b96404683..d5ba69ff536 100644 --- a/tests/baselines/reference/thisInInvalidContexts.js +++ b/tests/baselines/reference/thisInInvalidContexts.js @@ -92,7 +92,7 @@ var M; // function fn() { } // Error //'this' as a type argument function genericFunc(x) { } -genericFunc < this > (undefined); // Should be an error +genericFunc(undefined); // Should be an error var ErrClass3 = (function (_super) { __extends(ErrClass3, _super); function ErrClass3() { diff --git a/tests/baselines/reference/thisInInvalidContextsExternalModule.errors.txt b/tests/baselines/reference/thisInInvalidContextsExternalModule.errors.txt index df47901d771..2aa474d4cdc 100644 --- a/tests/baselines/reference/thisInInvalidContextsExternalModule.errors.txt +++ b/tests/baselines/reference/thisInInvalidContextsExternalModule.errors.txt @@ -1,13 +1,14 @@ tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalModule.ts(3,16): error TS2334: 'this' cannot be referenced in a static property initializer. tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalModule.ts(22,15): error TS2332: 'this' cannot be referenced in current location. 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(48,1): error TS1148: Cannot compile modules unless the '--module' flag is provided. -==== tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalModule.ts (7 errors) ==== +==== tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalModule.ts (8 errors) ==== //'this' in static member initializer class ErrClass1 { static t = this; // Error @@ -50,6 +51,8 @@ tests/cases/conformance/expressions/thisKeyword/thisInInvalidContextsExternalMod //'this' as a type argument function genericFunc(x: T) { } genericFunc(undefined); // Should be an error + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. class ErrClass3 extends this { ~~~~ diff --git a/tests/baselines/reference/thisInInvalidContextsExternalModule.js b/tests/baselines/reference/thisInInvalidContextsExternalModule.js index 7de94be9420..7c195964947 100644 --- a/tests/baselines/reference/thisInInvalidContextsExternalModule.js +++ b/tests/baselines/reference/thisInInvalidContextsExternalModule.js @@ -92,7 +92,7 @@ var M; // function fn() { } // Error //'this' as a type argument function genericFunc(x) { } -genericFunc < this > (undefined); // Should be an error +genericFunc(undefined); // Should be an error var ErrClass3 = (function (_super) { __extends(ErrClass3, _super); function ErrClass3() { diff --git a/tests/baselines/reference/thisInLambda.types b/tests/baselines/reference/thisInLambda.types index ef4d7557abd..aea7fb08bd6 100644 --- a/tests/baselines/reference/thisInLambda.types +++ b/tests/baselines/reference/thisInLambda.types @@ -11,14 +11,14 @@ class Foo { this.x; // 'this' is type 'Foo' >this.x : string ->this : Foo +>this : this >x : string var f = () => this.x; // 'this' should be type 'Foo' as well >f : () => string >() => this.x : () => string >this.x : string ->this : Foo +>this : this >x : string } } @@ -42,8 +42,8 @@ class myCls { >() => { var x = this; } : () => void var x = this; ->x : myCls ->this : myCls +>x : this +>this : this }); }); diff --git a/tests/baselines/reference/thisInObjectLiterals.errors.txt b/tests/baselines/reference/thisInObjectLiterals.errors.txt new file mode 100644 index 00000000000..73300d86d74 --- /dev/null +++ b/tests/baselines/reference/thisInObjectLiterals.errors.txt @@ -0,0 +1,24 @@ +tests/cases/conformance/expressions/thisKeyword/thisInObjectLiterals.ts(7,13): error TS2403: Subsequent variable declarations must have the same type. Variable 't' must be of type '{ x: this; y: number; }', but here has type '{ x: MyClass; y: number; }'. + + +==== tests/cases/conformance/expressions/thisKeyword/thisInObjectLiterals.ts (1 errors) ==== + class MyClass { + t: number; + + fn() { + //type of 'this' in an object literal is the containing scope's this + var t = { x: this, y: this.t }; + var t: { x: MyClass; y: number }; + ~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 't' must be of type '{ x: this; y: number; }', but here has type '{ x: MyClass; y: number; }'. + } + } + + //type of 'this' in an object literal property of a function type is Any + var obj = { + f() { + return this.spaaace; + } + }; + var obj: { f: () => any; }; + \ No newline at end of file diff --git a/tests/baselines/reference/thisInObjectLiterals.symbols b/tests/baselines/reference/thisInObjectLiterals.symbols deleted file mode 100644 index cb351ccd457..00000000000 --- a/tests/baselines/reference/thisInObjectLiterals.symbols +++ /dev/null @@ -1,42 +0,0 @@ -=== tests/cases/conformance/expressions/thisKeyword/thisInObjectLiterals.ts === -class MyClass { ->MyClass : Symbol(MyClass, Decl(thisInObjectLiterals.ts, 0, 0)) - - t: number; ->t : Symbol(t, Decl(thisInObjectLiterals.ts, 0, 15)) - - fn() { ->fn : Symbol(fn, Decl(thisInObjectLiterals.ts, 1, 14)) - - //type of 'this' in an object literal is the containing scope's this - var t = { x: this, y: this.t }; ->t : Symbol(t, Decl(thisInObjectLiterals.ts, 5, 11), Decl(thisInObjectLiterals.ts, 6, 11)) ->x : Symbol(x, Decl(thisInObjectLiterals.ts, 5, 17)) ->this : Symbol(MyClass, Decl(thisInObjectLiterals.ts, 0, 0)) ->y : Symbol(y, Decl(thisInObjectLiterals.ts, 5, 26)) ->this.t : Symbol(t, Decl(thisInObjectLiterals.ts, 0, 15)) ->this : Symbol(MyClass, Decl(thisInObjectLiterals.ts, 0, 0)) ->t : Symbol(t, Decl(thisInObjectLiterals.ts, 0, 15)) - - var t: { x: MyClass; y: number }; ->t : Symbol(t, Decl(thisInObjectLiterals.ts, 5, 11), Decl(thisInObjectLiterals.ts, 6, 11)) ->x : Symbol(x, Decl(thisInObjectLiterals.ts, 6, 16)) ->MyClass : Symbol(MyClass, Decl(thisInObjectLiterals.ts, 0, 0)) ->y : Symbol(y, Decl(thisInObjectLiterals.ts, 6, 28)) - } -} - -//type of 'this' in an object literal property of a function type is Any -var obj = { ->obj : Symbol(obj, Decl(thisInObjectLiterals.ts, 11, 3), Decl(thisInObjectLiterals.ts, 16, 3)) - - f() { ->f : Symbol(f, Decl(thisInObjectLiterals.ts, 11, 11)) - - return this.spaaace; - } -}; -var obj: { f: () => any; }; ->obj : Symbol(obj, Decl(thisInObjectLiterals.ts, 11, 3), Decl(thisInObjectLiterals.ts, 16, 3)) ->f : Symbol(f, Decl(thisInObjectLiterals.ts, 16, 10)) - diff --git a/tests/baselines/reference/thisInObjectLiterals.types b/tests/baselines/reference/thisInObjectLiterals.types deleted file mode 100644 index d3853389a9e..00000000000 --- a/tests/baselines/reference/thisInObjectLiterals.types +++ /dev/null @@ -1,47 +0,0 @@ -=== tests/cases/conformance/expressions/thisKeyword/thisInObjectLiterals.ts === -class MyClass { ->MyClass : MyClass - - t: number; ->t : number - - fn() { ->fn : () => void - - //type of 'this' in an object literal is the containing scope's this - var t = { x: this, y: this.t }; ->t : { x: MyClass; y: number; } ->{ x: this, y: this.t } : { x: MyClass; y: number; } ->x : MyClass ->this : MyClass ->y : number ->this.t : number ->this : MyClass ->t : number - - var t: { x: MyClass; y: number }; ->t : { x: MyClass; y: number; } ->x : MyClass ->MyClass : MyClass ->y : number - } -} - -//type of 'this' in an object literal property of a function type is Any -var obj = { ->obj : { f(): any; } ->{ f() { return this.spaaace; }} : { f(): any; } - - f() { ->f : () => any - - return this.spaaace; ->this.spaaace : any ->this : any ->spaaace : any - } -}; -var obj: { f: () => any; }; ->obj : { f(): any; } ->f : () => any - diff --git a/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols b/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols index 6a5f1417cd0..9d405b8f6f6 100644 --- a/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols +++ b/tests/baselines/reference/thisInPropertyBoundDeclarations.symbols @@ -7,7 +7,7 @@ class Bug { private static func: Function[] = [ >func : Symbol(Bug.func, Decl(thisInPropertyBoundDeclarations.ts, 1, 25)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) (that: Bug, name: string) => { >that : Symbol(that, Decl(thisInPropertyBoundDeclarations.ts, 4, 6)) @@ -15,9 +15,9 @@ class Bug { >name : Symbol(name, Decl(thisInPropertyBoundDeclarations.ts, 4, 16)) that.foo(name); ->that.foo : Symbol(foo, Decl(thisInPropertyBoundDeclarations.ts, 7, 6)) +>that.foo : Symbol(Bug.foo, Decl(thisInPropertyBoundDeclarations.ts, 7, 6)) >that : Symbol(that, Decl(thisInPropertyBoundDeclarations.ts, 4, 6)) ->foo : Symbol(foo, Decl(thisInPropertyBoundDeclarations.ts, 7, 6)) +>foo : Symbol(Bug.foo, Decl(thisInPropertyBoundDeclarations.ts, 7, 6)) >name : Symbol(name, Decl(thisInPropertyBoundDeclarations.ts, 4, 16)) } ]; diff --git a/tests/baselines/reference/thisInPropertyBoundDeclarations.types b/tests/baselines/reference/thisInPropertyBoundDeclarations.types index 596632f1691..f871e78d219 100644 --- a/tests/baselines/reference/thisInPropertyBoundDeclarations.types +++ b/tests/baselines/reference/thisInPropertyBoundDeclarations.types @@ -32,7 +32,7 @@ class Bug { this.name = name; >this.name = name : string >this.name : string ->this : Bug +>this : this >name : string >name : string } @@ -110,21 +110,21 @@ class B { >B : B prop1 = this; ->prop1 : B ->this : B +>prop1 : this +>this : this prop2 = () => this; ->prop2 : () => B ->() => this : () => B ->this : B +>prop2 : () => this +>() => this : () => this +>this : this prop3 = () => () => () => () => this; ->prop3 : () => () => () => () => B ->() => () => () => () => this : () => () => () => () => B ->() => () => () => this : () => () => () => B ->() => () => this : () => () => B ->() => this : () => B ->this : B +>prop3 : () => () => () => () => this +>() => () => () => () => this : () => () => () => () => this +>() => () => () => this : () => () => () => this +>() => () => this : () => () => this +>() => this : () => this +>this : this prop4 = ' ' + >prop4 : string @@ -141,34 +141,34 @@ class B { >' ' : string (() => () => () => this); ->(() => () => () => this) : () => () => () => B ->() => () => () => this : () => () => () => B ->() => () => this : () => () => B ->() => this : () => B ->this : B +>(() => () => () => this) : () => () => () => this +>() => () => () => this : () => () => () => this +>() => () => this : () => () => this +>() => this : () => this +>this : this prop5 = { ->prop5 : { a: () => B; } ->{ a: () => { return this; } } : { a: () => B; } +>prop5 : { a: () => this; } +>{ a: () => { return this; } } : { a: () => this; } a: () => { return this; } ->a : () => B ->() => { return this; } : () => B ->this : B +>a : () => this +>() => { return this; } : () => this +>this : this }; prop6 = () => { ->prop6 : () => { a: () => B; } ->() => { return { a: () => { return this; } }; } : () => { a: () => B; } +>prop6 : () => { a: () => this; } +>() => { return { a: () => { return this; } }; } : () => { a: () => this; } return { ->{ a: () => { return this; } } : { a: () => B; } +>{ a: () => { return this; } } : { a: () => this; } a: () => { return this; } ->a : () => B ->() => { return this; } : () => B ->this : B +>a : () => this +>() => { return this; } : () => this +>this : this }; }; diff --git a/tests/baselines/reference/thisTypeErrors.errors.txt b/tests/baselines/reference/thisTypeErrors.errors.txt new file mode 100644 index 00000000000..17b7e0d39b9 --- /dev/null +++ b/tests/baselines/reference/thisTypeErrors.errors.txt @@ -0,0 +1,149 @@ +tests/cases/conformance/types/thisType/thisTypeErrors.ts(1,9): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(2,14): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(3,9): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(5,16): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(5,23): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(6,12): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(11,13): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(12,14): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(13,18): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(14,23): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(15,15): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(15,22): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(19,13): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(20,14): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(21,18): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(22,23): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(23,15): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(23,22): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(27,15): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(28,17): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(29,19): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(29,26): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(35,19): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(36,20): error TS2331: 'this' cannot be referenced in a module or namespace body. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(41,14): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(41,21): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(46,23): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(46,30): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(50,18): error TS2526: A 'this' type is available only in a non-static member of a class or interface. +tests/cases/conformance/types/thisType/thisTypeErrors.ts(50,25): error TS2526: A 'this' type is available only in a non-static member of a class or interface. + + +==== tests/cases/conformance/types/thisType/thisTypeErrors.ts (30 errors) ==== + var x1: this; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + var x2: { a: this }; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + var x3: this[]; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + + function f1(x: this): this { + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + var y: this; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + return this; + } + + interface I1 { + a: { x: this }; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + b: { (): this }; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + c: { new (): this }; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + d: { [x: string]: this }; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + e: { f(x: this): this }; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + } + + class C1 { + a: { x: this }; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + b: { (): this }; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + c: { new (): this }; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + d: { [x: string]: this }; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + e: { f(x: this): this }; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + } + + class C2 { + static x: this; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + static y = undefined; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + static foo(x: this): this { + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + return undefined; + } + } + + namespace N1 { + export var x: this; + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + export var y = this; + ~~~~ +!!! error TS2331: 'this' cannot be referenced in a module or namespace body. + } + + class C3 { + x1 = { + g(x: this): this { + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + return undefined; + } + } + f() { + function g(x: this): this { + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + return undefined; + } + let x2 = { + h(x: this): this { + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + ~~~~ +!!! error TS2526: A 'this' type is available only in a non-static member of a class or interface. + return undefined; + } + } + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/thisTypeErrors.js b/tests/baselines/reference/thisTypeErrors.js new file mode 100644 index 00000000000..677feb374e1 --- /dev/null +++ b/tests/baselines/reference/thisTypeErrors.js @@ -0,0 +1,104 @@ +//// [thisTypeErrors.ts] +var x1: this; +var x2: { a: this }; +var x3: this[]; + +function f1(x: this): this { + var y: this; + return this; +} + +interface I1 { + a: { x: this }; + b: { (): this }; + c: { new (): this }; + d: { [x: string]: this }; + e: { f(x: this): this }; +} + +class C1 { + a: { x: this }; + b: { (): this }; + c: { new (): this }; + d: { [x: string]: this }; + e: { f(x: this): this }; +} + +class C2 { + static x: this; + static y = undefined; + static foo(x: this): this { + return undefined; + } +} + +namespace N1 { + export var x: this; + export var y = this; +} + +class C3 { + x1 = { + g(x: this): this { + return undefined; + } + } + f() { + function g(x: this): this { + return undefined; + } + let x2 = { + h(x: this): this { + return undefined; + } + } + } +} + + +//// [thisTypeErrors.js] +var x1; +var x2; +var x3; +function f1(x) { + var y; + return this; +} +var C1 = (function () { + function C1() { + } + return C1; +})(); +var C2 = (function () { + function C2() { + } + C2.foo = function (x) { + return undefined; + }; + C2.y = undefined; + return C2; +})(); +var N1; +(function (N1) { + N1.y = this; +})(N1 || (N1 = {})); +var C3 = (function () { + function C3() { + this.x1 = { + g: function (x) { + return undefined; + } + }; + } + C3.prototype.f = function () { + function g(x) { + return undefined; + } + var x2 = { + h: function (x) { + return undefined; + } + }; + }; + return C3; +})(); diff --git a/tests/baselines/reference/thisTypeInClasses.js b/tests/baselines/reference/thisTypeInClasses.js new file mode 100644 index 00000000000..93344fa62cb --- /dev/null +++ b/tests/baselines/reference/thisTypeInClasses.js @@ -0,0 +1,91 @@ +//// [thisTypeInClasses.ts] +class C1 { + x: this; + f(x: this): this { return undefined; } + constructor(x: this) { } +} + +class C2 { + [x: string]: this; +} + +interface Foo { + x: T; + y: this; +} + +class C3 { + a: this[]; + b: [this, this]; + c: this | Date; + d: this & Date; + e: (((this))); + f: (x: this) => this; + g: new (x: this) => this; + h: Foo; + i: Foo this)>; + j: (x: any) => x is this; +} + +declare class C4 { + x: this; + f(x: this): this; +} + +class C5 { + foo() { + let f1 = (x: this): this => this; + let f2 = (x: this) => this; + let f3 = (x: this) => (y: this) => this; + let f4 = (x: this) => { + let g = (y: this) => { + return () => this; + } + return g(this); + } + } + bar() { + let x1 = undefined; + let x2 = undefined as this; + } +} + + +//// [thisTypeInClasses.js] +var C1 = (function () { + function C1(x) { + } + C1.prototype.f = function (x) { return undefined; }; + return C1; +})(); +var C2 = (function () { + function C2() { + } + return C2; +})(); +var C3 = (function () { + function C3() { + } + return C3; +})(); +var C5 = (function () { + function C5() { + } + C5.prototype.foo = function () { + var _this = this; + var f1 = function (x) { return _this; }; + var f2 = function (x) { return _this; }; + var f3 = function (x) { return function (y) { return _this; }; }; + var f4 = function (x) { + var g = function (y) { + return function () { return _this; }; + }; + return g(_this); + }; + }; + C5.prototype.bar = function () { + var x1 = undefined; + var x2 = undefined; + }; + return C5; +})(); diff --git a/tests/baselines/reference/thisTypeInClasses.symbols b/tests/baselines/reference/thisTypeInClasses.symbols new file mode 100644 index 00000000000..04ed47b09ff --- /dev/null +++ b/tests/baselines/reference/thisTypeInClasses.symbols @@ -0,0 +1,140 @@ +=== tests/cases/conformance/types/thisType/thisTypeInClasses.ts === +class C1 { +>C1 : Symbol(C1, Decl(thisTypeInClasses.ts, 0, 0)) + + x: this; +>x : Symbol(x, Decl(thisTypeInClasses.ts, 0, 10)) + + f(x: this): this { return undefined; } +>f : Symbol(f, Decl(thisTypeInClasses.ts, 1, 12)) +>x : Symbol(x, Decl(thisTypeInClasses.ts, 2, 6)) +>undefined : Symbol(undefined) + + constructor(x: this) { } +>x : Symbol(x, Decl(thisTypeInClasses.ts, 3, 16)) +} + +class C2 { +>C2 : Symbol(C2, Decl(thisTypeInClasses.ts, 4, 1)) + + [x: string]: this; +>x : Symbol(x, Decl(thisTypeInClasses.ts, 7, 5)) +} + +interface Foo { +>Foo : Symbol(Foo, Decl(thisTypeInClasses.ts, 8, 1)) +>T : Symbol(T, Decl(thisTypeInClasses.ts, 10, 14)) + + x: T; +>x : Symbol(x, Decl(thisTypeInClasses.ts, 10, 18)) +>T : Symbol(T, Decl(thisTypeInClasses.ts, 10, 14)) + + y: this; +>y : Symbol(y, Decl(thisTypeInClasses.ts, 11, 9)) +} + +class C3 { +>C3 : Symbol(C3, Decl(thisTypeInClasses.ts, 13, 1)) + + a: this[]; +>a : Symbol(a, Decl(thisTypeInClasses.ts, 15, 10)) + + b: [this, this]; +>b : Symbol(b, Decl(thisTypeInClasses.ts, 16, 14)) + + c: this | Date; +>c : Symbol(c, Decl(thisTypeInClasses.ts, 17, 20)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + d: this & Date; +>d : Symbol(d, Decl(thisTypeInClasses.ts, 18, 19)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + e: (((this))); +>e : Symbol(e, Decl(thisTypeInClasses.ts, 19, 19)) + + f: (x: this) => this; +>f : Symbol(f, Decl(thisTypeInClasses.ts, 20, 18)) +>x : Symbol(x, Decl(thisTypeInClasses.ts, 21, 8)) + + g: new (x: this) => this; +>g : Symbol(g, Decl(thisTypeInClasses.ts, 21, 25)) +>x : Symbol(x, Decl(thisTypeInClasses.ts, 22, 12)) + + h: Foo; +>h : Symbol(h, Decl(thisTypeInClasses.ts, 22, 29)) +>Foo : Symbol(Foo, Decl(thisTypeInClasses.ts, 8, 1)) + + i: Foo this)>; +>i : Symbol(i, Decl(thisTypeInClasses.ts, 23, 17)) +>Foo : Symbol(Foo, Decl(thisTypeInClasses.ts, 8, 1)) + + j: (x: any) => x is this; +>j : Symbol(j, Decl(thisTypeInClasses.ts, 24, 32)) +>x : Symbol(x, Decl(thisTypeInClasses.ts, 25, 8)) +>x : Symbol(x, Decl(thisTypeInClasses.ts, 25, 8)) +} + +declare class C4 { +>C4 : Symbol(C4, Decl(thisTypeInClasses.ts, 26, 1)) + + x: this; +>x : Symbol(x, Decl(thisTypeInClasses.ts, 28, 18)) + + f(x: this): this; +>f : Symbol(f, Decl(thisTypeInClasses.ts, 29, 12)) +>x : Symbol(x, Decl(thisTypeInClasses.ts, 30, 6)) +} + +class C5 { +>C5 : Symbol(C5, Decl(thisTypeInClasses.ts, 31, 1)) + + foo() { +>foo : Symbol(foo, Decl(thisTypeInClasses.ts, 33, 10)) + + let f1 = (x: this): this => this; +>f1 : Symbol(f1, Decl(thisTypeInClasses.ts, 35, 11)) +>x : Symbol(x, Decl(thisTypeInClasses.ts, 35, 18)) +>this : Symbol(C5, Decl(thisTypeInClasses.ts, 31, 1)) +>this : Symbol(C5, Decl(thisTypeInClasses.ts, 31, 1)) + + let f2 = (x: this) => this; +>f2 : Symbol(f2, Decl(thisTypeInClasses.ts, 36, 11)) +>x : Symbol(x, Decl(thisTypeInClasses.ts, 36, 18)) +>this : Symbol(C5, Decl(thisTypeInClasses.ts, 31, 1)) + + let f3 = (x: this) => (y: this) => this; +>f3 : Symbol(f3, Decl(thisTypeInClasses.ts, 37, 11)) +>x : Symbol(x, Decl(thisTypeInClasses.ts, 37, 18)) +>y : Symbol(y, Decl(thisTypeInClasses.ts, 37, 31)) +>this : Symbol(C5, Decl(thisTypeInClasses.ts, 31, 1)) + + let f4 = (x: this) => { +>f4 : Symbol(f4, Decl(thisTypeInClasses.ts, 38, 11)) +>x : Symbol(x, Decl(thisTypeInClasses.ts, 38, 18)) + + let g = (y: this) => { +>g : Symbol(g, Decl(thisTypeInClasses.ts, 39, 15)) +>y : Symbol(y, Decl(thisTypeInClasses.ts, 39, 21)) + + return () => this; +>this : Symbol(C5, Decl(thisTypeInClasses.ts, 31, 1)) + } + return g(this); +>g : Symbol(g, Decl(thisTypeInClasses.ts, 39, 15)) +>this : Symbol(C5, Decl(thisTypeInClasses.ts, 31, 1)) + } + } + bar() { +>bar : Symbol(bar, Decl(thisTypeInClasses.ts, 44, 5)) + + let x1 = undefined; +>x1 : Symbol(x1, Decl(thisTypeInClasses.ts, 46, 11)) +>undefined : Symbol(undefined) + + let x2 = undefined as this; +>x2 : Symbol(x2, Decl(thisTypeInClasses.ts, 47, 11)) +>undefined : Symbol(undefined) + } +} + diff --git a/tests/baselines/reference/thisTypeInClasses.types b/tests/baselines/reference/thisTypeInClasses.types new file mode 100644 index 00000000000..ddfdfb277a9 --- /dev/null +++ b/tests/baselines/reference/thisTypeInClasses.types @@ -0,0 +1,150 @@ +=== tests/cases/conformance/types/thisType/thisTypeInClasses.ts === +class C1 { +>C1 : C1 + + x: this; +>x : this + + f(x: this): this { return undefined; } +>f : (x: this) => this +>x : this +>undefined : undefined + + constructor(x: this) { } +>x : this +} + +class C2 { +>C2 : C2 + + [x: string]: this; +>x : string +} + +interface Foo { +>Foo : Foo +>T : T + + x: T; +>x : T +>T : T + + y: this; +>y : this +} + +class C3 { +>C3 : C3 + + a: this[]; +>a : this[] + + b: [this, this]; +>b : [this, this] + + c: this | Date; +>c : this | Date +>Date : Date + + d: this & Date; +>d : this & Date +>Date : Date + + e: (((this))); +>e : this + + f: (x: this) => this; +>f : (x: this) => this +>x : this + + g: new (x: this) => this; +>g : new (x: this) => this +>x : this + + h: Foo; +>h : Foo +>Foo : Foo + + i: Foo this)>; +>i : Foo this)> +>Foo : Foo + + j: (x: any) => x is this; +>j : (x: any) => x is this +>x : any +>x : any +} + +declare class C4 { +>C4 : C4 + + x: this; +>x : this + + f(x: this): this; +>f : (x: this) => this +>x : this +} + +class C5 { +>C5 : C5 + + foo() { +>foo : () => void + + let f1 = (x: this): this => this; +>f1 : (x: this) => this +>(x: this): this => this : (x: this) => this +>x : this +>this : this +>this : this + + let f2 = (x: this) => this; +>f2 : (x: this) => this +>(x: this) => this : (x: this) => this +>x : this +>this : this + + let f3 = (x: this) => (y: this) => this; +>f3 : (x: this) => (y: this) => this +>(x: this) => (y: this) => this : (x: this) => (y: this) => this +>x : this +>(y: this) => this : (y: this) => this +>y : this +>this : this + + let f4 = (x: this) => { +>f4 : (x: this) => () => this +>(x: this) => { let g = (y: this) => { return () => this; } return g(this); } : (x: this) => () => this +>x : this + + let g = (y: this) => { +>g : (y: this) => () => this +>(y: this) => { return () => this; } : (y: this) => () => this +>y : this + + return () => this; +>() => this : () => this +>this : this + } + return g(this); +>g(this) : () => this +>g : (y: this) => () => this +>this : this + } + } + bar() { +>bar : () => void + + let x1 = undefined; +>x1 : this +>undefined : this +>undefined : undefined + + let x2 = undefined as this; +>x2 : this +>undefined as this : this +>undefined : undefined + } +} + diff --git a/tests/baselines/reference/thisTypeInInterfaces.js b/tests/baselines/reference/thisTypeInInterfaces.js new file mode 100644 index 00000000000..eb521918d33 --- /dev/null +++ b/tests/baselines/reference/thisTypeInInterfaces.js @@ -0,0 +1,32 @@ +//// [thisTypeInInterfaces.ts] +interface I1 { + x: this; + f(x: this): this; +} + +interface I2 { + (x: this): this; + new (x: this): this; + [x: string]: this; +} + +interface Foo { + x: T; + y: this; +} + +interface I3 { + a: this[]; + b: [this, this]; + c: this | Date; + d: this & Date; + e: (((this))); + f: (x: this) => this; + g: new (x: this) => this; + h: Foo; + i: Foo this)>; + j: (x: any) => x is this; +} + + +//// [thisTypeInInterfaces.js] diff --git a/tests/baselines/reference/thisTypeInInterfaces.symbols b/tests/baselines/reference/thisTypeInInterfaces.symbols new file mode 100644 index 00000000000..4ab896ae6f6 --- /dev/null +++ b/tests/baselines/reference/thisTypeInInterfaces.symbols @@ -0,0 +1,79 @@ +=== tests/cases/conformance/types/thisType/thisTypeInInterfaces.ts === +interface I1 { +>I1 : Symbol(I1, Decl(thisTypeInInterfaces.ts, 0, 0)) + + x: this; +>x : Symbol(x, Decl(thisTypeInInterfaces.ts, 0, 14)) + + f(x: this): this; +>f : Symbol(f, Decl(thisTypeInInterfaces.ts, 1, 12)) +>x : Symbol(x, Decl(thisTypeInInterfaces.ts, 2, 6)) +} + +interface I2 { +>I2 : Symbol(I2, Decl(thisTypeInInterfaces.ts, 3, 1)) + + (x: this): this; +>x : Symbol(x, Decl(thisTypeInInterfaces.ts, 6, 5)) + + new (x: this): this; +>x : Symbol(x, Decl(thisTypeInInterfaces.ts, 7, 9)) + + [x: string]: this; +>x : Symbol(x, Decl(thisTypeInInterfaces.ts, 8, 5)) +} + +interface Foo { +>Foo : Symbol(Foo, Decl(thisTypeInInterfaces.ts, 9, 1)) +>T : Symbol(T, Decl(thisTypeInInterfaces.ts, 11, 14)) + + x: T; +>x : Symbol(x, Decl(thisTypeInInterfaces.ts, 11, 18)) +>T : Symbol(T, Decl(thisTypeInInterfaces.ts, 11, 14)) + + y: this; +>y : Symbol(y, Decl(thisTypeInInterfaces.ts, 12, 9)) +} + +interface I3 { +>I3 : Symbol(I3, Decl(thisTypeInInterfaces.ts, 14, 1)) + + a: this[]; +>a : Symbol(a, Decl(thisTypeInInterfaces.ts, 16, 14)) + + b: [this, this]; +>b : Symbol(b, Decl(thisTypeInInterfaces.ts, 17, 14)) + + c: this | Date; +>c : Symbol(c, Decl(thisTypeInInterfaces.ts, 18, 20)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + d: this & Date; +>d : Symbol(d, Decl(thisTypeInInterfaces.ts, 19, 19)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + e: (((this))); +>e : Symbol(e, Decl(thisTypeInInterfaces.ts, 20, 19)) + + f: (x: this) => this; +>f : Symbol(f, Decl(thisTypeInInterfaces.ts, 21, 18)) +>x : Symbol(x, Decl(thisTypeInInterfaces.ts, 22, 8)) + + g: new (x: this) => this; +>g : Symbol(g, Decl(thisTypeInInterfaces.ts, 22, 25)) +>x : Symbol(x, Decl(thisTypeInInterfaces.ts, 23, 12)) + + h: Foo; +>h : Symbol(h, Decl(thisTypeInInterfaces.ts, 23, 29)) +>Foo : Symbol(Foo, Decl(thisTypeInInterfaces.ts, 9, 1)) + + i: Foo this)>; +>i : Symbol(i, Decl(thisTypeInInterfaces.ts, 24, 17)) +>Foo : Symbol(Foo, Decl(thisTypeInInterfaces.ts, 9, 1)) + + j: (x: any) => x is this; +>j : Symbol(j, Decl(thisTypeInInterfaces.ts, 25, 32)) +>x : Symbol(x, Decl(thisTypeInInterfaces.ts, 26, 8)) +>x : Symbol(x, Decl(thisTypeInInterfaces.ts, 26, 8)) +} + diff --git a/tests/baselines/reference/thisTypeInInterfaces.types b/tests/baselines/reference/thisTypeInInterfaces.types new file mode 100644 index 00000000000..5eadd7c13be --- /dev/null +++ b/tests/baselines/reference/thisTypeInInterfaces.types @@ -0,0 +1,79 @@ +=== tests/cases/conformance/types/thisType/thisTypeInInterfaces.ts === +interface I1 { +>I1 : I1 + + x: this; +>x : this + + f(x: this): this; +>f : (x: this) => this +>x : this +} + +interface I2 { +>I2 : I2 + + (x: this): this; +>x : this + + new (x: this): this; +>x : this + + [x: string]: this; +>x : string +} + +interface Foo { +>Foo : Foo +>T : T + + x: T; +>x : T +>T : T + + y: this; +>y : this +} + +interface I3 { +>I3 : I3 + + a: this[]; +>a : this[] + + b: [this, this]; +>b : [this, this] + + c: this | Date; +>c : this | Date +>Date : Date + + d: this & Date; +>d : this & Date +>Date : Date + + e: (((this))); +>e : this + + f: (x: this) => this; +>f : (x: this) => this +>x : this + + g: new (x: this) => this; +>g : new (x: this) => this +>x : this + + h: Foo; +>h : Foo +>Foo : Foo + + i: Foo this)>; +>i : Foo this)> +>Foo : Foo + + j: (x: any) => x is this; +>j : (x: any) => x is this +>x : any +>x : any +} + diff --git a/tests/baselines/reference/thisTypeInTuples.js b/tests/baselines/reference/thisTypeInTuples.js new file mode 100644 index 00000000000..b80cfded513 --- /dev/null +++ b/tests/baselines/reference/thisTypeInTuples.js @@ -0,0 +1,16 @@ +//// [thisTypeInTuples.ts] +interface Array { + slice(): this; +} + +let t: [number, string] = [42, "hello"]; +let a = t.slice(); +let b = t.slice(1); +let c = t.slice(0, 1); + + +//// [thisTypeInTuples.js] +var t = [42, "hello"]; +var a = t.slice(); +var b = t.slice(1); +var c = t.slice(0, 1); diff --git a/tests/baselines/reference/thisTypeInTuples.symbols b/tests/baselines/reference/thisTypeInTuples.symbols new file mode 100644 index 00000000000..256f182dd69 --- /dev/null +++ b/tests/baselines/reference/thisTypeInTuples.symbols @@ -0,0 +1,30 @@ +=== tests/cases/conformance/types/thisType/thisTypeInTuples.ts === +interface Array { +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 0)) +>T : Symbol(T, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 16)) + + slice(): this; +>slice : Symbol(slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20)) +} + +let t: [number, string] = [42, "hello"]; +>t : Symbol(t, Decl(thisTypeInTuples.ts, 4, 3)) + +let a = t.slice(); +>a : Symbol(a, Decl(thisTypeInTuples.ts, 5, 3)) +>t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20)) +>t : Symbol(t, Decl(thisTypeInTuples.ts, 4, 3)) +>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20)) + +let b = t.slice(1); +>b : Symbol(b, Decl(thisTypeInTuples.ts, 6, 3)) +>t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20)) +>t : Symbol(t, Decl(thisTypeInTuples.ts, 4, 3)) +>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20)) + +let c = t.slice(0, 1); +>c : Symbol(c, Decl(thisTypeInTuples.ts, 7, 3)) +>t.slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20)) +>t : Symbol(t, Decl(thisTypeInTuples.ts, 4, 3)) +>slice : Symbol(Array.slice, Decl(lib.d.ts, --, --), Decl(thisTypeInTuples.ts, 0, 20)) + diff --git a/tests/baselines/reference/thisTypeInTuples.types b/tests/baselines/reference/thisTypeInTuples.types new file mode 100644 index 00000000000..e0268840317 --- /dev/null +++ b/tests/baselines/reference/thisTypeInTuples.types @@ -0,0 +1,39 @@ +=== tests/cases/conformance/types/thisType/thisTypeInTuples.ts === +interface Array { +>Array : T[] +>T : T + + slice(): this; +>slice : { (start?: number, end?: number): T[]; (): this; } +} + +let t: [number, string] = [42, "hello"]; +>t : [number, string] +>[42, "hello"] : [number, string] +>42 : number +>"hello" : string + +let a = t.slice(); +>a : [number, string] +>t.slice() : [number, string] +>t.slice : { (start?: number, end?: number): (number | string)[]; (): [number, string]; } +>t : [number, string] +>slice : { (start?: number, end?: number): (number | string)[]; (): [number, string]; } + +let b = t.slice(1); +>b : (number | string)[] +>t.slice(1) : (number | string)[] +>t.slice : { (start?: number, end?: number): (number | string)[]; (): [number, string]; } +>t : [number, string] +>slice : { (start?: number, end?: number): (number | string)[]; (): [number, string]; } +>1 : number + +let c = t.slice(0, 1); +>c : (number | string)[] +>t.slice(0, 1) : (number | string)[] +>t.slice : { (start?: number, end?: number): (number | string)[]; (): [number, string]; } +>t : [number, string] +>slice : { (start?: number, end?: number): (number | string)[]; (): [number, string]; } +>0 : number +>1 : number + diff --git a/tests/baselines/reference/throwInEnclosingStatements.types b/tests/baselines/reference/throwInEnclosingStatements.types index f3ae0bacd60..bcff8653d52 100644 --- a/tests/baselines/reference/throwInEnclosingStatements.types +++ b/tests/baselines/reference/throwInEnclosingStatements.types @@ -81,13 +81,13 @@ class C { throw this.value; >this.value : T ->this : C +>this : this >value : T } constructor() { throw this; ->this : C +>this : this } } diff --git a/tests/baselines/reference/throwStatements.symbols b/tests/baselines/reference/throwStatements.symbols index cb65755a145..508bdcb9f3f 100644 --- a/tests/baselines/reference/throwStatements.symbols +++ b/tests/baselines/reference/throwStatements.symbols @@ -53,9 +53,9 @@ module M { export function F2(x: number): string { return x.toString(); } >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, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(throwStatements.ts, 23, 23)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } var aNumber = 9.9; @@ -72,14 +72,14 @@ throw aString; var aDate = new Date(12); >aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw aDate; >aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3)) var anObject = new Object(); >anObject : Symbol(anObject, Decl(throwStatements.ts, 32, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw anObject; >anObject : Symbol(anObject, Decl(throwStatements.ts, 32, 3)) @@ -202,13 +202,13 @@ throw []; throw ['a', ['b']]; throw /[a-z]/; throw new Date(); ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw new C(); >C : Symbol(C, Decl(throwStatements.ts, 4, 1)) throw new Object(); ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw new D(); >D : Symbol(D, Decl(throwStatements.ts, 8, 1)) diff --git a/tests/baselines/reference/toStringOnPrimitives.symbols b/tests/baselines/reference/toStringOnPrimitives.symbols index f0cdf2c7050..96fb16bf4ca 100644 --- a/tests/baselines/reference/toStringOnPrimitives.symbols +++ b/tests/baselines/reference/toStringOnPrimitives.symbols @@ -1,17 +1,17 @@ === tests/cases/compiler/toStringOnPrimitives.ts === true.toString() ->true.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>true.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) var aBool = false; >aBool : Symbol(aBool, Decl(toStringOnPrimitives.ts, 1, 3)) aBool.toString(); ->aBool.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>aBool.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >aBool : Symbol(aBool, Decl(toStringOnPrimitives.ts, 1, 3)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) 1..toString(); ->1..toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>1..toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols b/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols index 79d5bc3e7a7..752e75d4901 100644 --- a/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols +++ b/tests/baselines/reference/tooFewArgumentsInGenericFunctionTypedArgument.symbols @@ -73,16 +73,16 @@ var r1a = _.map(c2, (x) => { return x.toFixed() }); >map : Symbol(Combinators.map, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 5, 23), Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 6, 77)) >c2 : Symbol(c2, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 9, 3)) >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 11, 21)) ->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 11, 21)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) var rf1 = (x: number) => { return x.toFixed() }; >rf1 : Symbol(rf1, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 3)) >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 11)) ->x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>x.toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 12, 11)) ->toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, 463, 37)) +>toFixed : Symbol(Number.toFixed, Decl(lib.d.ts, --, --)) var r1b = _.map(c2, rf1); >r1b : Symbol(r1b, Decl(tooFewArgumentsInGenericFunctionTypedArgument.ts, 13, 3)) diff --git a/tests/baselines/reference/topLevel.types b/tests/baselines/reference/topLevel.types index d7ed4a27001..ac1dd1182b9 100644 --- a/tests/baselines/reference/topLevel.types +++ b/tests/baselines/reference/topLevel.types @@ -18,26 +18,26 @@ class Point implements IPoint { >y : any public move(xo:number,yo:number) { ->move : (xo: number, yo: number) => Point +>move : (xo: number, yo: number) => this >xo : number >yo : number this.x+=xo; >this.x+=xo : any >this.x : any ->this : Point +>this : this >x : any >xo : number this.y+=yo; >this.y+=yo : any >this.y : any ->this : Point +>this : this >y : any >yo : number return this; ->this : Point +>this : this } public toString() { >toString : () => string @@ -50,11 +50,11 @@ class Point implements IPoint { >"("+this.x : string >"(" : string >this.x : any ->this : Point +>this : this >x : any >"," : string >this.y : any ->this : Point +>this : this >y : any >")" : string } diff --git a/tests/baselines/reference/topLevelExports.symbols b/tests/baselines/reference/topLevelExports.symbols index 56a32820228..733a98bcde5 100644 --- a/tests/baselines/reference/topLevelExports.symbols +++ b/tests/baselines/reference/topLevelExports.symbols @@ -8,8 +8,8 @@ function log(n:number) { return n;} >n : Symbol(n, Decl(topLevelExports.ts, 2, 13)) void log(foo).toString(); ->log(foo).toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>log(foo).toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >log : Symbol(log, Decl(topLevelExports.ts, 0, 19)) >foo : Symbol(foo, Decl(topLevelExports.ts, 0, 10)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/tsxAttributeResolution8.symbols b/tests/baselines/reference/tsxAttributeResolution8.symbols index 9bb09c6cd85..85db1985cc2 100644 --- a/tests/baselines/reference/tsxAttributeResolution8.symbols +++ b/tests/baselines/reference/tsxAttributeResolution8.symbols @@ -20,4 +20,5 @@ var x: any; // Should be OK >test1 : Symbol(JSX.IntrinsicElements.test1, Decl(tsxAttributeResolution8.tsx, 2, 30)) +>x : Symbol(x, Decl(tsxAttributeResolution8.tsx, 7, 3)) diff --git a/tests/baselines/reference/tsxEmit1.types b/tests/baselines/reference/tsxEmit1.types index a427270354e..c34896b08ad 100644 --- a/tests/baselines/reference/tsxEmit1.types +++ b/tests/baselines/reference/tsxEmit1.types @@ -115,8 +115,8 @@ class SomeClass { >rewrites1 : JSX.Element >
{() => this}
: JSX.Element >div : any ->() => this : () => SomeClass ->this : SomeClass +>() => this : () => this +>this : this >div : any var rewrites2 =
{[p, ...p, p]}
; @@ -143,8 +143,8 @@ class SomeClass { >
this}>
: JSX.Element >div : any >a : any ->() => this : () => SomeClass ->this : SomeClass +>() => this : () => this +>this : this >div : any var rewrites5 =
; diff --git a/tests/baselines/reference/tsxEmit2.symbols b/tests/baselines/reference/tsxEmit2.symbols index 5eefc31710d..5da1b16ae44 100644 --- a/tests/baselines/reference/tsxEmit2.symbols +++ b/tests/baselines/reference/tsxEmit2.symbols @@ -21,12 +21,14 @@ var p1, p2, p3; var spreads1 =
{p2}
; >spreads1 : Symbol(spreads1, Decl(tsxEmit2.tsx, 8, 3)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) +>p1 : Symbol(p1, Decl(tsxEmit2.tsx, 7, 3)) >p2 : Symbol(p2, Decl(tsxEmit2.tsx, 7, 7)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) var spreads2 =
{p2}
; >spreads2 : Symbol(spreads2, Decl(tsxEmit2.tsx, 9, 3)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) +>p1 : Symbol(p1, Decl(tsxEmit2.tsx, 7, 3)) >p2 : Symbol(p2, Decl(tsxEmit2.tsx, 7, 7)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) @@ -35,12 +37,14 @@ var spreads3 =
{p2}
; >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) >x : Symbol(unknown) >p3 : Symbol(p3, Decl(tsxEmit2.tsx, 7, 11)) +>p1 : Symbol(p1, Decl(tsxEmit2.tsx, 7, 3)) >p2 : Symbol(p2, Decl(tsxEmit2.tsx, 7, 7)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) var spreads4 =
{p2}
; >spreads4 : Symbol(spreads4, Decl(tsxEmit2.tsx, 11, 3)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) +>p1 : Symbol(p1, Decl(tsxEmit2.tsx, 7, 3)) >x : Symbol(unknown) >p3 : Symbol(p3, Decl(tsxEmit2.tsx, 7, 11)) >p2 : Symbol(p2, Decl(tsxEmit2.tsx, 7, 7)) @@ -51,6 +55,7 @@ var spreads5 =
{p2}
; >div : Symbol(JSX.IntrinsicElements, Decl(tsxEmit2.tsx, 1, 22)) >x : Symbol(unknown) >p2 : Symbol(p2, Decl(tsxEmit2.tsx, 7, 7)) +>p1 : Symbol(p1, Decl(tsxEmit2.tsx, 7, 3)) >y : Symbol(unknown) >p3 : Symbol(p3, Decl(tsxEmit2.tsx, 7, 11)) >p2 : Symbol(p2, Decl(tsxEmit2.tsx, 7, 7)) diff --git a/tests/baselines/reference/tsxExternalModuleEmit2.symbols b/tests/baselines/reference/tsxExternalModuleEmit2.symbols index 6f8d3d76cd2..ff5fdc49171 100644 --- a/tests/baselines/reference/tsxExternalModuleEmit2.symbols +++ b/tests/baselines/reference/tsxExternalModuleEmit2.symbols @@ -26,6 +26,7 @@ declare var Foo, React; // Should see mod_1['default'] in emit here ; >Foo : Symbol(Foo, Decl(app.tsx, 1, 11)) +>Main : Symbol(Main, Decl(app.tsx, 0, 6)) >Foo : Symbol(Foo, Decl(app.tsx, 1, 11)) diff --git a/tests/baselines/reference/tsxParseTests2.js b/tests/baselines/reference/tsxParseTests2.js new file mode 100644 index 00000000000..c179d75776a --- /dev/null +++ b/tests/baselines/reference/tsxParseTests2.js @@ -0,0 +1,11 @@ +//// [tsxParseTests2.tsx] +declare module JSX { + interface Element { } + interface IntrinsicElements { div; span; } +} + +var x = ; + + +//// [tsxParseTests2.jsx] +var x =
; diff --git a/tests/baselines/reference/tsxParseTests2.symbols b/tests/baselines/reference/tsxParseTests2.symbols new file mode 100644 index 00000000000..17b612df786 --- /dev/null +++ b/tests/baselines/reference/tsxParseTests2.symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/jsx/tsxParseTests2.tsx === +declare module JSX { +>JSX : Symbol(JSX, Decl(tsxParseTests2.tsx, 0, 0)) + + interface Element { } +>Element : Symbol(Element, Decl(tsxParseTests2.tsx, 0, 20)) + + interface IntrinsicElements { div; span; } +>IntrinsicElements : Symbol(IntrinsicElements, Decl(tsxParseTests2.tsx, 1, 22)) +>div : Symbol(div, Decl(tsxParseTests2.tsx, 2, 30)) +>span : Symbol(span, Decl(tsxParseTests2.tsx, 2, 35)) +} + +var x = ; +>x : Symbol(x, Decl(tsxParseTests2.tsx, 5, 3)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxParseTests2.tsx, 2, 30)) +>div : Symbol(JSX.IntrinsicElements.div, Decl(tsxParseTests2.tsx, 2, 30)) + diff --git a/tests/baselines/reference/tsxParseTests2.types b/tests/baselines/reference/tsxParseTests2.types new file mode 100644 index 00000000000..5714a4d3483 --- /dev/null +++ b/tests/baselines/reference/tsxParseTests2.types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/jsx/tsxParseTests2.tsx === +declare module JSX { +>JSX : any + + interface Element { } +>Element : Element + + interface IntrinsicElements { div; span; } +>IntrinsicElements : IntrinsicElements +>div : any +>span : any +} + +var x = ; +>x : JSX.Element +> : JSX.Element +>div : any +>div : any + diff --git a/tests/baselines/reference/tsxPreserveEmit1.js b/tests/baselines/reference/tsxPreserveEmit1.js new file mode 100644 index 00000000000..80aeef6b297 --- /dev/null +++ b/tests/baselines/reference/tsxPreserveEmit1.js @@ -0,0 +1,32 @@ +//// [tests/cases/conformance/jsx/tsxPreserveEmit1.tsx] //// + +//// [react.d.ts] + +declare module 'react' { + var x: any; + export = x; +} + +declare module ReactRouter { + var Route: any; + interface Thing { } +} +declare module 'react-router' { + export = ReactRouter; +} + +//// [test.tsx] +// Should emit 'react-router' in the AMD dependency list +import React = require('react'); +import ReactRouter = require('react-router'); + +import Route = ReactRouter.Route; + +var routes = ; + + +//// [test.jsx] +define(["require", "exports", 'react-router'], function (require, exports, ReactRouter) { + var Route = ReactRouter.Route; + var routes = ; +}); diff --git a/tests/baselines/reference/tsxPreserveEmit1.symbols b/tests/baselines/reference/tsxPreserveEmit1.symbols new file mode 100644 index 00000000000..6dcf4d9ac49 --- /dev/null +++ b/tests/baselines/reference/tsxPreserveEmit1.symbols @@ -0,0 +1,41 @@ +=== tests/cases/conformance/jsx/test.tsx === +// Should emit 'react-router' in the AMD dependency list +import React = require('react'); +>React : Symbol(React, Decl(test.tsx, 0, 0)) + +import ReactRouter = require('react-router'); +>ReactRouter : Symbol(ReactRouter, Decl(test.tsx, 1, 32)) + +import Route = ReactRouter.Route; +>Route : Symbol(Route, Decl(test.tsx, 2, 45)) +>ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 4, 1)) +>Route : Symbol(ReactRouter.Route, Decl(react.d.ts, 7, 4)) + +var routes = ; +>routes : Symbol(routes, Decl(test.tsx, 6, 3)) +>Route : Symbol(Route, Decl(test.tsx, 2, 45)) + +=== tests/cases/conformance/jsx/react.d.ts === + +declare module 'react' { + var x: any; +>x : Symbol(x, Decl(react.d.ts, 2, 4)) + + export = x; +>x : Symbol(x, Decl(react.d.ts, 2, 4)) +} + +declare module ReactRouter { +>ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 4, 1)) + + var Route: any; +>Route : Symbol(Route, Decl(react.d.ts, 7, 4)) + + interface Thing { } +>Thing : Symbol(Thing, Decl(react.d.ts, 7, 16)) +} +declare module 'react-router' { + export = ReactRouter; +>ReactRouter : Symbol(ReactRouter, Decl(react.d.ts, 4, 1)) +} + diff --git a/tests/baselines/reference/tsxPreserveEmit1.types b/tests/baselines/reference/tsxPreserveEmit1.types new file mode 100644 index 00000000000..ea64e2d2e94 --- /dev/null +++ b/tests/baselines/reference/tsxPreserveEmit1.types @@ -0,0 +1,42 @@ +=== tests/cases/conformance/jsx/test.tsx === +// Should emit 'react-router' in the AMD dependency list +import React = require('react'); +>React : any + +import ReactRouter = require('react-router'); +>ReactRouter : typeof ReactRouter + +import Route = ReactRouter.Route; +>Route : any +>ReactRouter : typeof ReactRouter +>Route : any + +var routes = ; +>routes : any +> : any +>Route : any + +=== tests/cases/conformance/jsx/react.d.ts === + +declare module 'react' { + var x: any; +>x : any + + export = x; +>x : any +} + +declare module ReactRouter { +>ReactRouter : typeof ReactRouter + + var Route: any; +>Route : any + + interface Thing { } +>Thing : Thing +} +declare module 'react-router' { + export = ReactRouter; +>ReactRouter : typeof ReactRouter +} + diff --git a/tests/baselines/reference/tsxReactEmit1.types b/tests/baselines/reference/tsxReactEmit1.types index e180d2b6b70..4afe4be01dc 100644 --- a/tests/baselines/reference/tsxReactEmit1.types +++ b/tests/baselines/reference/tsxReactEmit1.types @@ -119,8 +119,8 @@ class SomeClass { >rewrites1 : JSX.Element >
{() => this}
: JSX.Element >div : any ->() => this : () => SomeClass ->this : SomeClass +>() => this : () => this +>this : this >div : any var rewrites2 =
{[p, ...p, p]}
; @@ -147,8 +147,8 @@ class SomeClass { >
this}>
: JSX.Element >div : any >a : any ->() => this : () => SomeClass ->this : SomeClass +>() => this : () => this +>this : this >div : any var rewrites5 =
; diff --git a/tests/baselines/reference/tsxReactEmit2.symbols b/tests/baselines/reference/tsxReactEmit2.symbols index 049fdb1819b..051f7588f25 100644 --- a/tests/baselines/reference/tsxReactEmit2.symbols +++ b/tests/baselines/reference/tsxReactEmit2.symbols @@ -23,12 +23,14 @@ var p1, p2, p3; var spreads1 =
{p2}
; >spreads1 : Symbol(spreads1, Decl(tsxReactEmit2.tsx, 9, 3)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) +>p1 : Symbol(p1, Decl(tsxReactEmit2.tsx, 8, 3)) >p2 : Symbol(p2, Decl(tsxReactEmit2.tsx, 8, 7)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) var spreads2 =
{p2}
; >spreads2 : Symbol(spreads2, Decl(tsxReactEmit2.tsx, 10, 3)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) +>p1 : Symbol(p1, Decl(tsxReactEmit2.tsx, 8, 3)) >p2 : Symbol(p2, Decl(tsxReactEmit2.tsx, 8, 7)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) @@ -37,12 +39,14 @@ var spreads3 =
{p2}
; >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) >x : Symbol(unknown) >p3 : Symbol(p3, Decl(tsxReactEmit2.tsx, 8, 11)) +>p1 : Symbol(p1, Decl(tsxReactEmit2.tsx, 8, 3)) >p2 : Symbol(p2, Decl(tsxReactEmit2.tsx, 8, 7)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) var spreads4 =
{p2}
; >spreads4 : Symbol(spreads4, Decl(tsxReactEmit2.tsx, 12, 3)) >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) +>p1 : Symbol(p1, Decl(tsxReactEmit2.tsx, 8, 3)) >x : Symbol(unknown) >p3 : Symbol(p3, Decl(tsxReactEmit2.tsx, 8, 11)) >p2 : Symbol(p2, Decl(tsxReactEmit2.tsx, 8, 7)) @@ -53,6 +57,7 @@ var spreads5 =
{p2}
; >div : Symbol(JSX.IntrinsicElements, Decl(tsxReactEmit2.tsx, 1, 22)) >x : Symbol(unknown) >p2 : Symbol(p2, Decl(tsxReactEmit2.tsx, 8, 7)) +>p1 : Symbol(p1, Decl(tsxReactEmit2.tsx, 8, 3)) >y : Symbol(unknown) >p3 : Symbol(p3, Decl(tsxReactEmit2.tsx, 8, 11)) >p2 : Symbol(p2, Decl(tsxReactEmit2.tsx, 8, 7)) diff --git a/tests/baselines/reference/tsxReactEmit5.symbols b/tests/baselines/reference/tsxReactEmit5.symbols index 388e717957f..3e0e1790676 100644 --- a/tests/baselines/reference/tsxReactEmit5.symbols +++ b/tests/baselines/reference/tsxReactEmit5.symbols @@ -31,5 +31,6 @@ var spread1 =
; >spread1 : Symbol(spread1, Decl(react-consumer.tsx, 4, 3)) >div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22)) >x : Symbol(unknown) +>foo : Symbol(foo, Decl(react-consumer.tsx, 3, 3)) >y : Symbol(unknown) diff --git a/tests/baselines/reference/tsxReactEmit6.js b/tests/baselines/reference/tsxReactEmit6.js index d20ef7051e0..4f583929004 100644 --- a/tests/baselines/reference/tsxReactEmit6.js +++ b/tests/baselines/reference/tsxReactEmit6.js @@ -19,7 +19,11 @@ namespace M { // and M.React.__spread var foo; var spread1 =
; + + // Quotes + var x =
This "quote" thing
; } + //// [file.js] @@ -33,4 +37,6 @@ var M; // and M.React.__spread var foo; var spread1 = M.React.createElement("div", M.React.__spread({x: ''}, foo, {y: ''})); + // Quotes + var x = M.React.createElement("div", null, "This \"quote\" thing"); })(M || (M = {})); diff --git a/tests/baselines/reference/tsxReactEmit6.symbols b/tests/baselines/reference/tsxReactEmit6.symbols index 0302cef3e8d..8eb0561e185 100644 --- a/tests/baselines/reference/tsxReactEmit6.symbols +++ b/tests/baselines/reference/tsxReactEmit6.symbols @@ -34,6 +34,14 @@ namespace M { >spread1 : Symbol(spread1, Decl(react-consumer.tsx, 8, 4)) >div : Symbol(JSX.IntrinsicElements, Decl(file.tsx, 2, 22)) >x : Symbol(unknown) +>foo : Symbol(foo, Decl(react-consumer.tsx, 7, 4)) >y : Symbol(unknown) + + // 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)) } + diff --git a/tests/baselines/reference/tsxReactEmit6.types b/tests/baselines/reference/tsxReactEmit6.types index 1b16b84fcc7..b8a307eb9d7 100644 --- a/tests/baselines/reference/tsxReactEmit6.types +++ b/tests/baselines/reference/tsxReactEmit6.types @@ -37,5 +37,13 @@ namespace M { >x : any >foo : any >y : any + + // Quotes + var x =
This "quote" thing
; +>x : JSX.Element +>
This "quote" thing
: JSX.Element +>div : any +>div : any } + diff --git a/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.symbols b/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.symbols index 9fe6e31259e..5d46be73518 100644 --- a/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.symbols +++ b/tests/baselines/reference/twoMergedInterfacesWithDifferingOverloads.symbols @@ -19,8 +19,8 @@ interface A { foo(x: Date): Date; >foo : Symbol(foo, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 2, 13), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 3, 27), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 7, 13)) >x : Symbol(x, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 8, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } interface B { @@ -45,12 +45,12 @@ interface B { >foo : Symbol(foo, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 11, 16), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 12, 22), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 16, 16), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 17, 20)) >x : Symbol(x, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 17, 8)) >T : Symbol(T, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 11, 12), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 16, 12)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo(x: Date): string; >foo : Symbol(foo, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 11, 16), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 12, 22), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 16, 16), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 17, 20)) >x : Symbol(x, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 18, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } var b: B; @@ -100,7 +100,7 @@ interface C { var c: C; >c : Symbol(c, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 34, 3)) >C : Symbol(C, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 22, 20), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 28, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r2 = c.foo(1, 2); // number >r2 : Symbol(r2, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 35, 3)) @@ -150,7 +150,7 @@ interface D { var d: D; >d : Symbol(d, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 48, 3)) >D : Symbol(D, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 35, 21), Decl(twoMergedInterfacesWithDifferingOverloads.ts, 42, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var r3 = d.foo(1, 1); // boolean, last definition wins >r3 : Symbol(r3, Decl(twoMergedInterfacesWithDifferingOverloads.ts, 49, 3)) diff --git a/tests/baselines/reference/typeAliasDoesntMakeModuleInstantiated.symbols b/tests/baselines/reference/typeAliasDoesntMakeModuleInstantiated.symbols index a94890b51be..c990d3de59d 100644 --- a/tests/baselines/reference/typeAliasDoesntMakeModuleInstantiated.symbols +++ b/tests/baselines/reference/typeAliasDoesntMakeModuleInstantiated.symbols @@ -5,7 +5,7 @@ declare module m { // type alias declaration here shouldnt make the module declaration instantiated type Selector = string| string[] |Function; >Selector : Symbol(Selector, Decl(typeAliasDoesntMakeModuleInstantiated.ts, 0, 18)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) export interface IStatic { >IStatic : Symbol(IStatic, Decl(typeAliasDoesntMakeModuleInstantiated.ts, 2, 47)) diff --git a/tests/baselines/reference/typeAliases.symbols b/tests/baselines/reference/typeAliases.symbols index 5bbc77c735d..02cc5027b04 100644 --- a/tests/baselines/reference/typeAliases.symbols +++ b/tests/baselines/reference/typeAliases.symbols @@ -200,12 +200,12 @@ declare function f15(a: Meters): string; >Meters : Symbol(Meters, Decl(typeAliases.ts, 63, 39)) f15(E.x).toLowerCase(); ->f15(E.x).toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>f15(E.x).toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >f15 : Symbol(f15, Decl(typeAliases.ts, 67, 17), Decl(typeAliases.ts, 69, 41)) >E.x : Symbol(E.x, Decl(typeAliases.ts, 67, 8)) >E : Symbol(E, Decl(typeAliases.ts, 65, 20)) >x : Symbol(E.x, Decl(typeAliases.ts, 67, 8)) ->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) type StringAndBoolean = [string, boolean] >StringAndBoolean : Symbol(StringAndBoolean, Decl(typeAliases.ts, 71, 23)) @@ -227,8 +227,8 @@ var y: StringAndBoolean = ["1", false]; >StringAndBoolean : Symbol(StringAndBoolean, Decl(typeAliases.ts, 71, 23)) y[0].toLowerCase(); ->y[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>y[0].toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) >y : Symbol(y, Decl(typeAliases.ts, 78, 3)) >0 : Symbol(0) ->toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, 399, 51)) +>toLowerCase : Symbol(String.toLowerCase, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols b/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols index 557175473da..00de7ec64c9 100644 --- a/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols +++ b/tests/baselines/reference/typeArgumentInferenceApparentType1.symbols @@ -3,7 +3,7 @@ function method(iterable: Iterable): T { >method : Symbol(method, Decl(typeArgumentInferenceApparentType1.ts, 0, 0)) >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16)) >iterable : Symbol(iterable, Decl(typeArgumentInferenceApparentType1.ts, 0, 19)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16)) >T : Symbol(T, Decl(typeArgumentInferenceApparentType1.ts, 0, 16)) diff --git a/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols b/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols index f25ca2bba6b..4626aabb605 100644 --- a/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols +++ b/tests/baselines/reference/typeArgumentInferenceApparentType2.symbols @@ -3,14 +3,14 @@ function method(iterable: Iterable): T { >method : Symbol(method, Decl(typeArgumentInferenceApparentType2.ts, 0, 0)) >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16)) >iterable : Symbol(iterable, Decl(typeArgumentInferenceApparentType2.ts, 0, 19)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16)) >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16)) function inner>() { >inner : Symbol(inner, Decl(typeArgumentInferenceApparentType2.ts, 0, 46)) >U : Symbol(U, Decl(typeArgumentInferenceApparentType2.ts, 1, 19)) ->Iterable : Symbol(Iterable, Decl(lib.d.ts, 4396, 1)) +>Iterable : Symbol(Iterable, Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(typeArgumentInferenceApparentType2.ts, 0, 16)) var u: U; diff --git a/tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols b/tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols index ceb97a73af8..7c24840b5ab 100644 --- a/tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols +++ b/tests/baselines/reference/typeArgumentInferenceWithClassExpression1.symbols @@ -12,8 +12,8 @@ function foo(x = class { static prop: T }): T { } foo(class { static prop = "hello" }).length; ->foo(class { static prop = "hello" }).length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>foo(class { static prop = "hello" }).length : Symbol(String.length, Decl(lib.d.ts, --, --)) >foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression1.ts, 0, 0)) >prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression1.ts, 4, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/typeArgumentInferenceWithClassExpression2.errors.txt b/tests/baselines/reference/typeArgumentInferenceWithClassExpression2.errors.txt index c630944306b..eb74ff0ade0 100644 --- a/tests/baselines/reference/typeArgumentInferenceWithClassExpression2.errors.txt +++ b/tests/baselines/reference/typeArgumentInferenceWithClassExpression2.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/es6/classExpressions/typeArgumentInferenceWithClassExpression2.ts(6,5): error TS2345: Argument of type 'typeof (Anonymous class)' is not assignable to parameter of type 'typeof (Anonymous class)'. - Type '(Anonymous class)' is not assignable to type 'foo<{}>.'. + Type '(Anonymous class)' is not assignable to type 'foo<{}>.(Anonymous class)'. Property 'prop' is missing in type '(Anonymous class)'. @@ -12,5 +12,5 @@ tests/cases/conformance/es6/classExpressions/typeArgumentInferenceWithClassExpre foo(class { static prop = "hello" }).length; ~~~~~ !!! error TS2345: Argument of type 'typeof (Anonymous class)' is not assignable to parameter of type 'typeof (Anonymous class)'. -!!! error TS2345: Type '(Anonymous class)' is not assignable to type 'foo<{}>.'. +!!! error TS2345: Type '(Anonymous class)' is not assignable to type 'foo<{}>.(Anonymous class)'. !!! error TS2345: Property 'prop' is missing in type '(Anonymous class)'. \ No newline at end of file diff --git a/tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols b/tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols index aedb0230fd6..3f25fd0682f 100644 --- a/tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols +++ b/tests/baselines/reference/typeArgumentInferenceWithClassExpression3.symbols @@ -12,8 +12,8 @@ function foo(x = class { prop: T }): T { } foo(class { prop = "hello" }).length; ->foo(class { prop = "hello" }).length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>foo(class { prop = "hello" }).length : Symbol(String.length, Decl(lib.d.ts, --, --)) >foo : Symbol(foo, Decl(typeArgumentInferenceWithClassExpression3.ts, 0, 0)) >prop : Symbol((Anonymous class).prop, Decl(typeArgumentInferenceWithClassExpression3.ts, 4, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols index 08b61492a54..b73bd8882d2 100644 --- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols +++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.symbols @@ -15,9 +15,9 @@ var nodes: TreeNode[]; >TreeNode : Symbol(TreeNode, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 0)) nodes.map(n => n.name); ->nodes.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>nodes.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >nodes : Symbol(nodes, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 5, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 6, 10)) >n.name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 0, 17)) >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral01.ts, 6, 10)) diff --git a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols index cb2e8e94656..7cec46cb4b6 100644 --- a/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols +++ b/tests/baselines/reference/typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.symbols @@ -26,9 +26,9 @@ var nodes: TreeNodeMiddleman[]; >TreeNodeMiddleman : Symbol(TreeNodeMiddleman, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 3, 1)) nodes.map(n => n.name); ->nodes.map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>nodes.map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >nodes : Symbol(nodes, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 10, 3)) ->map : Symbol(Array.map, Decl(lib.d.ts, 1115, 92)) +>map : Symbol(Array.map, Decl(lib.d.ts, --, --)) >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 11, 10)) >n.name : Symbol(name, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 5, 26)) >n : Symbol(n, Decl(typeArgumentInferenceWithRecursivelyReferencedTypeAliasToTypeLiteral02.ts, 11, 10)) diff --git a/tests/baselines/reference/typeConstraintsWithConstructSignatures.types b/tests/baselines/reference/typeConstraintsWithConstructSignatures.types index 3814c014ece..9141aec0496 100644 --- a/tests/baselines/reference/typeConstraintsWithConstructSignatures.types +++ b/tests/baselines/reference/typeConstraintsWithConstructSignatures.types @@ -23,14 +23,14 @@ class C { >x : any >new this.data() : any >this.data : T ->this : C +>this : this >data : T var x2 = new this.data2(); // should not error >x2 : any >new this.data2() : any >this.data2 : Constructable ->this : C +>this : this >data2 : Constructable } } diff --git a/tests/baselines/reference/typeGuardsDefeat.symbols b/tests/baselines/reference/typeGuardsDefeat.symbols index e5b2b4b2047..388b69b5789 100644 --- a/tests/baselines/reference/typeGuardsDefeat.symbols +++ b/tests/baselines/reference/typeGuardsDefeat.symbols @@ -18,9 +18,9 @@ function foo(x: number | string) { >f : Symbol(f, Decl(typeGuardsDefeat.ts, 2, 34)) return x.length; // string ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsDefeat.ts, 2, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } else { return x++; // number @@ -35,9 +35,9 @@ function foo2(x: number | string) { >x : Symbol(x, Decl(typeGuardsDefeat.ts, 14, 14)) return x.length; // string ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsDefeat.ts, 14, 14)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } else { var f = function () { @@ -63,9 +63,9 @@ function foo3(x: number | string) { >x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14)) return x.length; // string ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsDefeat.ts, 26, 14)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } else { var f = () => x * x; diff --git a/tests/baselines/reference/typeGuardsInClassAccessors.symbols b/tests/baselines/reference/typeGuardsInClassAccessors.symbols index 17754779ecf..d38c3040e01 100644 --- a/tests/baselines/reference/typeGuardsInClassAccessors.symbols +++ b/tests/baselines/reference/typeGuardsInClassAccessors.symbols @@ -24,9 +24,9 @@ class ClassWithAccessors { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -35,9 +35,9 @@ class ClassWithAccessors { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 15, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 15, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) return strOrNum; >strOrNum : Symbol(strOrNum, Decl(typeGuardsInClassAccessors.ts, 6, 3)) @@ -51,17 +51,17 @@ class ClassWithAccessors { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameter of function declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 21, 11)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 21, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -70,9 +70,9 @@ class ClassWithAccessors { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 29, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 29, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } // Inside private accessor getter private get pp1() { @@ -82,9 +82,9 @@ class ClassWithAccessors { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -93,9 +93,9 @@ class ClassWithAccessors { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 38, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 38, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) return strOrNum; >strOrNum : Symbol(strOrNum, Decl(typeGuardsInClassAccessors.ts, 6, 3)) @@ -109,17 +109,17 @@ class ClassWithAccessors { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameter of function declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 44, 20)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 44, 20)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -128,9 +128,9 @@ class ClassWithAccessors { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 52, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 52, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } // Inside static accessor getter static get s1() { @@ -140,9 +140,9 @@ class ClassWithAccessors { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -151,9 +151,9 @@ class ClassWithAccessors { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 61, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 61, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) return strOrNum; >strOrNum : Symbol(strOrNum, Decl(typeGuardsInClassAccessors.ts, 6, 3)) @@ -167,17 +167,17 @@ class ClassWithAccessors { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameter of function declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 67, 18)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 67, 18)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -186,9 +186,9 @@ class ClassWithAccessors { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 75, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 75, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } // Inside private static accessor getter private static get ss1() { @@ -198,9 +198,9 @@ class ClassWithAccessors { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -209,9 +209,9 @@ class ClassWithAccessors { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 84, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 84, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) return strOrNum; >strOrNum : Symbol(strOrNum, Decl(typeGuardsInClassAccessors.ts, 6, 3)) @@ -225,17 +225,17 @@ class ClassWithAccessors { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassAccessors.ts, 7, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameter of function declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 90, 27)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInClassAccessors.ts, 90, 27)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -244,9 +244,9 @@ class ClassWithAccessors { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassAccessors.ts, 5, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 98, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassAccessors.ts, 98, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/typeGuardsInClassMethods.symbols b/tests/baselines/reference/typeGuardsInClassMethods.symbols index c0d88ff414f..30f01d3619f 100644 --- a/tests/baselines/reference/typeGuardsInClassMethods.symbols +++ b/tests/baselines/reference/typeGuardsInClassMethods.symbols @@ -19,9 +19,9 @@ class C1 { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -30,17 +30,17 @@ class C1 { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 12, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 12, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameters in function declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 7, 16)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 7, 16)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } // Inside function declaration private p1(param: string | number) { @@ -51,9 +51,9 @@ class C1 { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -62,17 +62,17 @@ class C1 { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 24, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 24, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameters in function declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 19, 15)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 19, 15)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } // Inside function declaration p2(param: string | number) { @@ -83,9 +83,9 @@ class C1 { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -94,17 +94,17 @@ class C1 { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 36, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 36, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameters in function declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 31, 7)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 31, 7)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } // Inside function declaration private static s1(param: string | number) { @@ -115,9 +115,9 @@ class C1 { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -126,17 +126,17 @@ class C1 { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 48, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 48, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameters in function declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 43, 22)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 43, 22)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } // Inside function declaration static s2(param: string | number) { @@ -147,9 +147,9 @@ class C1 { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInClassMethods.ts, 5, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -158,17 +158,17 @@ class C1 { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 60, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInClassMethods.ts, 60, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameters in function declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInClassMethods.ts, 4, 3)) >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 55, 14)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInClassMethods.ts, 55, 14)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/typeGuardsInConditionalExpression.symbols b/tests/baselines/reference/typeGuardsInConditionalExpression.symbols index ac35c1f18b9..7de63d90bf9 100644 --- a/tests/baselines/reference/typeGuardsInConditionalExpression.symbols +++ b/tests/baselines/reference/typeGuardsInConditionalExpression.symbols @@ -14,9 +14,9 @@ function foo(x: number | string) { >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 7, 13)) ? x.length // string ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 7, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) : x++; // number >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 7, 13)) @@ -157,9 +157,9 @@ function foo9(x: number | string) { ? ((y = x.length) && x === "hello") // string >y : Symbol(y, Decl(typeGuardsInConditionalExpression.ts, 61, 7)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 60, 14)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 60, 14)) : x === 10; // number @@ -187,9 +187,9 @@ function foo10(x: number | string | boolean) { >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 67, 15)) && x.toString()); // x is number ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 67, 15)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } function foo11(x: number | string | boolean) { >foo11 : Symbol(foo11, Decl(typeGuardsInConditionalExpression.ts, 75, 1)) @@ -233,11 +233,11 @@ function foo12(x: number | string | boolean) { ? (x = 10 && x.toString().length) // number | boolean | string - changed here >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 87, 15)) ->x.toString().length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) ->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>x.toString().length : Symbol(String.length, Decl(lib.d.ts, --, --)) +>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInConditionalExpression.ts, 87, 15)) ->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) : ((b = x) // x is number | boolean | string - changed in true branch >b : Symbol(b, Decl(typeGuardsInConditionalExpression.ts, 90, 7)) diff --git a/tests/baselines/reference/typeGuardsInExternalModule.symbols b/tests/baselines/reference/typeGuardsInExternalModule.symbols index 290fe0bf80c..c9e5791f101 100644 --- a/tests/baselines/reference/typeGuardsInExternalModule.symbols +++ b/tests/baselines/reference/typeGuardsInExternalModule.symbols @@ -14,9 +14,9 @@ if (typeof var1 === "string") { num = var1.length; // string >num : Symbol(num, Decl(typeGuardsInExternalModule.ts, 4, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInExternalModule.ts, 5, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } else { num = var1; // number diff --git a/tests/baselines/reference/typeGuardsInFunction.symbols b/tests/baselines/reference/typeGuardsInFunction.symbols index 32a37f62a07..452e69435ff 100644 --- a/tests/baselines/reference/typeGuardsInFunction.symbols +++ b/tests/baselines/reference/typeGuardsInFunction.symbols @@ -18,9 +18,9 @@ function f(param: string | number) { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -29,17 +29,17 @@ function f(param: string | number) { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 12, 7)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 12, 7)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameters in function declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >param : Symbol(param, Decl(typeGuardsInFunction.ts, 7, 11)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInFunction.ts, 7, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } // local function declaration function f1(param: string | number) { @@ -57,25 +57,25 @@ function f1(param: string | number) { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables from outer function declaration num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 20, 7)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 20, 7)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameters in outer declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >param : Symbol(param, Decl(typeGuardsInFunction.ts, 19, 12)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInFunction.ts, 19, 12)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // local var var3: string | number; @@ -84,16 +84,16 @@ function f1(param: string | number) { num = typeof var3 === "string" && var3.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >var3 : Symbol(var3, Decl(typeGuardsInFunction.ts, 32, 11)) ->var3.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var3.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var3 : Symbol(var3, Decl(typeGuardsInFunction.ts, 32, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) num = typeof param1 === "string" && param1.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 21, 16)) ->param1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 21, 16)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } } // Function expression @@ -114,25 +114,25 @@ function f2(param: string | number) { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables from outer function declaration num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 40, 7)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 40, 7)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameters in outer declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >param : Symbol(param, Decl(typeGuardsInFunction.ts, 38, 12)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInFunction.ts, 38, 12)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // local var var3: string | number; @@ -141,16 +141,16 @@ function f2(param: string | number) { num = typeof var3 === "string" && var3.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >var3 : Symbol(var3, Decl(typeGuardsInFunction.ts, 53, 11)) ->var3.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var3.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var3 : Symbol(var3, Decl(typeGuardsInFunction.ts, 53, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) num = typeof param1 === "string" && param1.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 42, 22)) ->param1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 42, 22)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } (param); >param : Symbol(param, Decl(typeGuardsInFunction.ts, 38, 12)) @@ -173,25 +173,25 @@ function f3(param: string | number) { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInFunction.ts, 5, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables from outer function declaration num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 61, 7)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInFunction.ts, 61, 7)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameters in outer declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >param : Symbol(param, Decl(typeGuardsInFunction.ts, 59, 12)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsInFunction.ts, 59, 12)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // local var var3: string | number; @@ -200,16 +200,16 @@ function f3(param: string | number) { num = typeof var3 === "string" && var3.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >var3 : Symbol(var3, Decl(typeGuardsInFunction.ts, 74, 11)) ->var3.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var3.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var3 : Symbol(var3, Decl(typeGuardsInFunction.ts, 74, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) num = typeof param1 === "string" && param1.length; // string >num : Symbol(num, Decl(typeGuardsInFunction.ts, 4, 3)) >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 63, 14)) ->param1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param1 : Symbol(param1, Decl(typeGuardsInFunction.ts, 63, 14)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) })(param); >param : Symbol(param, Decl(typeGuardsInFunction.ts, 59, 12)) diff --git a/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols b/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols index d1140e3af60..2f3232b0225 100644 --- a/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols +++ b/tests/baselines/reference/typeGuardsInFunctionAndModuleBlock.symbols @@ -22,14 +22,14 @@ function foo(x: number | string | boolean) { >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 2, 13)) ? x.toString() // boolean ->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 2, 13)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) : x.toString(); // number ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 2, 13)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } (); } @@ -55,14 +55,14 @@ function foo2(x: number | string | boolean) { >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 12, 14)) ? x.toString() // boolean ->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 12, 14)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) : x.toString(); // number ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 12, 14)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } (x); // x here is narrowed to number | boolean >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 12, 14)) @@ -86,14 +86,14 @@ function foo3(x: number | string | boolean) { >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 22, 14)) ? x.toString() // boolean ->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 22, 14)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) : x.toString(); // number ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 22, 14)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) })(); } @@ -118,14 +118,14 @@ function foo4(x: number | string | boolean) { >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 32, 14)) ? x.toString() // boolean ->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 32, 14)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) : x.toString(); // number ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 32, 14)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) })(x); // x here is narrowed to number | boolean >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 32, 14)) @@ -180,14 +180,14 @@ module m { >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 52, 7)) ? x.toString() // boolean ->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 52, 7)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) : x.toString(); // number ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 52, 7)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } } } @@ -221,14 +221,14 @@ module m1 { >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 66, 7)) ? x.toString() // boolean ->x.toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 66, 7)) ->toString : Symbol(Object.toString, Decl(lib.d.ts, 96, 26)) +>toString : Symbol(Object.toString, Decl(lib.d.ts, --, --)) : x.toString(); // number ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInFunctionAndModuleBlock.ts, 66, 7)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } } } diff --git a/tests/baselines/reference/typeGuardsInGlobal.symbols b/tests/baselines/reference/typeGuardsInGlobal.symbols index 0ae6e75ce17..e052a068651 100644 --- a/tests/baselines/reference/typeGuardsInGlobal.symbols +++ b/tests/baselines/reference/typeGuardsInGlobal.symbols @@ -14,9 +14,9 @@ if (typeof var1 === "string") { num = var1.length; // string >num : Symbol(num, Decl(typeGuardsInGlobal.ts, 4, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInGlobal.ts, 5, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } else { num = var1; // number diff --git a/tests/baselines/reference/typeGuardsInIfStatement.symbols b/tests/baselines/reference/typeGuardsInIfStatement.symbols index 798fe18cf5a..54a65f0693b 100644 --- a/tests/baselines/reference/typeGuardsInIfStatement.symbols +++ b/tests/baselines/reference/typeGuardsInIfStatement.symbols @@ -13,9 +13,9 @@ function foo(x: number | string) { >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 6, 13)) return x.length; // string ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 6, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } else { return x++; // number @@ -181,9 +181,9 @@ function foo9(x: number | string) { // usage of x or assignment to separate variable shouldn't cause narrowing of type to stop y = x.length; >y : Symbol(y, Decl(typeGuardsInIfStatement.ts, 91, 7)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 90, 14)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) return x === "hello"; // string >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 90, 14)) @@ -249,9 +249,9 @@ function foo11(x: number | string | boolean) { // change value of x x = 10 && x.toString() // number | boolean | string >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15)) ->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15)) ->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ) : ( @@ -259,9 +259,9 @@ function foo11(x: number | string | boolean) { y = x && x.toString() // number | boolean | string >y : Symbol(y, Decl(typeGuardsInIfStatement.ts, 121, 11)) >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15)) ->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 114, 15)) ->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) ); } @@ -276,9 +276,9 @@ function foo12(x: number | string | boolean) { >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15)) return x.toString(); // string | number | boolean - x changed in else branch ->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15)) ->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } else { x = 10; @@ -292,13 +292,13 @@ function foo12(x: number | string | boolean) { >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15)) ? x.toString() // number ->x.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) : x.toString(); // boolean | string ->x.toString : Symbol(toString, Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInIfStatement.ts, 134, 15)) ->toString : Symbol(toString, Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } } diff --git a/tests/baselines/reference/typeGuardsInModule.symbols b/tests/baselines/reference/typeGuardsInModule.symbols index 581bb26d805..9c501e9c22f 100644 --- a/tests/baselines/reference/typeGuardsInModule.symbols +++ b/tests/baselines/reference/typeGuardsInModule.symbols @@ -20,9 +20,9 @@ module m1 { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3)) >var1 : Symbol(var1, Decl(typeGuardsInModule.ts, 6, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInModule.ts, 6, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in module declaration var var2: string | number; @@ -33,9 +33,9 @@ module m1 { num = var2.length; // string >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInModule.ts, 13, 7)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } else { num = var2; // number @@ -77,17 +77,17 @@ module m2 { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3)) >var1 : Symbol(var1, Decl(typeGuardsInModule.ts, 6, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInModule.ts, 6, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // local variables from outer module declaration num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3)) >var2 : Symbol(var2, Decl(typeGuardsInModule.ts, 32, 7)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInModule.ts, 32, 7)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // exported variable from outer the module strOrNum = typeof var3 === "string" && var3; // string | number @@ -104,9 +104,9 @@ module m2 { num = var4.length; // string >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3)) ->var4.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var4.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var4 : Symbol(var4, Decl(typeGuardsInModule.ts, 45, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } else { num = var4; // number @@ -141,9 +141,9 @@ module m3.m4 { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3)) >var1 : Symbol(var1, Decl(typeGuardsInModule.ts, 6, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsInModule.ts, 6, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in module declaration var var2: string | number; @@ -154,9 +154,9 @@ module m3.m4 { num = var2.length; // string >num : Symbol(num, Decl(typeGuardsInModule.ts, 4, 3)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsInModule.ts, 69, 7)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } else { num = var2; // number diff --git a/tests/baselines/reference/typeGuardsInProperties.types b/tests/baselines/reference/typeGuardsInProperties.types index 2167eb88642..ca4d8b94527 100644 --- a/tests/baselines/reference/typeGuardsInProperties.types +++ b/tests/baselines/reference/typeGuardsInProperties.types @@ -35,11 +35,11 @@ class C1 { >typeof this.pp1 === "string" : boolean >typeof this.pp1 : string >this.pp1 : string | number ->this : C1 +>this : this >pp1 : string | number >"string" : string >this.pp1 : string | number ->this : C1 +>this : this >pp1 : string | number strOrNum = typeof this.pp2 === "string" && this.pp2; // string | number @@ -49,11 +49,11 @@ class C1 { >typeof this.pp2 === "string" : boolean >typeof this.pp2 : string >this.pp2 : string | number ->this : C1 +>this : this >pp2 : string | number >"string" : string >this.pp2 : string | number ->this : C1 +>this : this >pp2 : string | number strOrNum = typeof this.pp3 === "string" && this.pp3; // string | number @@ -63,11 +63,11 @@ class C1 { >typeof this.pp3 === "string" : boolean >typeof this.pp3 : string >this.pp3 : string | number ->this : C1 +>this : this >pp3 : string | number >"string" : string >this.pp3 : string | number ->this : C1 +>this : this >pp3 : string | number } } diff --git a/tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.symbols b/tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.symbols index 59f51d21e71..21e3dd3701f 100644 --- a/tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.symbols +++ b/tests/baselines/reference/typeGuardsInRightOperandOfAndAndOperator.symbols @@ -8,9 +8,9 @@ function foo(x: number | string) { return typeof x === "string" && x.length === 10; // string >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 3, 13)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 3, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } function foo2(x: number | string) { >foo2 : Symbol(foo2, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 5, 1)) @@ -106,17 +106,17 @@ function foo7(x: number | string | boolean) { // change value of x ? (x = 10 && x.toString()) // number | boolean | string >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14)) ->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14)) ->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) // do not change value : (y = x && x.toString()))); // number | boolean | string >y : Symbol(y, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 34, 7)) >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14)) ->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 33, 14)) ->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function foo8(x: number | string) { >foo8 : Symbol(foo8, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 45, 1)) @@ -137,7 +137,7 @@ function foo8(x: number | string) { >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 46, 14)) : x.length); // string ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInRightOperandOfAndAndOperator.ts, 46, 14)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.symbols b/tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.symbols index d33f0b6877b..de9b4396d3d 100644 --- a/tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.symbols +++ b/tests/baselines/reference/typeGuardsInRightOperandOfOrOrOperator.symbols @@ -8,9 +8,9 @@ function foo(x: number | string) { return typeof x !== "string" || x.length === 10; // string >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 3, 13)) ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 3, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } function foo2(x: number | string) { >foo2 : Symbol(foo2, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 5, 1)) @@ -106,17 +106,17 @@ function foo7(x: number | string | boolean) { // change value of x ? (x = 10 && x.toString()) // number | boolean | string >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14)) ->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14)) ->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) // do not change value : (y = x && x.toString()))); // number | boolean | string >y : Symbol(y, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 34, 7)) >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14)) ->x.toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>x.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 33, 14)) ->toString : Symbol(toString, Decl(lib.d.ts, 458, 18), Decl(lib.d.ts, 277, 18), Decl(lib.d.ts, 96, 26)) +>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } function foo8(x: number | string) { >foo8 : Symbol(foo8, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 45, 1)) @@ -137,7 +137,7 @@ function foo8(x: number | string) { >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 46, 14)) : x.length); // string ->x.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>x.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeGuardsInRightOperandOfOrOrOperator.ts, 46, 14)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/typeGuardsObjectMethods.symbols b/tests/baselines/reference/typeGuardsObjectMethods.symbols index 3f585c1e4c6..2afbb3a8467 100644 --- a/tests/baselines/reference/typeGuardsObjectMethods.symbols +++ b/tests/baselines/reference/typeGuardsObjectMethods.symbols @@ -25,9 +25,9 @@ var obj1 = { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3)) >var1 : Symbol(var1, Decl(typeGuardsObjectMethods.ts, 7, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsObjectMethods.ts, 7, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -36,17 +36,17 @@ var obj1 = { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3)) >var2 : Symbol(var2, Decl(typeGuardsObjectMethods.ts, 15, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsObjectMethods.ts, 15, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameters in function declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3)) >param : Symbol(param, Decl(typeGuardsObjectMethods.ts, 10, 11)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsObjectMethods.ts, 10, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) return strOrNum; >strOrNum : Symbol(strOrNum, Decl(typeGuardsObjectMethods.ts, 6, 3)) @@ -59,9 +59,9 @@ var obj1 = { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3)) >var1 : Symbol(var1, Decl(typeGuardsObjectMethods.ts, 7, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsObjectMethods.ts, 7, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -70,9 +70,9 @@ var obj1 = { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3)) >var2 : Symbol(var2, Decl(typeGuardsObjectMethods.ts, 28, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsObjectMethods.ts, 28, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) return strOrNum; >strOrNum : Symbol(strOrNum, Decl(typeGuardsObjectMethods.ts, 6, 3)) @@ -86,9 +86,9 @@ var obj1 = { num = typeof var1 === "string" && var1.length; // string >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3)) >var1 : Symbol(var1, Decl(typeGuardsObjectMethods.ts, 7, 3)) ->var1.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var1.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var1 : Symbol(var1, Decl(typeGuardsObjectMethods.ts, 7, 3)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // variables in function declaration var var2: string | number; @@ -97,17 +97,17 @@ var obj1 = { num = typeof var2 === "string" && var2.length; // string >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3)) >var2 : Symbol(var2, Decl(typeGuardsObjectMethods.ts, 38, 11)) ->var2.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>var2.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >var2 : Symbol(var2, Decl(typeGuardsObjectMethods.ts, 38, 11)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) // parameters in function declaration num = typeof param === "string" && param.length; // string >num : Symbol(num, Decl(typeGuardsObjectMethods.ts, 5, 3)) >param : Symbol(param, Decl(typeGuardsObjectMethods.ts, 33, 13)) ->param.length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>param.length : Symbol(String.length, Decl(lib.d.ts, --, --)) >param : Symbol(param, Decl(typeGuardsObjectMethods.ts, 33, 13)) ->length : Symbol(String.length, Decl(lib.d.ts, 414, 19)) +>length : Symbol(String.length, Decl(lib.d.ts, --, --)) } }; // return expression of the method diff --git a/tests/baselines/reference/typeGuardsWithInstanceOf.symbols b/tests/baselines/reference/typeGuardsWithInstanceOf.symbols index b010ef12692..81efb5d5b1d 100644 --- a/tests/baselines/reference/typeGuardsWithInstanceOf.symbols +++ b/tests/baselines/reference/typeGuardsWithInstanceOf.symbols @@ -13,7 +13,7 @@ var result2: I; if (!(result instanceof RegExp)) { >result : Symbol(result, Decl(typeGuardsWithInstanceOf.ts, 1, 3)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) result = result2; >result : Symbol(result, Decl(typeGuardsWithInstanceOf.ts, 1, 3)) diff --git a/tests/baselines/reference/typeInferenceReturnTypeCallback.types b/tests/baselines/reference/typeInferenceReturnTypeCallback.types index fb26424d892..408e60f90ec 100644 --- a/tests/baselines/reference/typeInferenceReturnTypeCallback.types +++ b/tests/baselines/reference/typeInferenceReturnTypeCallback.types @@ -54,7 +54,7 @@ class Cons implements IList{ return this.foldRight(new Nil(), (t, acc) => { >this.foldRight(new Nil(), (t, acc) => { return new Cons(); }) : Nil >this.foldRight : (z: E, f: (t: T, acc: E) => E) => E ->this : Cons +>this : this >foldRight : (z: E, f: (t: T, acc: E) => E) => E >new Nil() : Nil >Nil : typeof Nil diff --git a/tests/baselines/reference/typeInferenceWithTupleType.symbols b/tests/baselines/reference/typeInferenceWithTupleType.symbols index a78cd0d490b..6f3279db8c2 100644 --- a/tests/baselines/reference/typeInferenceWithTupleType.symbols +++ b/tests/baselines/reference/typeInferenceWithTupleType.symbols @@ -41,12 +41,12 @@ function zip(array1: T[], array2: U[]): [[T, U]] { >U : Symbol(U, Decl(typeInferenceWithTupleType.ts, 8, 15)) if (array1.length != array2.length) { ->array1.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >array1 : Symbol(array1, Decl(typeInferenceWithTupleType.ts, 8, 19)) ->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) ->array2.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) +>array2.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >array2 : Symbol(array2, Decl(typeInferenceWithTupleType.ts, 8, 31)) ->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) return [[undefined, undefined]]; >undefined : Symbol(undefined) @@ -54,9 +54,9 @@ function zip(array1: T[], array2: U[]): [[T, U]] { } var length = array1.length; >length : Symbol(length, Decl(typeInferenceWithTupleType.ts, 12, 7)) ->array1.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>array1.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >array1 : Symbol(array1, Decl(typeInferenceWithTupleType.ts, 8, 19)) ->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) var zipResult: [[T, U]]; >zipResult : Symbol(zipResult, Decl(typeInferenceWithTupleType.ts, 13, 7)) @@ -70,9 +70,9 @@ function zip(array1: T[], array2: U[]): [[T, U]] { >i : Symbol(i, Decl(typeInferenceWithTupleType.ts, 14, 12)) zipResult.push([array1[i], array2[i]]); ->zipResult.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>zipResult.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >zipResult : Symbol(zipResult, Decl(typeInferenceWithTupleType.ts, 13, 7)) ->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >array1 : Symbol(array1, Decl(typeInferenceWithTupleType.ts, 8, 19)) >i : Symbol(i, Decl(typeInferenceWithTupleType.ts, 14, 12)) >array2 : Symbol(array2, Decl(typeInferenceWithTupleType.ts, 8, 31)) diff --git a/tests/baselines/reference/typeOfThis.errors.txt b/tests/baselines/reference/typeOfThis.errors.txt index bc3e9754c09..83d450570fc 100644 --- a/tests/baselines/reference/typeOfThis.errors.txt +++ b/tests/baselines/reference/typeOfThis.errors.txt @@ -1,14 +1,24 @@ +tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(14,13): error TS2403: Subsequent variable declarations must have the same type. Variable 't' must be of type 'this', but here has type 'MyTestClass'. +tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(18,13): error TS2403: Subsequent variable declarations must have the same type. Variable 'p' must be of type 'this', but here has type 'MyTestClass'. tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(22,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(24,13): error TS2403: Subsequent variable declarations must have the same type. Variable 'p' must be of type 'this', but here has type 'MyTestClass'. tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(27,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(29,13): error TS2403: Subsequent variable declarations must have the same type. Variable 'p' must be of type 'this', but here has type 'MyTestClass'. +tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(37,13): error TS2403: Subsequent variable declarations must have the same type. Variable 't' must be of type 'this', but here has type 'MyTestClass'. tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(53,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(61,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(83,13): error TS2403: Subsequent variable declarations must have the same type. Variable 't' must be of type 'this', but here has type 'MyGenericTestClass'. +tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(87,13): error TS2403: Subsequent variable declarations must have the same type. Variable 'p' must be of type 'this', but here has type 'MyGenericTestClass'. tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(91,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(93,13): error TS2403: Subsequent variable declarations must have the same type. Variable 'p' must be of type 'this', but here has type 'MyGenericTestClass'. tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(96,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(98,13): error TS2403: Subsequent variable declarations must have the same type. Variable 'p' must be of type 'this', but here has type 'MyGenericTestClass'. +tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(106,13): error TS2403: Subsequent variable declarations must have the same type. Variable 't' must be of type 'this', but here has type 'MyGenericTestClass'. tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(122,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(130,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -==== tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts (8 errors) ==== +==== tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts (18 errors) ==== class MyTestClass { private canary: number; static staticCanary: number; @@ -23,10 +33,14 @@ tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(130,16): error TS1 //type of 'this' in member function param list is the class instance type memberFunc(t = this) { var t: MyTestClass; + ~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 't' must be of type 'this', but here has type 'MyTestClass'. //type of 'this' in member function body is the class instance type var p = this; var p: MyTestClass; + ~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'p' must be of type 'this', but here has type 'MyTestClass'. } //type of 'this' in member accessor(get and set) body is the class instance type @@ -35,6 +49,8 @@ tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(130,16): error TS1 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. var p = this; var p: MyTestClass; + ~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'p' must be of type 'this', but here has type 'MyTestClass'. return this; } set prop(v) { @@ -42,6 +58,8 @@ tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(130,16): error TS1 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. var p = this; var p: MyTestClass; + ~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'p' must be of type 'this', but here has type 'MyTestClass'. p = v; v = p; } @@ -50,6 +68,8 @@ tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(130,16): error TS1 //type of 'this' in member variable initializer is the class instance type var t = this; var t: MyTestClass; + ~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 't' must be of type 'this', but here has type 'MyTestClass'. }; //type of 'this' in static function param list is constructor function type @@ -100,10 +120,14 @@ tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(130,16): error TS1 //type of 'this' in member function param list is the class instance type memberFunc(t = this) { var t: MyGenericTestClass; + ~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 't' must be of type 'this', but here has type 'MyGenericTestClass'. //type of 'this' in member function body is the class instance type var p = this; var p: MyGenericTestClass; + ~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'p' must be of type 'this', but here has type 'MyGenericTestClass'. } //type of 'this' in member accessor(get and set) body is the class instance type @@ -112,6 +136,8 @@ tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(130,16): error TS1 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. var p = this; var p: MyGenericTestClass; + ~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'p' must be of type 'this', but here has type 'MyGenericTestClass'. return this; } set prop(v) { @@ -119,6 +145,8 @@ tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(130,16): error TS1 !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. var p = this; var p: MyGenericTestClass; + ~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 'p' must be of type 'this', but here has type 'MyGenericTestClass'. p = v; v = p; } @@ -127,6 +155,8 @@ tests/cases/conformance/expressions/thisKeyword/typeOfThis.ts(130,16): error TS1 //type of 'this' in member variable initializer is the class instance type var t = this; var t: MyGenericTestClass; + ~ +!!! error TS2403: Subsequent variable declarations must have the same type. Variable 't' must be of type 'this', but here has type 'MyGenericTestClass'. }; //type of 'this' in static function param list is constructor function type diff --git a/tests/baselines/reference/typeOfThisInMemberFunctions.symbols b/tests/baselines/reference/typeOfThisInMemberFunctions.symbols index 31b04a52f86..c0a860af4f7 100644 --- a/tests/baselines/reference/typeOfThisInMemberFunctions.symbols +++ b/tests/baselines/reference/typeOfThisInMemberFunctions.symbols @@ -47,7 +47,7 @@ class D { class E { >E : Symbol(E, Decl(typeOfThisInMemberFunctions.ts, 19, 1)) >T : Symbol(T, Decl(typeOfThisInMemberFunctions.ts, 21, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) x: T; >x : Symbol(x, Decl(typeOfThisInMemberFunctions.ts, 21, 25)) diff --git a/tests/baselines/reference/typeOfThisInMemberFunctions.types b/tests/baselines/reference/typeOfThisInMemberFunctions.types index 2be8af1ca75..7318bae2d32 100644 --- a/tests/baselines/reference/typeOfThisInMemberFunctions.types +++ b/tests/baselines/reference/typeOfThisInMemberFunctions.types @@ -6,8 +6,8 @@ class C { >foo : () => void var r = this; ->r : C ->this : C +>r : this +>this : this } static bar() { @@ -31,8 +31,8 @@ class D { >foo : () => void var r = this; ->r : D ->this : D +>r : this +>this : this } static bar() { @@ -57,8 +57,8 @@ class E { >foo : () => void var r = this; ->r : E ->this : E +>r : this +>this : this } static bar() { diff --git a/tests/baselines/reference/typeParameterAndArgumentOfSameName1.symbols b/tests/baselines/reference/typeParameterAndArgumentOfSameName1.symbols index 450b291708f..e38953fe8a2 100644 --- a/tests/baselines/reference/typeParameterAndArgumentOfSameName1.symbols +++ b/tests/baselines/reference/typeParameterAndArgumentOfSameName1.symbols @@ -2,16 +2,16 @@ function f(A: A): A { >f : Symbol(f, Decl(typeParameterAndArgumentOfSameName1.ts, 0, 0)) >A : Symbol(A, Decl(typeParameterAndArgumentOfSameName1.ts, 0, 11), Decl(typeParameterAndArgumentOfSameName1.ts, 0, 29)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >A : Symbol(A, Decl(typeParameterAndArgumentOfSameName1.ts, 0, 11), Decl(typeParameterAndArgumentOfSameName1.ts, 0, 29)) >A : Symbol(A, Decl(typeParameterAndArgumentOfSameName1.ts, 0, 11), Decl(typeParameterAndArgumentOfSameName1.ts, 0, 29)) >A : Symbol(A, Decl(typeParameterAndArgumentOfSameName1.ts, 0, 11), Decl(typeParameterAndArgumentOfSameName1.ts, 0, 29)) var r = A.toExponential(123); >r : Symbol(r, Decl(typeParameterAndArgumentOfSameName1.ts, 1, 7)) ->A.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>A.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) >A : Symbol(A, Decl(typeParameterAndArgumentOfSameName1.ts, 0, 11), Decl(typeParameterAndArgumentOfSameName1.ts, 0, 29)) ->toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, 469, 45)) +>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --)) return null; } diff --git a/tests/baselines/reference/typeParameterExtendingUnion1.symbols b/tests/baselines/reference/typeParameterExtendingUnion1.symbols index 97d900b5d5e..39b67e6428c 100644 --- a/tests/baselines/reference/typeParameterExtendingUnion1.symbols +++ b/tests/baselines/reference/typeParameterExtendingUnion1.symbols @@ -33,9 +33,9 @@ function f(a: T) { >T : Symbol(T, Decl(typeParameterExtendingUnion1.ts, 8, 11)) a.run(); ->a.run : Symbol(Animal.run, Decl(typeParameterExtendingUnion1.ts, 0, 14)) +>a.run : Symbol(run, Decl(typeParameterExtendingUnion1.ts, 0, 14), Decl(typeParameterExtendingUnion1.ts, 0, 14)) >a : Symbol(a, Decl(typeParameterExtendingUnion1.ts, 8, 32)) ->run : Symbol(Animal.run, Decl(typeParameterExtendingUnion1.ts, 0, 14)) +>run : Symbol(run, Decl(typeParameterExtendingUnion1.ts, 0, 14), Decl(typeParameterExtendingUnion1.ts, 0, 14)) run(a); >run : Symbol(run, Decl(typeParameterExtendingUnion1.ts, 2, 33)) diff --git a/tests/baselines/reference/typeParameterExtendingUnion2.symbols b/tests/baselines/reference/typeParameterExtendingUnion2.symbols index 21866b3df92..44d47692a82 100644 --- a/tests/baselines/reference/typeParameterExtendingUnion2.symbols +++ b/tests/baselines/reference/typeParameterExtendingUnion2.symbols @@ -20,9 +20,9 @@ function run(a: Cat | Dog) { >Dog : Symbol(Dog, Decl(typeParameterExtendingUnion2.ts, 1, 33)) a.run(); ->a.run : Symbol(Animal.run, Decl(typeParameterExtendingUnion2.ts, 0, 14)) +>a.run : Symbol(run, Decl(typeParameterExtendingUnion2.ts, 0, 14), Decl(typeParameterExtendingUnion2.ts, 0, 14)) >a : Symbol(a, Decl(typeParameterExtendingUnion2.ts, 4, 13)) ->run : Symbol(Animal.run, Decl(typeParameterExtendingUnion2.ts, 0, 14)) +>run : Symbol(run, Decl(typeParameterExtendingUnion2.ts, 0, 14), Decl(typeParameterExtendingUnion2.ts, 0, 14)) } function f(a: T) { @@ -34,9 +34,9 @@ function f(a: T) { >T : Symbol(T, Decl(typeParameterExtendingUnion2.ts, 8, 11)) a.run(); ->a.run : Symbol(Animal.run, Decl(typeParameterExtendingUnion2.ts, 0, 14)) +>a.run : Symbol(run, Decl(typeParameterExtendingUnion2.ts, 0, 14), Decl(typeParameterExtendingUnion2.ts, 0, 14)) >a : Symbol(a, Decl(typeParameterExtendingUnion2.ts, 8, 32)) ->run : Symbol(Animal.run, Decl(typeParameterExtendingUnion2.ts, 0, 14)) +>run : Symbol(run, Decl(typeParameterExtendingUnion2.ts, 0, 14), Decl(typeParameterExtendingUnion2.ts, 0, 14)) run(a); >run : Symbol(run, Decl(typeParameterExtendingUnion2.ts, 2, 33)) diff --git a/tests/baselines/reference/typeParametersAreIdenticalToThemselves.symbols b/tests/baselines/reference/typeParametersAreIdenticalToThemselves.symbols index c9b06d0d68f..e50bce9e043 100644 --- a/tests/baselines/reference/typeParametersAreIdenticalToThemselves.symbols +++ b/tests/baselines/reference/typeParametersAreIdenticalToThemselves.symbols @@ -144,21 +144,21 @@ class C { foo4(x: T); >foo4 : Symbol(foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 31, 21), Decl(typeParametersAreIdenticalToThemselves.ts, 33, 31), Decl(typeParametersAreIdenticalToThemselves.ts, 34, 31)) >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 33, 9)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 33, 25)) >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 33, 9)) foo4(x: T); // no error, different declaration for each T >foo4 : Symbol(foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 31, 21), Decl(typeParametersAreIdenticalToThemselves.ts, 33, 31), Decl(typeParametersAreIdenticalToThemselves.ts, 34, 31)) >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 34, 9)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 34, 25)) >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 34, 9)) foo4(x: T) { } >foo4 : Symbol(foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 31, 21), Decl(typeParametersAreIdenticalToThemselves.ts, 33, 31), Decl(typeParametersAreIdenticalToThemselves.ts, 34, 31)) >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 35, 9)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 35, 25)) >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 35, 9)) } @@ -166,7 +166,7 @@ class C { class C2 { >C2 : Symbol(C2, Decl(typeParametersAreIdenticalToThemselves.ts, 36, 1)) >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 38, 9)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo1(x: T); >foo1 : Symbol(foo1, Decl(typeParametersAreIdenticalToThemselves.ts, 38, 26), Decl(typeParametersAreIdenticalToThemselves.ts, 39, 15), Decl(typeParametersAreIdenticalToThemselves.ts, 40, 15)) @@ -271,14 +271,14 @@ interface I { foo4(x: T); >foo4 : Symbol(foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 60, 18), Decl(typeParametersAreIdenticalToThemselves.ts, 62, 31)) >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 62, 9)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 62, 25)) >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 62, 9)) foo4(x: T); // no error, different declaration for each T >foo4 : Symbol(foo4, Decl(typeParametersAreIdenticalToThemselves.ts, 60, 18), Decl(typeParametersAreIdenticalToThemselves.ts, 62, 31)) >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 63, 9)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(typeParametersAreIdenticalToThemselves.ts, 63, 25)) >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 63, 9)) } @@ -286,7 +286,7 @@ interface I { interface I2 { >I2 : Symbol(I2, Decl(typeParametersAreIdenticalToThemselves.ts, 64, 1)) >T : Symbol(T, Decl(typeParametersAreIdenticalToThemselves.ts, 66, 13)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo1(x: T); >foo1 : Symbol(foo1, Decl(typeParametersAreIdenticalToThemselves.ts, 66, 30), Decl(typeParametersAreIdenticalToThemselves.ts, 67, 15)) diff --git a/tests/baselines/reference/typeRelationships.errors.txt b/tests/baselines/reference/typeRelationships.errors.txt new file mode 100644 index 00000000000..37954415778 --- /dev/null +++ b/tests/baselines/reference/typeRelationships.errors.txt @@ -0,0 +1,54 @@ +tests/cases/conformance/types/thisType/typeRelationships.ts(9,9): error TS2322: Type 'C' is not assignable to type 'this'. +tests/cases/conformance/types/thisType/typeRelationships.ts(35,9): error TS2322: Type 'C' is not assignable to type 'D'. + Property 'self1' is missing in type 'C'. +tests/cases/conformance/types/thisType/typeRelationships.ts(36,9): error TS2322: Type 'D' is not assignable to type 'this'. + + +==== tests/cases/conformance/types/thisType/typeRelationships.ts (3 errors) ==== + class C { + self = this; + c = new C(); + foo() { + return this; + } + f1() { + this.c = this.self; + this.self = this.c; // Error + ~~~~~~~~~ +!!! error TS2322: Type 'C' is not assignable to type 'this'. + } + f2() { + var a: C[]; + var a = [this, this.c]; // C[] since this is subtype of C + var b: this[]; + var b = [this, this.self, null, undefined]; + } + f3(b: boolean) { + return b ? this.c : this.self; // Should be C + } + } + + class D extends C { + self1 = this; + self2 = this.self; + self3 = this.foo(); + d = new D(); + bar() { + this.self = this.self1; + this.self = this.self2; + this.self = this.self3; + this.self1 = this.self; + this.self2 = this.self; + this.self3 = this.self; + this.d = this.self; + this.d = this.c; // Error + ~~~~~~ +!!! error TS2322: Type 'C' is not assignable to type 'D'. +!!! error TS2322: Property 'self1' is missing in type 'C'. + this.self = this.d; // Error + ~~~~~~~~~ +!!! error TS2322: Type 'D' is not assignable to type 'this'. + this.c = this.d; + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/typeRelationships.js b/tests/baselines/reference/typeRelationships.js new file mode 100644 index 00000000000..1e31009f9b7 --- /dev/null +++ b/tests/baselines/reference/typeRelationships.js @@ -0,0 +1,94 @@ +//// [typeRelationships.ts] +class C { + self = this; + c = new C(); + foo() { + return this; + } + f1() { + this.c = this.self; + this.self = this.c; // Error + } + f2() { + var a: C[]; + var a = [this, this.c]; // C[] since this is subtype of C + var b: this[]; + var b = [this, this.self, null, undefined]; + } + f3(b: boolean) { + return b ? this.c : this.self; // Should be C + } +} + +class D extends C { + self1 = this; + self2 = this.self; + self3 = this.foo(); + d = new D(); + bar() { + this.self = this.self1; + this.self = this.self2; + this.self = this.self3; + this.self1 = this.self; + this.self2 = this.self; + this.self3 = this.self; + this.d = this.self; + this.d = this.c; // Error + this.self = this.d; // Error + this.c = this.d; + } +} + + +//// [typeRelationships.js] +var __extends = (this && this.__extends) || function (d, b) { + for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); +}; +var C = (function () { + function C() { + this.self = this; + this.c = new C(); + } + C.prototype.foo = function () { + return this; + }; + C.prototype.f1 = function () { + this.c = this.self; + this.self = this.c; // Error + }; + C.prototype.f2 = function () { + var a; + var a = [this, this.c]; // C[] since this is subtype of C + var b; + var b = [this, this.self, null, undefined]; + }; + C.prototype.f3 = function (b) { + return b ? this.c : this.self; // Should be C + }; + return C; +})(); +var D = (function (_super) { + __extends(D, _super); + function D() { + _super.apply(this, arguments); + this.self1 = this; + this.self2 = this.self; + this.self3 = this.foo(); + this.d = new D(); + } + D.prototype.bar = function () { + this.self = this.self1; + this.self = this.self2; + this.self = this.self3; + this.self1 = this.self; + this.self2 = this.self; + this.self3 = this.self; + this.d = this.self; + this.d = this.c; // Error + this.self = this.d; // Error + this.c = this.d; + }; + return D; +})(C); diff --git a/tests/baselines/reference/typeResolution.symbols b/tests/baselines/reference/typeResolution.symbols index dadc38ad58e..aa0d611e52e 100644 --- a/tests/baselines/reference/typeResolution.symbols +++ b/tests/baselines/reference/typeResolution.symbols @@ -18,26 +18,26 @@ export module TopLevelModule1 { var a1: ClassA; a1.AisIn1_1_1(); >a1 : Symbol(a1, Decl(typeResolution.ts, 6, 23)) >ClassA : Symbol(ClassA, Decl(typeResolution.ts, 2, 37)) ->a1.AisIn1_1_1 : Symbol(AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) +>a1.AisIn1_1_1 : Symbol(ClassA.AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) >a1 : Symbol(a1, Decl(typeResolution.ts, 6, 23)) ->AisIn1_1_1 : Symbol(AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) +>AisIn1_1_1 : Symbol(ClassA.AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) var a2: SubSubModule1.ClassA; a2.AisIn1_1_1(); >a2 : Symbol(a2, Decl(typeResolution.ts, 7, 23)) >SubSubModule1 : Symbol(SubSubModule1, Decl(typeResolution.ts, 1, 30)) >ClassA : Symbol(ClassA, Decl(typeResolution.ts, 2, 37)) ->a2.AisIn1_1_1 : Symbol(AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) +>a2.AisIn1_1_1 : Symbol(ClassA.AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) >a2 : Symbol(a2, Decl(typeResolution.ts, 7, 23)) ->AisIn1_1_1 : Symbol(AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) +>AisIn1_1_1 : Symbol(ClassA.AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) var a3: SubModule1.SubSubModule1.ClassA; a3.AisIn1_1_1(); >a3 : Symbol(a3, Decl(typeResolution.ts, 8, 23)) >SubModule1 : Symbol(SubModule1, Decl(typeResolution.ts, 0, 31)) >SubSubModule1 : Symbol(SubSubModule1, Decl(typeResolution.ts, 1, 30)) >ClassA : Symbol(ClassA, Decl(typeResolution.ts, 2, 37)) ->a3.AisIn1_1_1 : Symbol(AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) +>a3.AisIn1_1_1 : Symbol(ClassA.AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) >a3 : Symbol(a3, Decl(typeResolution.ts, 8, 23)) ->AisIn1_1_1 : Symbol(AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) +>AisIn1_1_1 : Symbol(ClassA.AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) var a4: TopLevelModule1.SubModule1.SubSubModule1.ClassA; a4.AisIn1_1_1(); >a4 : Symbol(a4, Decl(typeResolution.ts, 9, 23)) @@ -45,9 +45,9 @@ export module TopLevelModule1 { >SubModule1 : Symbol(SubModule1, Decl(typeResolution.ts, 0, 31)) >SubSubModule1 : Symbol(SubSubModule1, Decl(typeResolution.ts, 1, 30)) >ClassA : Symbol(ClassA, Decl(typeResolution.ts, 2, 37)) ->a4.AisIn1_1_1 : Symbol(AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) +>a4.AisIn1_1_1 : Symbol(ClassA.AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) >a4 : Symbol(a4, Decl(typeResolution.ts, 9, 23)) ->AisIn1_1_1 : Symbol(AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) +>AisIn1_1_1 : Symbol(ClassA.AisIn1_1_1, Decl(typeResolution.ts, 3, 33)) // Two variants of qualifying a peer type var b1: ClassB; b1.BisIn1_1_1(); @@ -142,9 +142,9 @@ export module TopLevelModule1 { var b1: ClassB; b1.BisIn1_1_1(); >b1 : Symbol(b1, Decl(typeResolution.ts, 34, 23)) >ClassB : Symbol(ClassB, Decl(typeResolution.ts, 22, 13)) ->b1.BisIn1_1_1 : Symbol(BisIn1_1_1, Decl(typeResolution.ts, 23, 33)) +>b1.BisIn1_1_1 : Symbol(ClassB.BisIn1_1_1, Decl(typeResolution.ts, 23, 33)) >b1 : Symbol(b1, Decl(typeResolution.ts, 34, 23)) ->BisIn1_1_1 : Symbol(BisIn1_1_1, Decl(typeResolution.ts, 23, 33)) +>BisIn1_1_1 : Symbol(ClassB.BisIn1_1_1, Decl(typeResolution.ts, 23, 33)) var b2: TopLevelModule1.SubModule1.SubSubModule1.ClassB; b2.BisIn1_1_1(); >b2 : Symbol(b2, Decl(typeResolution.ts, 35, 23)) @@ -152,9 +152,9 @@ export module TopLevelModule1 { >SubModule1 : Symbol(SubModule1, Decl(typeResolution.ts, 0, 31)) >SubSubModule1 : Symbol(SubSubModule1, Decl(typeResolution.ts, 1, 30)) >ClassB : Symbol(ClassB, Decl(typeResolution.ts, 22, 13)) ->b2.BisIn1_1_1 : Symbol(BisIn1_1_1, Decl(typeResolution.ts, 23, 33)) +>b2.BisIn1_1_1 : Symbol(ClassB.BisIn1_1_1, Decl(typeResolution.ts, 23, 33)) >b2 : Symbol(b2, Decl(typeResolution.ts, 35, 23)) ->BisIn1_1_1 : Symbol(BisIn1_1_1, Decl(typeResolution.ts, 23, 33)) +>BisIn1_1_1 : Symbol(ClassB.BisIn1_1_1, Decl(typeResolution.ts, 23, 33)) // Type only accessible from the root var c1: TopLevelModule1.SubModule2.SubSubModule2.ClassA; c1.AisIn1_2_2(); diff --git a/tests/baselines/reference/typedArrays.symbols b/tests/baselines/reference/typedArrays.symbols index 41fbab91e3c..cf5e68b956a 100644 --- a/tests/baselines/reference/typedArrays.symbols +++ b/tests/baselines/reference/typedArrays.symbols @@ -8,39 +8,39 @@ function CreateTypedArrayTypes() { typedArrays[0] = Int8Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) typedArrays[1] = Uint8Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) typedArrays[2] = Int16Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) typedArrays[3] = Uint16Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) typedArrays[4] = Int32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) typedArrays[5] = Uint32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) typedArrays[6] = Float32Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) typedArrays[7] = Float64Array; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) typedArrays[8] = Uint8ClampedArray; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) return typedArrays; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 2, 7)) @@ -55,47 +55,47 @@ function CreateTypedArrayInstancesFromLength(obj: number) { typedArrays[0] = new Int8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[1] = new Uint8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[2] = new Int16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[3] = new Uint16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[4] = new Int32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[5] = new Uint32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[6] = new Float32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[7] = new Float64Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) typedArrays[8] = new Uint8ClampedArray(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 17, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 16, 45)) return typedArrays; @@ -111,47 +111,47 @@ function CreateTypedArrayInstancesFromArray(obj: number[]) { typedArrays[0] = new Int8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[1] = new Uint8Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[2] = new Int16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[3] = new Uint16Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[4] = new Int32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[5] = new Uint32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[6] = new Float32Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[7] = new Float64Array(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) typedArrays[8] = new Uint8ClampedArray(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 32, 7)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 31, 44)) return typedArrays; @@ -167,65 +167,65 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { typedArrays[0] = Int8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[1] = Uint8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[2] = Int16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[3] = Uint16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[4] = Int32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[5] = Uint32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[6] = Float32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[7] = Float64Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) typedArrays[8] = Uint8ClampedArray.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 47, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 46, 44)) return typedArrays; @@ -235,72 +235,72 @@ function CreateIntegerTypedArraysFromArray2(obj:number[]) { function CreateIntegerTypedArraysFromArrayLike(obj:ArrayLike) { >CreateIntegerTypedArraysFromArrayLike : Symbol(CreateIntegerTypedArraysFromArrayLike, Decl(typedArrays.ts, 59, 1)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) ->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1198, 1)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, --, --)) var typedArrays = []; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) typedArrays[0] = Int8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[1] = Uint8Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[2] = Int16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[3] = Uint16Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[4] = Int32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[5] = Uint32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[6] = Float32Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[7] = Float64Array.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) typedArrays[8] = Uint8ClampedArray.from(obj); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 62, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 61, 47)) return typedArrays; @@ -332,57 +332,57 @@ function CreateTypedArraysOf2() { typedArrays[0] = Int8Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 1635, 30)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1)) ->of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, 1635, 30)) +>Int8Array.of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, --, --)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>of : Symbol(Int8ArrayConstructor.of, Decl(lib.d.ts, --, --)) typedArrays[1] = Uint8Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 1909, 30)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1)) ->of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, 1909, 30)) +>Uint8Array.of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, --, --)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>of : Symbol(Uint8ArrayConstructor.of, Decl(lib.d.ts, --, --)) typedArrays[2] = Int16Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 2456, 30)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1)) ->of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, 2456, 30)) +>Int16Array.of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, --, --)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>of : Symbol(Int16ArrayConstructor.of, Decl(lib.d.ts, --, --)) typedArrays[3] = Uint16Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 2730, 30)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1)) ->of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, 2730, 30)) +>Uint16Array.of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, --, --)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>of : Symbol(Uint16ArrayConstructor.of, Decl(lib.d.ts, --, --)) typedArrays[4] = Int32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3003, 30)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1)) ->of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, 3003, 30)) +>Int32Array.of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, --, --)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>of : Symbol(Int32ArrayConstructor.of, Decl(lib.d.ts, --, --)) typedArrays[5] = Uint32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 3276, 30)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1)) ->of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, 3276, 30)) +>Uint32Array.of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, --, --)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>of : Symbol(Uint32ArrayConstructor.of, Decl(lib.d.ts, --, --)) typedArrays[6] = Float32Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 3549, 30)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1)) ->of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, 3549, 30)) +>Float32Array.of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, --, --)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>of : Symbol(Float32ArrayConstructor.of, Decl(lib.d.ts, --, --)) typedArrays[7] = Float64Array.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 3823, 30)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1)) ->of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, 3823, 30)) +>Float64Array.of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, --, --)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>of : Symbol(Float64ArrayConstructor.of, Decl(lib.d.ts, --, --)) typedArrays[8] = Uint8ClampedArray.of(1,2,3,4); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) ->Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2183, 30)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1)) ->of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, 2183, 30)) +>Uint8ClampedArray.of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, --, --)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>of : Symbol(Uint8ClampedArrayConstructor.of, Decl(lib.d.ts, --, --)) return typedArrays; >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 94, 7)) @@ -391,7 +391,7 @@ function CreateTypedArraysOf2() { function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:number)=> number) { >CreateTypedArraysFromMapFn : Symbol(CreateTypedArraysFromMapFn, Decl(typedArrays.ts, 106, 1)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) ->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1198, 1)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, --, --)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) >n : Symbol(n, Decl(typedArrays.ts, 108, 67)) >v : Symbol(v, Decl(typedArrays.ts, 108, 76)) @@ -401,73 +401,73 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n typedArrays[0] = Int8Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[1] = Uint8Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[2] = Int16Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[3] = Uint16Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[4] = Int32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[5] = Uint32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[6] = Float32Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[7] = Float64Array.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) typedArrays[8] = Uint8ClampedArray.from(obj, mapFn); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 109, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 108, 36)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 108, 58)) @@ -478,7 +478,7 @@ function CreateTypedArraysFromMapFn(obj:ArrayLike, mapFn: (n:number, v:n function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v:number)=> number, thisArg: {}) { >CreateTypedArraysFromThisObj : Symbol(CreateTypedArraysFromThisObj, Decl(typedArrays.ts, 121, 1)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) ->ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, 1198, 1)) +>ArrayLike : Symbol(ArrayLike, Decl(lib.d.ts, --, --)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >n : Symbol(n, Decl(typedArrays.ts, 123, 69)) >v : Symbol(v, Decl(typedArrays.ts, 123, 78)) @@ -489,81 +489,81 @@ function CreateTypedArraysFromThisObj(obj:ArrayLike, mapFn: (n:number, v typedArrays[0] = Int8Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48)) ->Int8Array : Symbol(Int8Array, Decl(lib.d.ts, 1379, 42), Decl(lib.d.ts, 1652, 11), Decl(lib.d.ts, 4731, 1)) ->from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, 1641, 38), Decl(lib.d.ts, 4754, 48)) +>Int8Array.from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Int8Array : Symbol(Int8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Int8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[1] = Uint8Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49)) ->Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, 1652, 44), Decl(lib.d.ts, 1926, 11), Decl(lib.d.ts, 4763, 1)) ->from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, 1915, 39), Decl(lib.d.ts, 4786, 49)) +>Uint8Array.from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint8Array : Symbol(Uint8Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint8ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[2] = Int16Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49)) ->Int16Array : Symbol(Int16Array, Decl(lib.d.ts, 2199, 60), Decl(lib.d.ts, 2473, 11), Decl(lib.d.ts, 4831, 1)) ->from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, 2462, 39), Decl(lib.d.ts, 4858, 49)) +>Int16Array.from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Int16Array : Symbol(Int16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Int16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[3] = Uint16Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50)) ->Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, 2473, 46), Decl(lib.d.ts, 2747, 11), Decl(lib.d.ts, 4867, 1)) ->from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, 2736, 40), Decl(lib.d.ts, 4890, 50)) +>Uint16Array.from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint16Array : Symbol(Uint16Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint16ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[4] = Int32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49)) ->Int32Array : Symbol(Int32Array, Decl(lib.d.ts, 2747, 48), Decl(lib.d.ts, 3019, 11), Decl(lib.d.ts, 4899, 1)) ->from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, 3009, 39), Decl(lib.d.ts, 4922, 49)) +>Int32Array.from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Int32Array : Symbol(Int32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Int32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[5] = Uint32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50)) ->Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, 3019, 46), Decl(lib.d.ts, 3292, 11), Decl(lib.d.ts, 4931, 1)) ->from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, 3282, 40), Decl(lib.d.ts, 4954, 50)) +>Uint32Array.from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint32Array : Symbol(Uint32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[6] = Float32Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51)) ->Float32Array : Symbol(Float32Array, Decl(lib.d.ts, 3292, 48), Decl(lib.d.ts, 3566, 11), Decl(lib.d.ts, 4963, 1)) ->from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, 3555, 41), Decl(lib.d.ts, 4986, 51)) +>Float32Array.from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Float32Array : Symbol(Float32Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Float32ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[7] = Float64Array.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51)) ->Float64Array : Symbol(Float64Array, Decl(lib.d.ts, 3566, 50), Decl(lib.d.ts, 3839, 11), Decl(lib.d.ts, 4995, 1)) ->from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, 3829, 41), Decl(lib.d.ts, 5018, 51)) +>Float64Array.from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Float64Array : Symbol(Float64Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Float64ArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) typedArrays[8] = Uint8ClampedArray.from(obj, mapFn, thisArg); >typedArrays : Symbol(typedArrays, Decl(typedArrays.ts, 124, 7)) ->Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56)) ->Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, 1926, 46), Decl(lib.d.ts, 2199, 11), Decl(lib.d.ts, 4795, 1)) ->from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, 2189, 46), Decl(lib.d.ts, 4821, 56)) +>Uint8ClampedArray.from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Uint8ClampedArray : Symbol(Uint8ClampedArray, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>from : Symbol(Uint8ClampedArrayConstructor.from, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >obj : Symbol(obj, Decl(typedArrays.ts, 123, 38)) >mapFn : Symbol(mapFn, Decl(typedArrays.ts, 123, 60)) >thisArg : Symbol(thisArg, Decl(typedArrays.ts, 123, 98)) diff --git a/tests/baselines/reference/typeofOperatorWithStringType.symbols b/tests/baselines/reference/typeofOperatorWithStringType.symbols index 6da22469f83..090e0958e60 100644 --- a/tests/baselines/reference/typeofOperatorWithStringType.symbols +++ b/tests/baselines/reference/typeofOperatorWithStringType.symbols @@ -88,9 +88,9 @@ var ResultIsString11 = typeof (STRING + STRING); var ResultIsString12 = typeof STRING.charAt(0); >ResultIsString12 : Symbol(ResultIsString12, Decl(typeofOperatorWithStringType.ts, 32, 3)) ->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) // multiple typeof operators var ResultIsString13 = typeof typeof STRING; diff --git a/tests/baselines/reference/umdDependencyComment2.js b/tests/baselines/reference/umdDependencyComment2.js index cae34631517..f063df77308 100644 --- a/tests/baselines/reference/umdDependencyComment2.js +++ b/tests/baselines/reference/umdDependencyComment2.js @@ -7,14 +7,14 @@ m1.f(); //// [umdDependencyComment2.js] /// -(function (deps, factory) { +(function (factory) { if (typeof module === 'object' && typeof module.exports === 'object') { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === 'function' && define.amd) { - define(deps, factory); + define(["require", "exports", "bar", "m2"], factory); } -})(["require", "exports", "bar", "m2"], function (require, exports) { +})(function (require, exports) { var m1 = require("m2"); m1.f(); }); diff --git a/tests/baselines/reference/umdDependencyCommentName1.js b/tests/baselines/reference/umdDependencyCommentName1.js index 6cb87eb45f5..763e0523272 100644 --- a/tests/baselines/reference/umdDependencyCommentName1.js +++ b/tests/baselines/reference/umdDependencyCommentName1.js @@ -7,14 +7,14 @@ m1.f(); //// [umdDependencyCommentName1.js] /// -(function (deps, factory) { +(function (factory) { if (typeof module === 'object' && typeof module.exports === 'object') { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === 'function' && define.amd) { - define(deps, factory); + define(["require", "exports", "bar", "m2"], factory); } -})(["require", "exports", "bar", "m2"], function (require, exports, b) { +})(function (require, exports, b) { var m1 = require("m2"); m1.f(); }); diff --git a/tests/baselines/reference/umdDependencyCommentName2.js b/tests/baselines/reference/umdDependencyCommentName2.js index d474454936d..f749e4cc22d 100644 --- a/tests/baselines/reference/umdDependencyCommentName2.js +++ b/tests/baselines/reference/umdDependencyCommentName2.js @@ -11,14 +11,14 @@ m1.f(); /// /// /// -(function (deps, factory) { +(function (factory) { if (typeof module === 'object' && typeof module.exports === 'object') { var v = factory(require, exports); if (v !== undefined) module.exports = v; } else if (typeof define === 'function' && define.amd) { - define(deps, factory); + define(["require", "exports", "bar", "goo", "foo", "m2"], factory); } -})(["require", "exports", "bar", "goo", "foo", "m2"], function (require, exports, b, c) { +})(function (require, exports, b, c) { var m1 = require("m2"); m1.f(); }); diff --git a/tests/baselines/reference/undefinedAssignableToEveryType.symbols b/tests/baselines/reference/undefinedAssignableToEveryType.symbols index da2b3ff7c83..f511231515e 100644 --- a/tests/baselines/reference/undefinedAssignableToEveryType.symbols +++ b/tests/baselines/reference/undefinedAssignableToEveryType.symbols @@ -41,7 +41,7 @@ var d: boolean = undefined; var e: Date = undefined; >e : Symbol(e, Decl(undefinedAssignableToEveryType.ts, 15, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >undefined : Symbol(undefined) var f: any = undefined; @@ -54,7 +54,7 @@ var g: void = undefined; var h: Object = undefined; >h : Symbol(h, Decl(undefinedAssignableToEveryType.ts, 18, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >undefined : Symbol(undefined) var i: {} = undefined; @@ -67,7 +67,7 @@ var j: () => {} = undefined; var k: Function = undefined; >k : Symbol(k, Decl(undefinedAssignableToEveryType.ts, 21, 3)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >undefined : Symbol(undefined) var l: (x: number) => string = undefined; @@ -106,12 +106,12 @@ var o: (x: T) => T = undefined; var p: Number = undefined; >p : Symbol(p, Decl(undefinedAssignableToEveryType.ts, 29, 3)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >undefined : Symbol(undefined) var q: String = undefined; >q : Symbol(q, Decl(undefinedAssignableToEveryType.ts, 30, 3)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >undefined : Symbol(undefined) function foo(x: T, y: U, z: V) { @@ -119,7 +119,7 @@ function foo(x: T, y: U, z: V) { >T : Symbol(T, Decl(undefinedAssignableToEveryType.ts, 32, 13)) >U : Symbol(U, Decl(undefinedAssignableToEveryType.ts, 32, 15)) >V : Symbol(V, Decl(undefinedAssignableToEveryType.ts, 32, 18)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(undefinedAssignableToEveryType.ts, 32, 35)) >T : Symbol(T, Decl(undefinedAssignableToEveryType.ts, 32, 13)) >y : Symbol(y, Decl(undefinedAssignableToEveryType.ts, 32, 40)) diff --git a/tests/baselines/reference/undefinedIsSubtypeOfEverything.symbols b/tests/baselines/reference/undefinedIsSubtypeOfEverything.symbols index 1b786e9e524..de4f6f0da05 100644 --- a/tests/baselines/reference/undefinedIsSubtypeOfEverything.symbols +++ b/tests/baselines/reference/undefinedIsSubtypeOfEverything.symbols @@ -40,7 +40,7 @@ class D1A extends Base { foo: String; >foo : Symbol(foo, Decl(undefinedIsSubtypeOfEverything.ts, 18, 24)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } @@ -58,7 +58,7 @@ class D2A extends Base { foo: Number; >foo : Symbol(foo, Decl(undefinedIsSubtypeOfEverything.ts, 27, 24)) ->Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11)) +>Number : Symbol(Number, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } @@ -76,7 +76,7 @@ class D3A extends Base { foo: Boolean; >foo : Symbol(foo, Decl(undefinedIsSubtypeOfEverything.ts, 36, 24)) ->Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11)) +>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } @@ -86,7 +86,7 @@ class D4 extends Base { foo: RegExp; >foo : Symbol(foo, Decl(undefinedIsSubtypeOfEverything.ts, 41, 23)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } class D5 extends Base { @@ -95,7 +95,7 @@ class D5 extends Base { foo: Date; >foo : Symbol(foo, Decl(undefinedIsSubtypeOfEverything.ts, 45, 23)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } @@ -235,7 +235,7 @@ class D16 extends Base { foo: Object; >foo : Symbol(foo, Decl(undefinedIsSubtypeOfEverything.ts, 112, 24)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } diff --git a/tests/baselines/reference/underscoreMapFirst.types b/tests/baselines/reference/underscoreMapFirst.types index 4de320604bd..60cbcccda2b 100644 --- a/tests/baselines/reference/underscoreMapFirst.types +++ b/tests/baselines/reference/underscoreMapFirst.types @@ -124,7 +124,7 @@ class MyView extends View { >this.model.get("data") : any >this.model.get : any >this.model : any ->this : MyView +>this : this >model : any >get : any >"data" : string diff --git a/tests/baselines/reference/underscoreTest1.symbols b/tests/baselines/reference/underscoreTest1.symbols index 1ba7c97d331..9de509de417 100644 --- a/tests/baselines/reference/underscoreTest1.symbols +++ b/tests/baselines/reference/underscoreTest1.symbols @@ -14,9 +14,9 @@ _.each([1, 2, 3], (num) => alert(num.toString())); >each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 5, 19)) >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14)) ->num.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>num.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 5, 19)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(value.toString())); >_.each : Symbol(Underscore.Static.each, Decl(underscoreTest1_underscore.ts, 395, 43), Decl(underscoreTest1_underscore.ts, 397, 77)) @@ -28,9 +28,9 @@ _.each({ one: 1, two: 2, three: 3 }, (value: number, key?: string) => alert(valu >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 6, 38)) >key : Symbol(key, Decl(underscoreTest1_underscoreTests.ts, 6, 52)) >alert : Symbol(alert, Decl(underscoreTest1_underscoreTests.ts, 2, 14)) ->value.toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>value.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) >value : Symbol(value, Decl(underscoreTest1_underscoreTests.ts, 6, 38)) ->toString : Symbol(Number.toString, Decl(lib.d.ts, 458, 18)) +>toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) _.map([1, 2, 3], (num) => num * 3); >_.map : Symbol(Underscore.Static.map, Decl(underscoreTest1_underscore.ts, 400, 90), Decl(underscoreTest1_underscore.ts, 402, 75)) @@ -71,9 +71,9 @@ var flat = _.reduceRight(list, (a, b) => a.concat(b), []); >list : Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 13, 3)) >a : Symbol(a, Decl(underscoreTest1_underscoreTests.ts, 14, 32)) >b : Symbol(b, Decl(underscoreTest1_underscoreTests.ts, 14, 34)) ->a.concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>a.concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >a : Symbol(a, Decl(underscoreTest1_underscoreTests.ts, 14, 32)) ->concat : Symbol(Array.concat, Decl(lib.d.ts, 1025, 13), Decl(lib.d.ts, 1030, 46)) +>concat : Symbol(Array.concat, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >b : Symbol(b, Decl(underscoreTest1_underscoreTests.ts, 14, 34)) var even = _.find([1, 2, 3, 4, 5, 6], (num) => num % 2 == 0); @@ -182,9 +182,9 @@ _.sortBy([1, 2, 3, 4, 5, 6], (num) => Math.sin(num)); >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) >sortBy : Symbol(Underscore.Static.sortBy, Decl(underscoreTest1_underscore.ts, 473, 83), Decl(underscoreTest1_underscore.ts, 475, 77), Decl(underscoreTest1_underscore.ts, 476, 87), Decl(underscoreTest1_underscore.ts, 477, 56)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 41, 30)) ->Math.sin : Symbol(Math.sin, Decl(lib.d.ts, 615, 29)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->sin : Symbol(Math.sin, Decl(lib.d.ts, 615, 29)) +>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, --, --)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 41, 30)) @@ -196,9 +196,9 @@ _([1.3, 2.1, 2.4]).groupBy((e: number, i?: number, list?: number[]) => Math.floo >e : Symbol(e, Decl(underscoreTest1_underscoreTests.ts, 45, 28)) >i : Symbol(i, Decl(underscoreTest1_underscoreTests.ts, 45, 38)) >list : Symbol(list, Decl(underscoreTest1_underscoreTests.ts, 45, 50)) ->Math.floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27)) +>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, --, --)) >e : Symbol(e, Decl(underscoreTest1_underscoreTests.ts, 45, 28)) _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num)); @@ -206,9 +206,9 @@ _.groupBy([1.3, 2.1, 2.4], (num: number) => Math.floor(num)); >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) >groupBy : Symbol(Underscore.Static.groupBy, Decl(underscoreTest1_underscore.ts, 478, 66), Decl(underscoreTest1_underscore.ts, 480, 91), Decl(underscoreTest1_underscore.ts, 481, 101), Decl(underscoreTest1_underscore.ts, 482, 69)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 46, 28)) ->Math.floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27)) ->Math : Symbol(Math, Decl(lib.d.ts, 522, 1), Decl(lib.d.ts, 633, 11)) ->floor : Symbol(Math.floor, Decl(lib.d.ts, 582, 27)) +>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, --, --)) >num : Symbol(num, Decl(underscoreTest1_underscoreTests.ts, 46, 28)) _.groupBy(['one', 'two', 'three'], 'length'); @@ -437,7 +437,7 @@ var log = _.bind((message?: string, ...rest: string[]) => { }, Date); >bind : Symbol(Underscore.Static.bind, Decl(underscoreTest1_underscore.ts, 548, 68), Decl(underscoreTest1_underscore.ts, 550, 58)) >message : Symbol(message, Decl(underscoreTest1_underscoreTests.ts, 108, 18)) >rest : Symbol(rest, Decl(underscoreTest1_underscoreTests.ts, 108, 35)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) _.delay(log, 1000, 'logged later'); >_.delay : Symbol(Underscore.Static.delay, Decl(underscoreTest1_underscore.ts, 557, 73)) @@ -510,9 +510,9 @@ var renderNotes = _.after(notes.length, render); >_.after : Symbol(Underscore.Static.after, Decl(underscoreTest1_underscore.ts, 567, 45)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) >after : Symbol(Underscore.Static.after, Decl(underscoreTest1_underscore.ts, 567, 45)) ->notes.length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>notes.length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >notes : Symbol(notes, Decl(underscoreTest1_underscoreTests.ts, 126, 3)) ->length : Symbol(Array.length, Decl(lib.d.ts, 1007, 20)) +>length : Symbol(Array.length, Decl(lib.d.ts, --, --)) >render : Symbol(render, Decl(underscoreTest1_underscoreTests.ts, 127, 3)) _.each(notes, (note) => note.asyncSave({ success: renderNotes })); @@ -771,7 +771,7 @@ _.isFinite(-Infinity); >_.isFinite : Symbol(Underscore.Static.isFinite, Decl(underscoreTest1_underscore.ts, 609, 39)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) >isFinite : Symbol(Underscore.Static.isFinite, Decl(underscoreTest1_underscore.ts, 609, 39)) ->Infinity : Symbol(Infinity, Decl(lib.d.ts, 22, 11)) +>Infinity : Symbol(Infinity, Decl(lib.d.ts, --, --)) _.isBoolean(null); >_.isBoolean : Symbol(Underscore.Static.isBoolean, Decl(underscoreTest1_underscore.ts, 610, 39)) @@ -782,7 +782,7 @@ _.isDate(new Date()); >_.isDate : Symbol(Underscore.Static.isDate, Decl(underscoreTest1_underscore.ts, 611, 40)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) >isDate : Symbol(Underscore.Static.isDate, Decl(underscoreTest1_underscore.ts, 611, 40)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) _.isRegExp(/moe/); >_.isRegExp : Symbol(Underscore.Static.isRegExp, Decl(underscoreTest1_underscore.ts, 612, 37)) @@ -793,10 +793,10 @@ _.isNaN(NaN); >_.isNaN : Symbol(Underscore.Static.isNaN, Decl(underscoreTest1_underscore.ts, 613, 39)) >_ : Symbol(_, Decl(underscoreTest1_underscore.ts, 645, 11)) >isNaN : Symbol(Underscore.Static.isNaN, Decl(underscoreTest1_underscore.ts, 613, 39)) ->NaN : Symbol(NaN, Decl(lib.d.ts, 21, 11)) +>NaN : Symbol(NaN, Decl(lib.d.ts, --, --)) isNaN(undefined); ->isNaN : Symbol(isNaN, Decl(lib.d.ts, 43, 52)) +>isNaN : Symbol(isNaN, Decl(lib.d.ts, --, --)) >undefined : Symbol(undefined) _.isNaN(undefined); @@ -1008,7 +1008,7 @@ interface Tuple2 extends Array { >Tuple2 : Symbol(Tuple2, Decl(underscoreTest1_underscore.ts, 10, 1)) >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 12, 17)) >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 12, 20)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) 0: T0; >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 12, 17)) @@ -1022,7 +1022,7 @@ interface Tuple3 extends Array { >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 17, 17)) >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 17, 20)) >T2 : Symbol(T2, Decl(underscoreTest1_underscore.ts, 17, 24)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) 0: T0; >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 17, 17)) @@ -1040,7 +1040,7 @@ interface Tuple4 extends Array { >T1 : Symbol(T1, Decl(underscoreTest1_underscore.ts, 23, 20)) >T2 : Symbol(T2, Decl(underscoreTest1_underscore.ts, 23, 24)) >T3 : Symbol(T3, Decl(underscoreTest1_underscore.ts, 23, 28)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) 0: T0; >T0 : Symbol(T0, Decl(underscoreTest1_underscore.ts, 23, 17)) @@ -1173,7 +1173,7 @@ module Underscore { export interface WrappedFunction extends WrappedObject { >WrappedFunction : Symbol(WrappedFunction, Decl(underscoreTest1_underscore.ts, 62, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >WrappedObject : Symbol(WrappedObject, Decl(underscoreTest1_underscore.ts, 30, 19)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37)) @@ -1186,7 +1186,7 @@ module Underscore { >bind : Symbol(bind, Decl(underscoreTest1_underscore.ts, 64, 83), Decl(underscoreTest1_underscore.ts, 65, 29)) >object : Symbol(object, Decl(underscoreTest1_underscore.ts, 66, 13)) >args : Symbol(args, Decl(underscoreTest1_underscore.ts, 66, 25)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) bindAll(...methodNames: string[]): T; >bindAll : Symbol(bindAll, Decl(underscoreTest1_underscore.ts, 66, 52)) @@ -1196,12 +1196,12 @@ module Underscore { partial(...args: any[]): Function; >partial : Symbol(partial, Decl(underscoreTest1_underscore.ts, 67, 45)) >args : Symbol(args, Decl(underscoreTest1_underscore.ts, 68, 16)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) memoize(hashFunction?: Function): T; >memoize : Symbol(memoize, Decl(underscoreTest1_underscore.ts, 68, 42)) >hashFunction : Symbol(hashFunction, Decl(underscoreTest1_underscore.ts, 69, 16)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 64, 37)) delay(wait: number, ...args: any[]): number; @@ -1239,15 +1239,15 @@ module Underscore { compose(...funcs: Function[]): Function; >compose : Symbol(compose, Decl(underscoreTest1_underscore.ts, 75, 59)) >funcs : Symbol(funcs, Decl(underscoreTest1_underscore.ts, 76, 16)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) } export interface WrappedArray extends WrappedObject> { >WrappedArray : Symbol(WrappedArray, Decl(underscoreTest1_underscore.ts, 77, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) >WrappedObject : Symbol(WrappedObject, Decl(underscoreTest1_underscore.ts, 30, 19)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) each(iterator: Iterator, context?: any): void; @@ -1434,13 +1434,13 @@ module Underscore { where(properties: Object): T[]; >where : Symbol(where, Decl(underscoreTest1_underscore.ts, 97, 67)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 98, 14)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) findWhere(properties: Object): T; >findWhere : Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 98, 39)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 99, 18)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 79, 34)) reject(iterator: Iterator, context?: any): T[]; @@ -1973,13 +1973,13 @@ module Underscore { where(properties: Object): T[]; >where : Symbol(where, Decl(underscoreTest1_underscore.ts, 180, 67)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 181, 14)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) findWhere(properties: Object): T; >findWhere : Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 181, 39)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 182, 18)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 162, 39)) reject(iterator: Iterator, context?: any): T[]; @@ -2251,7 +2251,7 @@ module Underscore { >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) each(iterator: Iterator, context?: any): ChainedObject; @@ -2456,14 +2456,14 @@ module Underscore { where(properties: Object): ChainedArray; >where : Symbol(where, Decl(underscoreTest1_underscore.ts, 256, 79)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 257, 14)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) findWhere(properties: Object): ChainedObject; >findWhere : Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 257, 51)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 258, 18)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 238, 34)) @@ -3107,14 +3107,14 @@ module Underscore { where(properties: Object): ChainedArray; >where : Symbol(where, Decl(underscoreTest1_underscore.ts, 347, 79)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 348, 14)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >ChainedArray : Symbol(ChainedArray, Decl(underscoreTest1_underscore.ts, 236, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) findWhere(properties: Object): ChainedObject; >findWhere : Symbol(findWhere, Decl(underscoreTest1_underscore.ts, 348, 51)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 349, 18)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >ChainedObject : Symbol(ChainedObject, Decl(underscoreTest1_underscore.ts, 203, 5)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 329, 39)) @@ -3301,15 +3301,15 @@ module Underscore { evaluate?: RegExp; >evaluate : Symbol(evaluate, Decl(underscoreTest1_underscore.ts, 380, 39)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) interpolate?: RegExp; >interpolate : Symbol(interpolate, Decl(underscoreTest1_underscore.ts, 381, 26)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) escape?: RegExp; >escape : Symbol(escape, Decl(underscoreTest1_underscore.ts, 382, 29)) ->RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11)) +>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) variable?: string; >variable : Symbol(variable, Decl(underscoreTest1_underscore.ts, 383, 24)) @@ -3335,7 +3335,7 @@ module Underscore { (func: T): WrappedFunction; >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 390, 9)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 390, 29)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 390, 9)) >WrappedFunction : Symbol(WrappedFunction, Decl(underscoreTest1_underscore.ts, 62, 5)) @@ -3867,7 +3867,7 @@ module Underscore { >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 439, 17)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 439, 27)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 439, 14)) where(list: Dictionary, properties: Object): T[]; @@ -3877,7 +3877,7 @@ module Underscore { >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 440, 14)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 440, 37)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 440, 14)) findWhere(list: T[], properties: Object): T; @@ -3886,7 +3886,7 @@ module Underscore { >list : Symbol(list, Decl(underscoreTest1_underscore.ts, 442, 21)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 442, 18)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 442, 31)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 442, 18)) findWhere(list: Dictionary, properties: Object): T; @@ -3896,7 +3896,7 @@ module Underscore { >Dictionary : Symbol(Dictionary, Decl(underscoreTest1_underscore.ts, 0, 0)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 443, 18)) >properties : Symbol(properties, Decl(underscoreTest1_underscore.ts, 443, 41)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 443, 18)) reject(list: T[], iterator: Iterator, context?: any): T[]; @@ -4570,7 +4570,7 @@ module Underscore { bind(func: T, object: any): T; >bind : Symbol(bind, Decl(underscoreTest1_underscore.ts, 548, 68), Decl(underscoreTest1_underscore.ts, 550, 58)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 550, 13)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 550, 33)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 550, 13)) >object : Symbol(object, Decl(underscoreTest1_underscore.ts, 550, 41)) @@ -4579,10 +4579,10 @@ module Underscore { bind(func: Function, object: any, ...args: any[]): Function; >bind : Symbol(bind, Decl(underscoreTest1_underscore.ts, 548, 68), Decl(underscoreTest1_underscore.ts, 550, 58)) >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 551, 13)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >object : Symbol(object, Decl(underscoreTest1_underscore.ts, 551, 28)) >args : Symbol(args, Decl(underscoreTest1_underscore.ts, 551, 41)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) bindAll(object: T, ...methodNames: string[]): T; >bindAll : Symbol(bindAll, Decl(underscoreTest1_underscore.ts, 551, 68)) @@ -4595,37 +4595,37 @@ module Underscore { partial(func: Function, ...args: any[]): Function; >partial : Symbol(partial, Decl(underscoreTest1_underscore.ts, 553, 59)) >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 555, 16)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >args : Symbol(args, Decl(underscoreTest1_underscore.ts, 555, 31)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) memoize(func: T, hashFunction?: Function): T; >memoize : Symbol(memoize, Decl(underscoreTest1_underscore.ts, 555, 58)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 557, 16)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 557, 36)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 557, 16)) >hashFunction : Symbol(hashFunction, Decl(underscoreTest1_underscore.ts, 557, 44)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 557, 16)) delay(func: Function, wait: number, ...args: any[]): number; >delay : Symbol(delay, Decl(underscoreTest1_underscore.ts, 557, 73)) >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 559, 14)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >wait : Symbol(wait, Decl(underscoreTest1_underscore.ts, 559, 29)) >args : Symbol(args, Decl(underscoreTest1_underscore.ts, 559, 43)) defer(func: Function, ...args: any[]): number; >defer : Symbol(defer, Decl(underscoreTest1_underscore.ts, 559, 68)) >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 561, 14)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >args : Symbol(args, Decl(underscoreTest1_underscore.ts, 561, 29)) throttle(func: T, wait: number): T; >throttle : Symbol(throttle, Decl(underscoreTest1_underscore.ts, 561, 54)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 563, 17)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 563, 37)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 563, 17)) >wait : Symbol(wait, Decl(underscoreTest1_underscore.ts, 563, 45)) @@ -4634,7 +4634,7 @@ module Underscore { debounce(func: T, wait: number, immediate?: boolean): T; >debounce : Symbol(debounce, Decl(underscoreTest1_underscore.ts, 563, 63)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 565, 17)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 565, 37)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 565, 17)) >wait : Symbol(wait, Decl(underscoreTest1_underscore.ts, 565, 45)) @@ -4644,7 +4644,7 @@ module Underscore { once(func: T): T; >once : Symbol(once, Decl(underscoreTest1_underscore.ts, 565, 84)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 567, 13)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 567, 33)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 567, 13)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 567, 13)) @@ -4652,7 +4652,7 @@ module Underscore { after(count: number, func: T): T; >after : Symbol(after, Decl(underscoreTest1_underscore.ts, 567, 45)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 569, 14)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >count : Symbol(count, Decl(underscoreTest1_underscore.ts, 569, 34)) >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 569, 48)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 569, 14)) @@ -4661,7 +4661,7 @@ module Underscore { wrap(func: T, wrapper: (func: T, ...args: any[]) => any): T; >wrap : Symbol(wrap, Decl(underscoreTest1_underscore.ts, 569, 61)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 571, 13)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >func : Symbol(func, Decl(underscoreTest1_underscore.ts, 571, 33)) >T : Symbol(T, Decl(underscoreTest1_underscore.ts, 571, 13)) >wrapper : Symbol(wrapper, Decl(underscoreTest1_underscore.ts, 571, 41)) @@ -4673,8 +4673,8 @@ module Underscore { compose(...funcs: Function[]): Function; >compose : Symbol(compose, Decl(underscoreTest1_underscore.ts, 571, 88)) >funcs : Symbol(funcs, Decl(underscoreTest1_underscore.ts, 573, 16)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) ->Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) +>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) keys(object: any): string[]; >keys : Symbol(keys, Decl(underscoreTest1_underscore.ts, 573, 48)) diff --git a/tests/baselines/reference/unionTypeCallSignatures2.symbols b/tests/baselines/reference/unionTypeCallSignatures2.symbols index 35ba9464df0..32ce4c352b8 100644 --- a/tests/baselines/reference/unionTypeCallSignatures2.symbols +++ b/tests/baselines/reference/unionTypeCallSignatures2.symbols @@ -11,7 +11,7 @@ interface A { (x: Date): void; >x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 3, 5)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) (x: T[]): T[]; >T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 4, 5)) @@ -31,7 +31,7 @@ interface B { (x: Date): void; >x : Symbol(x, Decl(unionTypeCallSignatures2.ts, 10, 5)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) (x: T[]): T[]; >T : Symbol(T, Decl(unionTypeCallSignatures2.ts, 11, 5)) diff --git a/tests/baselines/reference/unionTypeIndexSignature.symbols b/tests/baselines/reference/unionTypeIndexSignature.symbols index e0228308c16..7295b860f3f 100644 --- a/tests/baselines/reference/unionTypeIndexSignature.symbols +++ b/tests/baselines/reference/unionTypeIndexSignature.symbols @@ -1,7 +1,7 @@ === tests/cases/conformance/types/union/unionTypeIndexSignature.ts === var numOrDate: number | Date; >numOrDate : Symbol(numOrDate, Decl(unionTypeIndexSignature.ts, 0, 3)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var anyVar: number; >anyVar : Symbol(anyVar, Decl(unionTypeIndexSignature.ts, 1, 3)) @@ -13,7 +13,7 @@ var unionOfDifferentReturnType: { [a: string]: number; } | { [a: string]: Date; >unionOfDifferentReturnType : Symbol(unionOfDifferentReturnType, Decl(unionTypeIndexSignature.ts, 6, 3)) >a : Symbol(a, Decl(unionTypeIndexSignature.ts, 6, 35)) >a : Symbol(a, Decl(unionTypeIndexSignature.ts, 6, 62)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) numOrDate = unionOfDifferentReturnType["hello"]; // number | Date >numOrDate : Symbol(numOrDate, Decl(unionTypeIndexSignature.ts, 0, 3)) @@ -41,7 +41,7 @@ var unionOfDifferentReturnType1: { [a: number]: number; } | { [a: number]: Date; >unionOfDifferentReturnType1 : Symbol(unionOfDifferentReturnType1, Decl(unionTypeIndexSignature.ts, 16, 3)) >a : Symbol(a, Decl(unionTypeIndexSignature.ts, 16, 36)) >a : Symbol(a, Decl(unionTypeIndexSignature.ts, 16, 63)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) numOrDate = unionOfDifferentReturnType1["hello"]; // any >numOrDate : Symbol(numOrDate, Decl(unionTypeIndexSignature.ts, 0, 3)) diff --git a/tests/baselines/reference/validBooleanAssignments.symbols b/tests/baselines/reference/validBooleanAssignments.symbols index a13a02a09cc..b7ba6be03c1 100644 --- a/tests/baselines/reference/validBooleanAssignments.symbols +++ b/tests/baselines/reference/validBooleanAssignments.symbols @@ -8,12 +8,12 @@ var a: any = x; var b: Object = x; >b : Symbol(b, Decl(validBooleanAssignments.ts, 3, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(validBooleanAssignments.ts, 0, 3)) var c: Boolean = x; >c : Symbol(c, Decl(validBooleanAssignments.ts, 4, 3)) ->Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11)) +>Boolean : Symbol(Boolean, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(validBooleanAssignments.ts, 0, 3)) var d: boolean = x; diff --git a/tests/baselines/reference/validMultipleVariableDeclarations.symbols b/tests/baselines/reference/validMultipleVariableDeclarations.symbols index 467c061c6fa..1c3a1feb75c 100644 --- a/tests/baselines/reference/validMultipleVariableDeclarations.symbols +++ b/tests/baselines/reference/validMultipleVariableDeclarations.symbols @@ -110,7 +110,7 @@ var a: string[] = []; var a = new Array(); >a : Symbol(a, Decl(validMultipleVariableDeclarations.ts, 32, 3), Decl(validMultipleVariableDeclarations.ts, 33, 3), Decl(validMultipleVariableDeclarations.ts, 34, 3), Decl(validMultipleVariableDeclarations.ts, 35, 3), Decl(validMultipleVariableDeclarations.ts, 36, 3), Decl(validMultipleVariableDeclarations.ts, 37, 3)) ->Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11)) +>Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) var a: typeof a; >a : Symbol(a, Decl(validMultipleVariableDeclarations.ts, 32, 3), Decl(validMultipleVariableDeclarations.ts, 33, 3), Decl(validMultipleVariableDeclarations.ts, 34, 3), Decl(validMultipleVariableDeclarations.ts, 35, 3), Decl(validMultipleVariableDeclarations.ts, 36, 3), Decl(validMultipleVariableDeclarations.ts, 37, 3)) diff --git a/tests/baselines/reference/validNumberAssignments.symbols b/tests/baselines/reference/validNumberAssignments.symbols index 44ab24e33e0..7cb763bc89b 100644 --- a/tests/baselines/reference/validNumberAssignments.symbols +++ b/tests/baselines/reference/validNumberAssignments.symbols @@ -8,7 +8,7 @@ var a: any = x; var b: Object = x; >b : Symbol(b, Decl(validNumberAssignments.ts, 3, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(validNumberAssignments.ts, 0, 3)) var c: number = x; diff --git a/tests/baselines/reference/validStringAssignments.symbols b/tests/baselines/reference/validStringAssignments.symbols index 750dadefebd..bb24a6c1574 100644 --- a/tests/baselines/reference/validStringAssignments.symbols +++ b/tests/baselines/reference/validStringAssignments.symbols @@ -8,7 +8,7 @@ var a: any = x; var b: Object = x; >b : Symbol(b, Decl(validStringAssignments.ts, 3, 3)) ->Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11)) +>Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(validStringAssignments.ts, 0, 3)) var c: string = x; @@ -17,6 +17,6 @@ var c: string = x; var d: String = x; >d : Symbol(d, Decl(validStringAssignments.ts, 5, 3)) ->String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11)) +>String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(validStringAssignments.ts, 0, 3)) diff --git a/tests/baselines/reference/validUseOfThisInSuper.types b/tests/baselines/reference/validUseOfThisInSuper.types index d7c882496e2..81b911dfdc9 100644 --- a/tests/baselines/reference/validUseOfThisInSuper.types +++ b/tests/baselines/reference/validUseOfThisInSuper.types @@ -15,9 +15,9 @@ class Super extends Base { super((() => this)()); // ok since this is not the case: The constructor declares parameter properties or the containing class declares instance member variables with initializers. >super((() => this)()) : void >super : typeof Base ->(() => this)() : Super ->(() => this) : () => Super ->() => this : () => Super ->this : Super +>(() => this)() : this +>(() => this) : () => this +>() => this : () => this +>this : this } } diff --git a/tests/baselines/reference/varArgsOnConstructorTypes.types b/tests/baselines/reference/varArgsOnConstructorTypes.types index 5ac9babd426..44987506101 100644 --- a/tests/baselines/reference/varArgsOnConstructorTypes.types +++ b/tests/baselines/reference/varArgsOnConstructorTypes.types @@ -28,14 +28,14 @@ export class B extends A { this.p1 = element; >this.p1 = element : any >this.p1 : number ->this : B +>this : this >p1 : number >element : any this.p2 = url; >this.p2 = url : string >this.p2 : string ->this : B +>this : this >p2 : string >url : string } diff --git a/tests/baselines/reference/vardecl.symbols b/tests/baselines/reference/vardecl.symbols index 979790877c1..0860fc19500 100644 --- a/tests/baselines/reference/vardecl.symbols +++ b/tests/baselines/reference/vardecl.symbols @@ -41,9 +41,9 @@ var complicatedArrayVar: { x: number; y: string; }[] ; >y : Symbol(y, Decl(vardecl.ts, 18, 37)) complicatedArrayVar.push({ x: 30, y : 'hello world' }); ->complicatedArrayVar.push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>complicatedArrayVar.push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >complicatedArrayVar : Symbol(complicatedArrayVar, Decl(vardecl.ts, 18, 3)) ->push : Symbol(Array.push, Decl(lib.d.ts, 1016, 29)) +>push : Symbol(Array.push, Decl(lib.d.ts, --, --)) >x : Symbol(x, Decl(vardecl.ts, 19, 26)) >y : Symbol(y, Decl(vardecl.ts, 19, 33)) diff --git a/tests/baselines/reference/voidOperatorWithStringType.symbols b/tests/baselines/reference/voidOperatorWithStringType.symbols index ab834bf1243..64fb0e600e8 100644 --- a/tests/baselines/reference/voidOperatorWithStringType.symbols +++ b/tests/baselines/reference/voidOperatorWithStringType.symbols @@ -88,9 +88,9 @@ var ResultIsAny11 = void (STRING + STRING); var ResultIsAny12 = void STRING.charAt(0); >ResultIsAny12 : Symbol(ResultIsAny12, Decl(voidOperatorWithStringType.ts, 32, 3)) ->STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>STRING.charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) >STRING : Symbol(STRING, Decl(voidOperatorWithStringType.ts, 1, 3)) ->charAt : Symbol(String.charAt, Decl(lib.d.ts, 279, 23)) +>charAt : Symbol(String.charAt, Decl(lib.d.ts, --, --)) // multiple void operators var ResultIsAny13 = void void STRING; diff --git a/tests/baselines/reference/wrappedAndRecursiveConstraints.symbols b/tests/baselines/reference/wrappedAndRecursiveConstraints.symbols index 5f3f2d6f854..b0128b37797 100644 --- a/tests/baselines/reference/wrappedAndRecursiveConstraints.symbols +++ b/tests/baselines/reference/wrappedAndRecursiveConstraints.symbols @@ -4,7 +4,7 @@ class C { >C : Symbol(C, Decl(wrappedAndRecursiveConstraints.ts, 0, 0)) >T : Symbol(T, Decl(wrappedAndRecursiveConstraints.ts, 2, 8)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) constructor(public data: T) { } >data : Symbol(data, Decl(wrappedAndRecursiveConstraints.ts, 3, 16)) @@ -24,7 +24,7 @@ class C { interface Foo extends Date { >Foo : Symbol(Foo, Decl(wrappedAndRecursiveConstraints.ts, 7, 1)) ->Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11)) +>Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) foo: string; >foo : Symbol(foo, Decl(wrappedAndRecursiveConstraints.ts, 9, 28)) diff --git a/tests/cases/compiler/asiAbstract.ts b/tests/cases/compiler/asiAbstract.ts new file mode 100644 index 00000000000..f9f36b12001 --- /dev/null +++ b/tests/cases/compiler/asiAbstract.ts @@ -0,0 +1,14 @@ +abstract +class NonAbstractClass { + abstract s(); +} + +class C2 { + abstract + nonAbstractFunction() { + } +} + +class C3 { + abstract +} diff --git a/tests/cases/compiler/asiPublicPrivateProtected.ts b/tests/cases/compiler/asiPublicPrivateProtected.ts new file mode 100644 index 00000000000..4ccd4c1c01b --- /dev/null +++ b/tests/cases/compiler/asiPublicPrivateProtected.ts @@ -0,0 +1,39 @@ +public +class NonPublicClass { + public s() { + } +} + +class NonPublicClass2 { + public + private nonPublicFunction() { + } +} +private +class NonPrivateClass { + private s() { + } +} + +class NonPrivateClass2 { + private + public nonPrivateFunction() { + } +} +protected +class NonProtectedClass { + protected s() { + } +} + +class NonProtectedClass2 { + protected + public nonProtectedFunction() { + } +} + +class ClassWithThreeMembers { + public + private + protected +} diff --git a/tests/cases/compiler/constIndexedAccess.ts b/tests/cases/compiler/constIndexedAccess.ts new file mode 100644 index 00000000000..d71a3cdb9f4 --- /dev/null +++ b/tests/cases/compiler/constIndexedAccess.ts @@ -0,0 +1,29 @@ + +const enum numbers { + zero, + one +} + +interface indexAccess { + 0: string; + 1: number; +} + +let test: indexAccess; + +let s = test[0]; +let n = test[1]; + +let s1 = test[numbers.zero]; +let n1 = test[numbers.one]; + +let s2 = test[numbers["zero"]]; +let n2 = test[numbers["one"]]; + +enum numbersNotConst { + zero, + one +} + +let s3 = test[numbersNotConst.zero]; +let n3 = test[numbersNotConst.one]; diff --git a/tests/cases/compiler/destructuringWithGenericParameter.ts b/tests/cases/compiler/destructuringWithGenericParameter.ts new file mode 100644 index 00000000000..99b5bfade36 --- /dev/null +++ b/tests/cases/compiler/destructuringWithGenericParameter.ts @@ -0,0 +1,13 @@ +class GenericClass { + payload: T; +} + +var genericObject = new GenericClass<{ greeting: string }>(); + +function genericFunction(object: GenericClass, callback: (payload: T) => void) { + callback(object.payload); +} + +genericFunction(genericObject, ({greeting}) => { + var s = greeting.toLocaleLowerCase(); // Greeting should be of type string +}); diff --git a/tests/cases/compiler/es5andes6module.ts b/tests/cases/compiler/es5andes6module.ts new file mode 100644 index 00000000000..0fbff3c23d2 --- /dev/null +++ b/tests/cases/compiler/es5andes6module.ts @@ -0,0 +1,17 @@ +// @target: ES5 +// @sourcemap: false +// @declaration: false +// @module: es6 + +export default class A +{ + constructor () + { + + } + + public B() + { + return 42; + } +} diff --git a/tests/cases/compiler/es6modulekind.ts b/tests/cases/compiler/es6modulekind.ts new file mode 100644 index 00000000000..0722e1690a3 --- /dev/null +++ b/tests/cases/compiler/es6modulekind.ts @@ -0,0 +1,17 @@ +// @target: ES6 +// @sourcemap: false +// @declaration: false +// @module: es6 + +export default class A +{ + constructor () + { + + } + + public B() + { + return 42; + } +} \ No newline at end of file diff --git a/tests/cases/compiler/exportedBlockScopedDeclarations.ts b/tests/cases/compiler/exportedBlockScopedDeclarations.ts new file mode 100644 index 00000000000..f7a0216e8be --- /dev/null +++ b/tests/cases/compiler/exportedBlockScopedDeclarations.ts @@ -0,0 +1,18 @@ +// @module: amd +const foo = foo; // compile error +export const bar = bar; // should be compile error +function f() { + const bar = bar; // compile error +} +namespace NS { + export const bar = bar; // should be compile error +} + +let foo1 = foo1; // compile error +export let bar1 = bar1; // should be compile error +function f1() { + let bar1 = bar1; // compile error +} +namespace NS1 { + export let bar1 = bar1; // should be compile error +} \ No newline at end of file diff --git a/tests/cases/compiler/exportsInAmbientModules1.ts b/tests/cases/compiler/exportsInAmbientModules1.ts new file mode 100644 index 00000000000..53e169fcf5d --- /dev/null +++ b/tests/cases/compiler/exportsInAmbientModules1.ts @@ -0,0 +1,10 @@ +// @module: amd + +// @filename: external.d.ts +export var x: number + +// @filename: main.ts + +declare module "M" { + export {x} from "external" +} \ No newline at end of file diff --git a/tests/cases/compiler/exportsInAmbientModules2.ts b/tests/cases/compiler/exportsInAmbientModules2.ts new file mode 100644 index 00000000000..0fbfa022d13 --- /dev/null +++ b/tests/cases/compiler/exportsInAmbientModules2.ts @@ -0,0 +1,10 @@ +// @module: amd + +// @filename: external.d.ts +export default class C {} + +// @filename: main.ts + +declare module "M" { + export * from "external" +} \ No newline at end of file diff --git a/tests/cases/compiler/functionsInClassExpressions.ts b/tests/cases/compiler/functionsInClassExpressions.ts new file mode 100644 index 00000000000..72e0bafd582 --- /dev/null +++ b/tests/cases/compiler/functionsInClassExpressions.ts @@ -0,0 +1,10 @@ +let Foo = class { + constructor() { + this.bar++; + } + bar = 0; + inc = () => { + this.bar++; + } + m() { return this.bar; } +} \ No newline at end of file diff --git a/tests/cases/compiler/implementsInClassExpression.ts b/tests/cases/compiler/implementsInClassExpression.ts new file mode 100644 index 00000000000..4504c6a2622 --- /dev/null +++ b/tests/cases/compiler/implementsInClassExpression.ts @@ -0,0 +1,7 @@ +interface Foo { + doThing(): void; +} + +let cls = class implements Foo { + doThing() { } +} \ No newline at end of file diff --git a/tests/cases/compiler/importsInAmbientModules1.ts b/tests/cases/compiler/importsInAmbientModules1.ts new file mode 100644 index 00000000000..afd3b071af6 --- /dev/null +++ b/tests/cases/compiler/importsInAmbientModules1.ts @@ -0,0 +1,10 @@ +// @module: amd + +// @filename: external.d.ts +export var x: number + +// @filename: main.ts + +declare module "M" { + import {x} from "external" +} \ No newline at end of file diff --git a/tests/cases/compiler/importsInAmbientModules2.ts b/tests/cases/compiler/importsInAmbientModules2.ts new file mode 100644 index 00000000000..587d7d2069d --- /dev/null +++ b/tests/cases/compiler/importsInAmbientModules2.ts @@ -0,0 +1,10 @@ +// @module: amd + +// @filename: external.d.ts +export default class C {} + +// @filename: main.ts + +declare module "M" { + import C from "external" +} \ No newline at end of file diff --git a/tests/cases/compiler/importsInAmbientModules3.ts b/tests/cases/compiler/importsInAmbientModules3.ts new file mode 100644 index 00000000000..cae5b404b9c --- /dev/null +++ b/tests/cases/compiler/importsInAmbientModules3.ts @@ -0,0 +1,10 @@ +// @module: amd + +// @filename: external.d.ts +export default class C {} + +// @filename: main.ts + +declare module "M" { + import C = require("external"); +} \ No newline at end of file diff --git a/tests/cases/compiler/initializersInAmbientEnums.ts b/tests/cases/compiler/initializersInAmbientEnums.ts new file mode 100644 index 00000000000..728fc881903 --- /dev/null +++ b/tests/cases/compiler/initializersInAmbientEnums.ts @@ -0,0 +1,5 @@ +declare enum E { + a = 10, + b = a, + e = 10 << 2 * 8, +} \ No newline at end of file diff --git a/tests/cases/compiler/modulePrologueAMD.ts b/tests/cases/compiler/modulePrologueAMD.ts new file mode 100644 index 00000000000..d5473798ee0 --- /dev/null +++ b/tests/cases/compiler/modulePrologueAMD.ts @@ -0,0 +1,4 @@ +// @module: amd +"use strict"; + +export class Foo {} \ No newline at end of file diff --git a/tests/cases/compiler/modulePrologueCommonjs.ts b/tests/cases/compiler/modulePrologueCommonjs.ts new file mode 100644 index 00000000000..d6ef5e820a3 --- /dev/null +++ b/tests/cases/compiler/modulePrologueCommonjs.ts @@ -0,0 +1,4 @@ +// @module: commonjs +"use strict"; + +export class Foo {} \ No newline at end of file diff --git a/tests/cases/compiler/modulePrologueES6.ts b/tests/cases/compiler/modulePrologueES6.ts new file mode 100644 index 00000000000..a0782891cba --- /dev/null +++ b/tests/cases/compiler/modulePrologueES6.ts @@ -0,0 +1,5 @@ +// @module: es6 +// @target: es6 +"use strict"; + +export class Foo {} \ No newline at end of file diff --git a/tests/cases/compiler/modulePrologueSystem.ts b/tests/cases/compiler/modulePrologueSystem.ts new file mode 100644 index 00000000000..d336bdb8950 --- /dev/null +++ b/tests/cases/compiler/modulePrologueSystem.ts @@ -0,0 +1,4 @@ +// @module: system +"use strict"; + +export class Foo {} \ No newline at end of file diff --git a/tests/cases/compiler/modulePrologueUmd.ts b/tests/cases/compiler/modulePrologueUmd.ts new file mode 100644 index 00000000000..2660ca75081 --- /dev/null +++ b/tests/cases/compiler/modulePrologueUmd.ts @@ -0,0 +1,4 @@ +// @module: umd +"use strict"; + +export class Foo {} \ No newline at end of file diff --git a/tests/cases/compiler/recursiveGenericUnionType1.ts b/tests/cases/compiler/recursiveGenericUnionType1.ts new file mode 100644 index 00000000000..c1c7b3e81ad --- /dev/null +++ b/tests/cases/compiler/recursiveGenericUnionType1.ts @@ -0,0 +1,20 @@ +declare module Test1 { + export type Container = T | { + [i: string]: Container; + }; + export type IStringContainer = Container; +} + +declare module Test2 { + export type Container = T | { + [i: string]: Container; + }; + export type IStringContainer = Container; +} + +var x: Test1.Container; + +var s1: Test1.IStringContainer; +var s2: Test2.IStringContainer; +s1 = s2; +s2 = s1; diff --git a/tests/cases/compiler/recursiveGenericUnionType2.ts b/tests/cases/compiler/recursiveGenericUnionType2.ts new file mode 100644 index 00000000000..784ddefeb1f --- /dev/null +++ b/tests/cases/compiler/recursiveGenericUnionType2.ts @@ -0,0 +1,20 @@ +declare module Test1 { + export type Container = T | { + [i: string]: Container[]; + }; + export type IStringContainer = Container; +} + +declare module Test2 { + export type Container = T | { + [i: string]: Container[]; + }; + export type IStringContainer = Container; +} + +var x: Test1.Container; + +var s1: Test1.IStringContainer; +var s2: Test2.IStringContainer; +s1 = s2; +s2 = s1; diff --git a/tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts b/tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts new file mode 100644 index 00000000000..9750ea5d161 --- /dev/null +++ b/tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring.ts @@ -0,0 +1,118 @@ +// @target: ES5 + + +(function() { + var s0; + for ({ s0 = 5 } of [{ s0: 1 }]) { + } +}); +(function() { + var s0; + for ({ s0:s0 = 5 } of [{ s0: 1 }]) { + } +}); + +(function() { + var s1; + for ({ s1 = 5 } of [{}]) { + } +}); + +(function() { + var s1; + for ({ s1:s1 = 5 } of [{}]) { + } +}); + +(function() { + var s2; + for ({ s2 = 5 } of [{ s2: "" }]) { + } +}); + +(function() { + var s2; + for ({ s2:s2 = 5 } of [{ s2: "" }]) { + } +}); + +(function() { + var s3: string; + for ({ s3 = 5 } of [{ s3: "" }]) { + } +}); + +(function() { + var s3: string; + for ({ s3:s3 = 5 } of [{ s3: "" }]) { + } +}); + +(function() { + let y; + ({ y = 5 } = { y: 1 }) +}); + +(function() { + let y; + ({ y:y = 5 } = { y: 1 }) +}); + +(function() { + let y0: number; + ({ y0 = 5 } = { y0: 1 }) +}); + +(function() { + let y0: number; + ({ y0:y0 = 5 } = { y0: 1 }) +}); + +(function() { + let y1: string; + ({ y1 = 5 } = {}) +}); + +(function() { + let y1: string; + ({ y1:y1 = 5 } = {}) +}); + +(function() { + let y2: string, y3: { x: string }; + ({ y2 = 5, y3 = { x: 1 } } = {}) +}); + +(function() { + let y2: string, y3: { x: string }; + ({ y2:y2 = 5, y3:y3 = { x: 1 } } = {}) +}); + +(function() { + let y4: number, y5: { x: number }; + ({ y4 = 5, y5 = { x: 1 } } = {}) +}); + +(function() { + let y4: number, y5: { x: number }; + ({ y4:y4 = 5, y5:y5 = { x: 1 } } = {}) +}); + + +(function() { + let z; + ({ z = { x: 5 } } = { z: { x: 1 } }); +}); + + +(function() { + let z; + ({ z:z = { x: 5 } } = { z: { x: 1 } }); +}); + +(function() { + let a = { s = 5 }; +}); + +function foo({a = 4, b = { x: 5 }}) { +} \ No newline at end of file diff --git a/tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts b/tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts new file mode 100644 index 00000000000..d479511b11d --- /dev/null +++ b/tests/cases/compiler/shorthandPropertyAssignmentsInDestructuring_ES6.ts @@ -0,0 +1,118 @@ +// @target: ES6 + + +(function() { + var s0; + for ({ s0 = 5 } of [{ s0: 1 }]) { + } +}); +(function() { + var s0; + for ({ s0:s0 = 5 } of [{ s0: 1 }]) { + } +}); + +(function() { + var s1; + for ({ s1 = 5 } of [{}]) { + } +}); + +(function() { + var s1; + for ({ s1:s1 = 5 } of [{}]) { + } +}); + +(function() { + var s2; + for ({ s2 = 5 } of [{ s2: "" }]) { + } +}); + +(function() { + var s2; + for ({ s2:s2 = 5 } of [{ s2: "" }]) { + } +}); + +(function() { + var s3: string; + for ({ s3 = 5 } of [{ s3: "" }]) { + } +}); + +(function() { + var s3: string; + for ({ s3:s3 = 5 } of [{ s3: "" }]) { + } +}); + +(function() { + let y; + ({ y = 5 } = { y: 1 }) +}); + +(function() { + let y; + ({ y:y = 5 } = { y: 1 }) +}); + +(function() { + let y0: number; + ({ y0 = 5 } = { y0: 1 }) +}); + +(function() { + let y0: number; + ({ y0:y0 = 5 } = { y0: 1 }) +}); + +(function() { + let y1: string; + ({ y1 = 5 } = {}) +}); + +(function() { + let y1: string; + ({ y1:y1 = 5 } = {}) +}); + +(function() { + let y2: string, y3: { x: string }; + ({ y2 = 5, y3 = { x: 1 } } = {}) +}); + +(function() { + let y2: string, y3: { x: string }; + ({ y2:y2 = 5, y3:y3 = { x: 1 } } = {}) +}); + +(function() { + let y4: number, y5: { x: number }; + ({ y4 = 5, y5 = { x: 1 } } = {}) +}); + +(function() { + let y4: number, y5: { x: number }; + ({ y4:y4 = 5, y5:y5 = { x: 1 } } = {}) +}); + + +(function() { + let z; + ({ z = { x: 5 } } = { z: { x: 1 } }); +}); + + +(function() { + let z; + ({ z:z = { x: 5 } } = { z: { x: 1 } }); +}); + +(function() { + let a = { s = 5 }; +}); + +function foo({a = 4, b = { x: 5 }}) { +} \ No newline at end of file diff --git a/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts new file mode 100644 index 00000000000..56bcf84911a --- /dev/null +++ b/tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration15_es6.ts @@ -0,0 +1,26 @@ +// @target: ES6 +// @noEmitHelpers: true +// @experimentalAsyncFunctions: true +declare class Thenable { then(): void; } +declare let a: any; +declare let obj: { then: string; }; +declare let thenable: Thenable; +async function fn1() { } // valid: Promise +async function fn2(): { } { } // error +async function fn3(): any { } // error +async function fn4(): number { } // error +async function fn5(): PromiseLike { } // error +async function fn6(): Thenable { } // error +async function fn7() { return; } // valid: Promise +async function fn8() { return 1; } // valid: Promise +async function fn9() { return null; } // valid: Promise +async function fn10() { return undefined; } // valid: Promise +async function fn11() { return a; } // valid: Promise +async function fn12() { return obj; } // valid: Promise<{ then: string; }> +async function fn13() { return thenable; } // error +async function fn14() { await 1; } // valid: Promise +async function fn15() { await null; } // valid: Promise +async function fn16() { await undefined; } // valid: Promise +async function fn17() { await a; } // valid: Promise +async function fn18() { await obj; } // valid: Promise +async function fn19() { await thenable; } // error diff --git a/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts b/tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSingleLineDecl.ts similarity index 100% rename from tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractMultiLineDecl.ts rename to tests/cases/conformance/classes/classDeclarations/classAbstractKeyword/classAbstractSingleLineDecl.ts diff --git a/tests/cases/conformance/es6/classDeclaration/exportDefaultClassWithStaticPropertyAssignmentsInES6.ts b/tests/cases/conformance/es6/classDeclaration/exportDefaultClassWithStaticPropertyAssignmentsInES6.ts new file mode 100644 index 00000000000..485fbdb011d --- /dev/null +++ b/tests/cases/conformance/es6/classDeclaration/exportDefaultClassWithStaticPropertyAssignmentsInES6.ts @@ -0,0 +1,4 @@ +// @target:es6 +export default class { + static z: string = "Foo"; +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts b/tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts new file mode 100644 index 00000000000..a6761600a1d --- /dev/null +++ b/tests/cases/conformance/es6/modules/defaultExportWithOverloads01.ts @@ -0,0 +1,7 @@ +// @module: commonjs +// @target: ES5 + +export default function f(); +export default function f(x: string); +export default function f(...args: any[]) { +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/modules/exportsAndImports1-es6.ts b/tests/cases/conformance/es6/modules/exportsAndImports1-es6.ts new file mode 100644 index 00000000000..16d8f2addf4 --- /dev/null +++ b/tests/cases/conformance/es6/modules/exportsAndImports1-es6.ts @@ -0,0 +1,34 @@ +// @target: es6 +// @module: commonjs + +// @filename: t1.ts +var v = 1; +function f() { } +class C { +} +interface I { +} +enum E { + A, B, C +} +const enum D { + A, B, C +} +module M { + export var x; +} +module N { + export interface I { + } +} +type T = number; +import a = M.x; + +export { v, f, C, I, E, D, M, N, T, a }; + +// @filename: t2.ts +export { v, f, C, I, E, D, M, N, T, a } from "./t1"; + +// @filename: t3.ts +import { v, f, C, I, E, D, M, N, T, a } from "./t1"; +export { v, f, C, I, E, D, M, N, T, a }; diff --git a/tests/cases/conformance/es6/modules/exportsAndImports2-es6.ts b/tests/cases/conformance/es6/modules/exportsAndImports2-es6.ts new file mode 100644 index 00000000000..5108b98f749 --- /dev/null +++ b/tests/cases/conformance/es6/modules/exportsAndImports2-es6.ts @@ -0,0 +1,13 @@ +// @target: es6 +// @module: commonjs + +// @filename: t1.ts +export var x = "x"; +export var y = "y"; + +// @filename: t2.ts +export { x as y, y as x } from "./t1"; + +// @filename: t3.ts +import { x, y } from "./t1"; +export { x as y, y as x }; diff --git a/tests/cases/conformance/es6/modules/exportsAndImports3-es6.ts b/tests/cases/conformance/es6/modules/exportsAndImports3-es6.ts new file mode 100644 index 00000000000..77cb5b9df9b --- /dev/null +++ b/tests/cases/conformance/es6/modules/exportsAndImports3-es6.ts @@ -0,0 +1,34 @@ +// @target: es6 +// @module: commonjs + +// @filename: t1.ts +export var v = 1; +export function f() { } +export class C { +} +export interface I { +} +export enum E { + A, B, C +} +export const enum D { + A, B, C +} +export module M { + export var x; +} +export module N { + export interface I { + } +} +export type T = number; +export import a = M.x; + +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 }; + +// @filename: 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"; + +// @filename: t3.ts +import { 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"; +export { v, f, C, I, E, D, M, N, T, a }; diff --git a/tests/cases/conformance/es6/modules/exportsAndImports4-es6.ts b/tests/cases/conformance/es6/modules/exportsAndImports4-es6.ts new file mode 100644 index 00000000000..42994486498 --- /dev/null +++ b/tests/cases/conformance/es6/modules/exportsAndImports4-es6.ts @@ -0,0 +1,39 @@ +// @target: es6 +// @module: commonjs + +// @filename: t1.ts +export default "hello"; + +// @filename: t2.ts +import a = require("./t1"); +a.default; +import b from "./t1"; +b; +import * as c from "./t1"; +c.default; +import { default as d } from "./t1"; +d; +import e1, * as e2 from "./t1"; +e1; +e2.default; +import f1, { default as f2 } from "./t1"; +f1; +f2; +import "./t1"; + +// @filename: t3.ts +import a = require("./t1"); +a.default; +import b from "./t1"; +b; +import * as c from "./t1"; +c.default; +import { default as d } from "./t1"; +d; +import e1, * as e2 from "./t1"; +e1; +e2.default; +import f1, { default as f2 } from "./t1"; +f1; +f2; +export { a, b, c, d, e1, e2, f1, f2 }; diff --git a/tests/cases/conformance/es6/modules/multipleDefaultExports03.ts b/tests/cases/conformance/es6/modules/multipleDefaultExports03.ts new file mode 100644 index 00000000000..f2fe7f1a6c3 --- /dev/null +++ b/tests/cases/conformance/es6/modules/multipleDefaultExports03.ts @@ -0,0 +1,8 @@ +// @module: commonjs +// @target: ES5 + +export default class C { +} + +export default class C { +} \ No newline at end of file diff --git a/tests/cases/conformance/es6/modules/multipleDefaultExports04.ts b/tests/cases/conformance/es6/modules/multipleDefaultExports04.ts new file mode 100644 index 00000000000..1dec7b8bea5 --- /dev/null +++ b/tests/cases/conformance/es6/modules/multipleDefaultExports04.ts @@ -0,0 +1,8 @@ +// @module: commonjs +// @target: ES5 + +export default function f() { +} + +export default function f() { +} \ No newline at end of file diff --git a/tests/cases/conformance/expressions/asOperator/asOperator4.ts b/tests/cases/conformance/expressions/asOperator/asOperator4.ts new file mode 100644 index 00000000000..33fcbf920a1 --- /dev/null +++ b/tests/cases/conformance/expressions/asOperator/asOperator4.ts @@ -0,0 +1,11 @@ +//@module: commonjs +//@filename: foo.ts + +export function foo() { } + +//@filename: bar.ts +import { foo } from './foo'; + +// These should emit identically +foo; +(foo as any); diff --git a/tests/cases/conformance/jsx/tsxParseTests2.tsx b/tests/cases/conformance/jsx/tsxParseTests2.tsx new file mode 100644 index 00000000000..9ced9b93b79 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxParseTests2.tsx @@ -0,0 +1,8 @@ +//@filename: file.tsx +//@jsx: preserve +declare module JSX { + interface Element { } + interface IntrinsicElements { div; span; } +} + +var x =
; diff --git a/tests/cases/conformance/jsx/tsxPreserveEmit1.tsx b/tests/cases/conformance/jsx/tsxPreserveEmit1.tsx new file mode 100644 index 00000000000..e75a1dbfde2 --- /dev/null +++ b/tests/cases/conformance/jsx/tsxPreserveEmit1.tsx @@ -0,0 +1,26 @@ +//@module: amd +//@jsx: preserve +//@target: ES5 + +//@Filename: react.d.ts +declare module 'react' { + var x: any; + export = x; +} + +declare module ReactRouter { + var Route: any; + interface Thing { } +} +declare module 'react-router' { + export = ReactRouter; +} + +//@Filename: test.tsx +// Should emit 'react-router' in the AMD dependency list +import React = require('react'); +import ReactRouter = require('react-router'); + +import Route = ReactRouter.Route; + +var routes = ; diff --git a/tests/cases/conformance/jsx/tsxReactEmit6.tsx b/tests/cases/conformance/jsx/tsxReactEmit6.tsx index 2782f90e503..0e8c772a3f1 100644 --- a/tests/cases/conformance/jsx/tsxReactEmit6.tsx +++ b/tests/cases/conformance/jsx/tsxReactEmit6.tsx @@ -19,4 +19,8 @@ namespace M { // and M.React.__spread var foo; var spread1 =
; + + // Quotes + var x =
This "quote" thing
; } + diff --git a/tests/cases/conformance/types/thisType/contextualThisType.ts b/tests/cases/conformance/types/thisType/contextualThisType.ts new file mode 100644 index 00000000000..fdda5494b5e --- /dev/null +++ b/tests/cases/conformance/types/thisType/contextualThisType.ts @@ -0,0 +1,14 @@ +interface X { + a: (p: this) => this; +} + +interface Y extends X { +} + +var x: Y = { + a(p) { + return p; + } +} + +var y = x.a(x); diff --git a/tests/cases/conformance/types/thisType/declarationFiles.ts b/tests/cases/conformance/types/thisType/declarationFiles.ts new file mode 100644 index 00000000000..462e497a90e --- /dev/null +++ b/tests/cases/conformance/types/thisType/declarationFiles.ts @@ -0,0 +1,48 @@ +// @declaration: true + +class C1 { + x: this; + f(x: this): this { return undefined; } + constructor(x: this) { } +} + +class C2 { + [x: string]: this; +} + +interface Foo { + x: T; + y: this; +} + +class C3 { + a: this[]; + b: [this, this]; + c: this | Date; + d: this & Date; + e: (((this))); + f: (x: this) => this; + g: new (x: this) => this; + h: Foo; + i: Foo this)>; + j: (x: any) => x is this; +} + +class C4 { + x1 = { a: this }; + x2 = [this]; + x3 = [{ a: this }]; + x4 = () => this; + f1() { + return { a: this }; + } + f2() { + return [this]; + } + f3() { + return [{ a: this }]; + } + f4() { + return () => this; + } +} diff --git a/tests/cases/conformance/types/thisType/fluentClasses.ts b/tests/cases/conformance/types/thisType/fluentClasses.ts new file mode 100644 index 00000000000..c9e791cb6f1 --- /dev/null +++ b/tests/cases/conformance/types/thisType/fluentClasses.ts @@ -0,0 +1,17 @@ +class A { + foo() { + return this; + } +} +class B extends A { + bar() { + return this; + } +} +class C extends B { + baz() { + return this; + } +} +var c: C; +var z = c.foo().bar().baz(); // Fluent pattern diff --git a/tests/cases/conformance/types/thisType/fluentInterfaces.ts b/tests/cases/conformance/types/thisType/fluentInterfaces.ts new file mode 100644 index 00000000000..d5fabd56bf9 --- /dev/null +++ b/tests/cases/conformance/types/thisType/fluentInterfaces.ts @@ -0,0 +1,11 @@ +interface A { + foo(): this; +} +interface B extends A { + bar(): this; +} +interface C extends B { + baz(): this; +} +var c: C; +var z = c.foo().bar().baz(); // Fluent pattern diff --git a/tests/cases/conformance/types/thisType/thisTypeErrors.ts b/tests/cases/conformance/types/thisType/thisTypeErrors.ts new file mode 100644 index 00000000000..a7e4a46493d --- /dev/null +++ b/tests/cases/conformance/types/thisType/thisTypeErrors.ts @@ -0,0 +1,55 @@ +var x1: this; +var x2: { a: this }; +var x3: this[]; + +function f1(x: this): this { + var y: this; + return this; +} + +interface I1 { + a: { x: this }; + b: { (): this }; + c: { new (): this }; + d: { [x: string]: this }; + e: { f(x: this): this }; +} + +class C1 { + a: { x: this }; + b: { (): this }; + c: { new (): this }; + d: { [x: string]: this }; + e: { f(x: this): this }; +} + +class C2 { + static x: this; + static y = undefined; + static foo(x: this): this { + return undefined; + } +} + +namespace N1 { + export var x: this; + export var y = this; +} + +class C3 { + x1 = { + g(x: this): this { + return undefined; + } + } + f() { + function g(x: this): this { + return undefined; + } + let x2 = { + h(x: this): this { + return undefined; + } + } + } +} diff --git a/tests/cases/conformance/types/thisType/thisTypeInClasses.ts b/tests/cases/conformance/types/thisType/thisTypeInClasses.ts new file mode 100644 index 00000000000..17dc13cf558 --- /dev/null +++ b/tests/cases/conformance/types/thisType/thisTypeInClasses.ts @@ -0,0 +1,50 @@ +class C1 { + x: this; + f(x: this): this { return undefined; } + constructor(x: this) { } +} + +class C2 { + [x: string]: this; +} + +interface Foo { + x: T; + y: this; +} + +class C3 { + a: this[]; + b: [this, this]; + c: this | Date; + d: this & Date; + e: (((this))); + f: (x: this) => this; + g: new (x: this) => this; + h: Foo; + i: Foo this)>; + j: (x: any) => x is this; +} + +declare class C4 { + x: this; + f(x: this): this; +} + +class C5 { + foo() { + let f1 = (x: this): this => this; + let f2 = (x: this) => this; + let f3 = (x: this) => (y: this) => this; + let f4 = (x: this) => { + let g = (y: this) => { + return () => this; + } + return g(this); + } + } + bar() { + let x1 = undefined; + let x2 = undefined as this; + } +} diff --git a/tests/cases/conformance/types/thisType/thisTypeInInterfaces.ts b/tests/cases/conformance/types/thisType/thisTypeInInterfaces.ts new file mode 100644 index 00000000000..c1f48ad8f15 --- /dev/null +++ b/tests/cases/conformance/types/thisType/thisTypeInInterfaces.ts @@ -0,0 +1,28 @@ +interface I1 { + x: this; + f(x: this): this; +} + +interface I2 { + (x: this): this; + new (x: this): this; + [x: string]: this; +} + +interface Foo { + x: T; + y: this; +} + +interface I3 { + a: this[]; + b: [this, this]; + c: this | Date; + d: this & Date; + e: (((this))); + f: (x: this) => this; + g: new (x: this) => this; + h: Foo; + i: Foo this)>; + j: (x: any) => x is this; +} diff --git a/tests/cases/conformance/types/thisType/thisTypeInTuples.ts b/tests/cases/conformance/types/thisType/thisTypeInTuples.ts new file mode 100644 index 00000000000..f7f4084a1a9 --- /dev/null +++ b/tests/cases/conformance/types/thisType/thisTypeInTuples.ts @@ -0,0 +1,8 @@ +interface Array { + slice(): this; +} + +let t: [number, string] = [42, "hello"]; +let a = t.slice(); +let b = t.slice(1); +let c = t.slice(0, 1); diff --git a/tests/cases/conformance/types/thisType/typeRelationships.ts b/tests/cases/conformance/types/thisType/typeRelationships.ts new file mode 100644 index 00000000000..c3ca6f3ef70 --- /dev/null +++ b/tests/cases/conformance/types/thisType/typeRelationships.ts @@ -0,0 +1,39 @@ +class C { + self = this; + c = new C(); + foo() { + return this; + } + f1() { + this.c = this.self; + this.self = this.c; // Error + } + f2() { + var a: C[]; + var a = [this, this.c]; // C[] since this is subtype of C + var b: this[]; + var b = [this, this.self, null, undefined]; + } + f3(b: boolean) { + return b ? this.c : this.self; // Should be C + } +} + +class D extends C { + self1 = this; + self2 = this.self; + self3 = this.foo(); + d = new D(); + bar() { + this.self = this.self1; + this.self = this.self2; + this.self = this.self3; + this.self1 = this.self; + this.self2 = this.self; + this.self3 = this.self; + this.d = this.self; + this.d = this.c; // Error + this.self = this.d; // Error + this.c = this.d; + } +} diff --git a/tests/cases/fourslash/asOperatorCompletion.ts b/tests/cases/fourslash/asOperatorCompletion.ts new file mode 100644 index 00000000000..2eaaae7e75d --- /dev/null +++ b/tests/cases/fourslash/asOperatorCompletion.ts @@ -0,0 +1,8 @@ +/// + +//// type T = number; +//// var x; +//// var y = x as /**/ + +goTo.marker(); +verify.completionListContains('T'); diff --git a/tests/cases/fourslash/commentsOverloads.ts b/tests/cases/fourslash/commentsOverloads.ts index 878ea8ea004..d32c35b0508 100644 --- a/tests/cases/fourslash/commentsOverloads.ts +++ b/tests/cases/fourslash/commentsOverloads.ts @@ -482,8 +482,8 @@ verify.quickInfoIs("(method) c.prop1(a: number): number (+1 overload)", ""); goTo.marker('46'); verify.currentSignatureHelpDocCommentIs(""); verify.currentParameterHelpArgumentDocCommentIs(""); -goTo.marker('46q'); -verify.quickInfoIs("(method) c.prop1(b: string): number (+1 overload)", ""); +//goTo.marker('46q'); +//verify.quickInfoIs("(method) c.prop1(b: string): number (+1 overload)", ""); goTo.marker('47'); verify.currentSignatureHelpDocCommentIs("prop2 1"); @@ -494,8 +494,8 @@ verify.quickInfoIs("(method) c.prop2(a: number): number (+1 overload)", "prop2 1 goTo.marker('48'); verify.currentSignatureHelpDocCommentIs(""); verify.currentParameterHelpArgumentDocCommentIs(""); -goTo.marker('48q'); -verify.quickInfoIs("(method) c.prop2(b: string): number (+1 overload)", ""); +//goTo.marker('48q'); +//verify.quickInfoIs("(method) c.prop2(b: string): number (+1 overload)", ""); goTo.marker('49'); verify.currentSignatureHelpDocCommentIs(""); @@ -506,8 +506,8 @@ verify.quickInfoIs("(method) c.prop3(a: number): number (+1 overload)", ""); goTo.marker('50'); verify.currentSignatureHelpDocCommentIs("prop3 2"); verify.currentParameterHelpArgumentDocCommentIs(""); -goTo.marker('50q'); -verify.quickInfoIs("(method) c.prop3(b: string): number (+1 overload)", "prop3 2"); +//goTo.marker('50q'); +//verify.quickInfoIs("(method) c.prop3(b: string): number (+1 overload)", "prop3 2"); goTo.marker('51'); verify.currentSignatureHelpDocCommentIs("prop4 1"); @@ -518,8 +518,8 @@ verify.quickInfoIs("(method) c.prop4(a: number): number (+1 overload)", "prop4 1 goTo.marker('52'); verify.currentSignatureHelpDocCommentIs("prop4 2"); verify.currentParameterHelpArgumentDocCommentIs(""); -goTo.marker('52q'); -verify.quickInfoIs("(method) c.prop4(b: string): number (+1 overload)", "prop4 2"); +//goTo.marker('52q'); +//verify.quickInfoIs("(method) c.prop4(b: string): number (+1 overload)", "prop4 2"); goTo.marker('53'); verify.currentSignatureHelpDocCommentIs("prop5 1"); @@ -530,8 +530,8 @@ verify.quickInfoIs("(method) c.prop5(a: number): number (+1 overload)", "prop5 1 goTo.marker('54'); verify.currentSignatureHelpDocCommentIs("prop5 2"); verify.currentParameterHelpArgumentDocCommentIs(""); -goTo.marker('54q'); -verify.quickInfoIs("(method) c.prop5(b: string): number (+1 overload)", "prop5 2"); +//goTo.marker('54q'); +//verify.quickInfoIs("(method) c.prop5(b: string): number (+1 overload)", "prop5 2"); goTo.marker('55'); verify.currentSignatureHelpDocCommentIs(""); diff --git a/tests/cases/fourslash/completionListInstanceProtectedMembers.ts b/tests/cases/fourslash/completionListInstanceProtectedMembers.ts index 996bef7077b..e396a71247a 100644 --- a/tests/cases/fourslash/completionListInstanceProtectedMembers.ts +++ b/tests/cases/fourslash/completionListInstanceProtectedMembers.ts @@ -31,15 +31,15 @@ // Same class, everything is visible -goTo.marker("1"); -verify.memberListContains('privateMethod'); -verify.memberListContains('privateProperty'); -verify.memberListContains('protectedMethod'); -verify.memberListContains('protectedProperty'); -verify.memberListContains('publicMethod'); -verify.memberListContains('publicProperty'); -verify.memberListContains('protectedOverriddenMethod'); -verify.memberListContains('protectedOverriddenProperty'); +//goTo.marker("1"); +//verify.memberListContains('privateMethod'); +//verify.memberListContains('privateProperty'); +//verify.memberListContains('protectedMethod'); +//verify.memberListContains('protectedProperty'); +//verify.memberListContains('publicMethod'); +//verify.memberListContains('publicProperty'); +//verify.memberListContains('protectedOverriddenMethod'); +//verify.memberListContains('protectedOverriddenProperty'); goTo.marker("2"); verify.memberListContains('privateMethod'); diff --git a/tests/cases/fourslash/completionListInstanceProtectedMembers2.ts b/tests/cases/fourslash/completionListInstanceProtectedMembers2.ts index c074bc06314..fed310aba21 100644 --- a/tests/cases/fourslash/completionListInstanceProtectedMembers2.ts +++ b/tests/cases/fourslash/completionListInstanceProtectedMembers2.ts @@ -32,15 +32,15 @@ // Same class, everything is visible -goTo.marker("1"); -verify.not.memberListContains('privateMethod'); -verify.not.memberListContains('privateProperty'); -verify.memberListContains('protectedMethod'); -verify.memberListContains('protectedProperty'); -verify.memberListContains('publicMethod'); -verify.memberListContains('publicProperty'); -verify.memberListContains('protectedOverriddenMethod'); -verify.memberListContains('protectedOverriddenProperty'); +//goTo.marker("1"); +//verify.not.memberListContains('privateMethod'); +//verify.not.memberListContains('privateProperty'); +//verify.memberListContains('protectedMethod'); +//verify.memberListContains('protectedProperty'); +//verify.memberListContains('publicMethod'); +//verify.memberListContains('publicProperty'); +//verify.memberListContains('protectedOverriddenMethod'); +//verify.memberListContains('protectedOverriddenProperty'); // Can not access properties on super goTo.marker("2"); diff --git a/tests/cases/fourslash/completionListProtectedMembers.ts b/tests/cases/fourslash/completionListProtectedMembers.ts index 4715a9fb714..8ddd8aca4d0 100644 --- a/tests/cases/fourslash/completionListProtectedMembers.ts +++ b/tests/cases/fourslash/completionListProtectedMembers.ts @@ -18,25 +18,25 @@ ////var b: Base; ////f./*5*/ -goTo.marker("1"); -verify.memberListContains("y"); -verify.memberListContains("x"); -verify.not.memberListContains("z"); +//goTo.marker("1"); +//verify.memberListContains("y"); +//verify.memberListContains("x"); +//verify.not.memberListContains("z"); -goTo.marker("2"); -verify.memberListContains("y"); -verify.memberListContains("x"); -verify.memberListContains("z"); +//goTo.marker("2"); +//verify.memberListContains("y"); +//verify.memberListContains("x"); +//verify.memberListContains("z"); -goTo.marker("3"); -verify.memberListContains("y"); -verify.memberListContains("x"); -verify.not.memberListContains("z"); +//goTo.marker("3"); +//verify.memberListContains("y"); +//verify.memberListContains("x"); +//verify.not.memberListContains("z"); -goTo.marker("4"); -verify.memberListContains("y"); -verify.memberListContains("x"); -verify.memberListContains("z"); +//goTo.marker("4"); +//verify.memberListContains("y"); +//verify.memberListContains("x"); +//verify.memberListContains("z"); goTo.marker("5"); verify.not.memberListContains("x"); diff --git a/tests/cases/fourslash/docCommentTemplateClassDecl01.ts b/tests/cases/fourslash/docCommentTemplateClassDecl01.ts new file mode 100644 index 00000000000..958a8c60fa4 --- /dev/null +++ b/tests/cases/fourslash/docCommentTemplateClassDecl01.ts @@ -0,0 +1,36 @@ +/// + +const CRLF = "\r\n"; +/** + * @returns the given value with '\n' normalized to '\r\n' and with no leading newline + */ +function useCRLFAndStripLeadingNewline(str: string): string { + str = str.replace(/\r?\n/g, CRLF); + if (str.indexOf(CRLF) === 0) { + str = str.slice(CRLF.length); + } + return str; +} + +function confirmNormalizedJsDoc(markerName: string, newTextOffset: number, template: string): void { + goTo.marker(markerName); + const normalized = useCRLFAndStripLeadingNewline(template); + verify.DocCommentTemplate(normalized, newTextOffset); +} + +/////*decl*/class C { +//// private p; +//// constructor(a, b, c, d); +//// constructor(public a, private b, protected c, d, e?) { +//// } +//// +//// foo(); +//// foo(a?, b?, ...args) { +//// } +////} + +confirmNormalizedJsDoc("decl", /*newTextOffset*/ 8, ` +/** + * + */ +`); diff --git a/tests/cases/fourslash/docCommentTemplateClassDeclMethods01.ts b/tests/cases/fourslash/docCommentTemplateClassDeclMethods01.ts new file mode 100644 index 00000000000..da407b632ef --- /dev/null +++ b/tests/cases/fourslash/docCommentTemplateClassDeclMethods01.ts @@ -0,0 +1,79 @@ +/// + +const CRLF = "\r\n"; +/** + * @returns the given value with '\n' normalized to '\r\n' and with no leading newline + */ +function useCRLFAndStripLeadingNewline(str: string): string { + str = str.replace(/\r?\n/g, CRLF); + if (str.indexOf(CRLF) === 0) { + str = str.slice(CRLF.length); + } + return str; +} + +function confirmNormalizedJsDoc(markerName: string, indentation: number, template: string): void { + goTo.marker(markerName); + const normalized = useCRLFAndStripLeadingNewline(template); + verify.DocCommentTemplate(normalized, indentation); +} + +const enum Indentation { + Standard = 8, + Indented = 12, +} + + +////class C { +/////*0*/ /*1*/ +//// foo(); +//// /*2*/foo(a); +//// /*3*/foo(a, b); +//// /*4*/ foo(a, {x: string}, [c]); +//// /*5*/foo(a?, b?, ...args) { +//// } +////} + +confirmNormalizedJsDoc("0", Indentation.Standard, ` +/** + * + */`); + + +confirmNormalizedJsDoc("1", Indentation.Indented, + `/** + * + */`); + + +confirmNormalizedJsDoc("2", Indentation.Indented, + `/** + * + * @param a + */ + `); + +confirmNormalizedJsDoc("3", Indentation.Indented, + `/** + * + * @param a + * @param b + */ + `); + +confirmNormalizedJsDoc("4", Indentation.Indented, + `/** + * + * @param a + * @param param1 + * @param param2 + */`); + +confirmNormalizedJsDoc("5", Indentation.Indented, + `/** + * + * @param a + * @param b + * @param args + */ + `); diff --git a/tests/cases/fourslash/docCommentTemplateClassDeclMethods02.ts b/tests/cases/fourslash/docCommentTemplateClassDeclMethods02.ts new file mode 100644 index 00000000000..99392cf3855 --- /dev/null +++ b/tests/cases/fourslash/docCommentTemplateClassDeclMethods02.ts @@ -0,0 +1,46 @@ +/// + +const CRLF = "\r\n"; +/** + * @returns the given value with '\n' normalized to '\r\n' and with no leading newline + */ +function useCRLFAndStripLeadingNewline(str: string): string { + str = str.replace(/\r?\n/g, CRLF); + if (str.indexOf(CRLF) === 0) { + str = str.slice(CRLF.length); + } + return str; +} + +function confirmNormalizedJsDoc(markerName: string, indentation: number, template: string): void { + goTo.marker(markerName); + const normalized = useCRLFAndStripLeadingNewline(template); + verify.DocCommentTemplate(normalized, indentation); +} + +const enum Indentation { + Indented = 12, +} + + +////class C { +//// /*0*/ +//// [Symbol.iterator]() { +//// return undefined; +//// } +//// /*1*/ +//// [1 + 2 + 3 + Math.rand()](x: number, y: string, z = true) { } +////} + +confirmNormalizedJsDoc("0", Indentation.Indented, + `/** + * + */`); + +confirmNormalizedJsDoc("1", Indentation.Indented, + `/** + * + * @param x + * @param y + * @param z + */`); \ No newline at end of file diff --git a/tests/cases/fourslash/docCommentTemplateConstructor01.ts b/tests/cases/fourslash/docCommentTemplateConstructor01.ts new file mode 100644 index 00000000000..b26ece7a5e6 --- /dev/null +++ b/tests/cases/fourslash/docCommentTemplateConstructor01.ts @@ -0,0 +1,52 @@ +/// + +const CRLF = "\r\n"; +/** + * @returns the given value with '\n' normalized to '\r\n' and with no leading newline + */ +function useCRLFAndStripLeadingNewline(str: string): string { + str = str.replace(/\r?\n/g, CRLF); + if (str.indexOf(CRLF) === 0) { + str = str.slice(CRLF.length); + } + return str; +} + +function confirmNormalizedJsDoc(markerName: string, newTextOffset: number, template: string): void { + goTo.marker(markerName); + const normalized = useCRLFAndStripLeadingNewline(template); + verify.DocCommentTemplate(normalized, newTextOffset); +} + +////class C { +//// private p; +//// /*0*/ +//// constructor(a, b, c, d); +//// /*1*/ +//// constructor(public a, private b, protected c, d, e?) { +//// } +//// +//// foo(); +//// foo(a?, b?, ...args) { +//// } +////} + +const newTextOffset = 12; +confirmNormalizedJsDoc("0", /*newTextOffset*/ newTextOffset, + `/** + * + * @param a + * @param b + * @param c + * @param d + */`); + +confirmNormalizedJsDoc("1", /*newTextOffset*/ newTextOffset, + `/** + * + * @param a + * @param b + * @param c + * @param d + * @param e + */`); diff --git a/tests/cases/fourslash/docCommentTemplateNamespacesAndModules01.ts b/tests/cases/fourslash/docCommentTemplateNamespacesAndModules01.ts new file mode 100644 index 00000000000..4d9fb987be5 --- /dev/null +++ b/tests/cases/fourslash/docCommentTemplateNamespacesAndModules01.ts @@ -0,0 +1,46 @@ +/// + +const CRLF = "\r\n"; +/** + * @returns the given value with '\n' normalized to '\r\n' and with no leading newline + */ +function useCRLFAndStripLeadingNewline(str: string): string { + str = str.replace(/\r?\n/g, CRLF); + if (str.indexOf(CRLF) === 0) { + str = str.slice(CRLF.length); + } + return str; +} + +function confirmNormalizedJsDoc(markerName: string, charOffset: number, template: string): void { + goTo.marker(markerName); + const normalized = useCRLFAndStripLeadingNewline(template); + verify.DocCommentTemplate(normalized, charOffset); +} + +/////*namespaceN*/ +////namespace n { +////} +//// +/////*namespaceM*/ +////module m { +////} +//// +/////*ambientModule*/ +////module "ambientModule" { +////} + +confirmNormalizedJsDoc("namespaceN", /*indentation*/ 8, ` +/** + * + */`); + +confirmNormalizedJsDoc("namespaceM", /*indentation*/ 8, ` +/** + * + */`); + +confirmNormalizedJsDoc("namespaceM", /*indentation*/ 8, ` +/** + * + */`); diff --git a/tests/cases/fourslash/docCommentTemplateNamespacesAndModules02.ts b/tests/cases/fourslash/docCommentTemplateNamespacesAndModules02.ts new file mode 100644 index 00000000000..e59b16d6163 --- /dev/null +++ b/tests/cases/fourslash/docCommentTemplateNamespacesAndModules02.ts @@ -0,0 +1,36 @@ +/// + +const CRLF = "\r\n"; +/** + * @returns the given value with '\n' normalized to '\r\n' and with no leading newline + */ +function useCRLFAndStripLeadingNewline(str: string): string { + str = str.replace(/\r?\n/g, CRLF); + if (str.indexOf(CRLF) === 0) { + str = str.slice(CRLF.length); + } + return str; +} + +function confirmNormalizedJsDoc(markerName: string, charOffset: number, template: string): void { + goTo.marker(markerName); + const normalized = useCRLFAndStripLeadingNewline(template); + verify.DocCommentTemplate(normalized, charOffset); +} + +/////*top*/ +////namespace n1. +//// /*n2*/ n2. +//// /*n3*/ n3 { +////} + +confirmNormalizedJsDoc("top", /*indentation*/ 8, ` +/** + * + */`); + +goTo.marker("n2"); +verify.noDocCommentTemplate(); + +goTo.marker("n3"); +verify.noDocCommentTemplate(); \ No newline at end of file diff --git a/tests/cases/fourslash/docCommentTemplateObjectLiteralMethods01.ts b/tests/cases/fourslash/docCommentTemplateObjectLiteralMethods01.ts new file mode 100644 index 00000000000..4af1b60c698 --- /dev/null +++ b/tests/cases/fourslash/docCommentTemplateObjectLiteralMethods01.ts @@ -0,0 +1,46 @@ +/// + +const CRLF = "\r\n"; +/** + * @returns the given value with '\n' normalized to '\r\n' and with no leading newline + */ +function useCRLFAndStripLeadingNewline(str: string): string { + str = str.replace(/\r?\n/g, CRLF); + if (str.indexOf(CRLF) === 0) { + str = str.slice(CRLF.length); + } + return str; +} + +function confirmNormalizedJsDoc(markerName: string, indentation: number, template: string): void { + goTo.marker(markerName); + const normalized = useCRLFAndStripLeadingNewline(template); + verify.DocCommentTemplate(normalized, indentation); +} + +const enum Indentation { + Indented = 12, +} + + +////var x = { +//// /*0*/ +//// foo() { +//// return undefined; +//// } +//// /*1*/ +//// [1 + 2 + 3 + Math.rand()](x: number, y: string, z = true) { } +////} + +confirmNormalizedJsDoc("0", Indentation.Indented, + `/** + * + */`); + +confirmNormalizedJsDoc("1", Indentation.Indented, + `/** + * + * @param x + * @param y + * @param z + */`); \ No newline at end of file diff --git a/tests/cases/fourslash/docCommentTemplateVariableStatements01.ts b/tests/cases/fourslash/docCommentTemplateVariableStatements01.ts new file mode 100644 index 00000000000..b901919fa1f --- /dev/null +++ b/tests/cases/fourslash/docCommentTemplateVariableStatements01.ts @@ -0,0 +1,70 @@ +/// + +const CRLF = "\r\n"; +/** + * @returns the given value with '\n' normalized to '\r\n' and with no leading newline + */ +function useCRLFAndStripLeadingNewline(str: string): string { + str = str.replace(/\r?\n/g, CRLF); + if (str.indexOf(CRLF) === 0) { + str = str.slice(CRLF.length); + } + return str; +} + +function confirmNormalizedJsDoc(markerName: string, newTextOffset: number, template: string): void { + goTo.marker(markerName); + const normalized = useCRLFAndStripLeadingNewline(template); + verify.DocCommentTemplate(normalized, newTextOffset); +} + +/////*a*/ +////var a = 10; +//// +/////*b*/ +////let b = ""; +//// +/////*c*/ +////const c = 30; +//// +/////*d*/ +////let d = { +//// foo: 10, +//// bar: "20" +////}; +//// +/////*e*/ +////let e = function e(x, y, z) { +//// return +(x + y + z); +////}; +//// +/////*f*/ +////let f = class F { +//// constructor(a, b, c) { +//// this.a = a; +//// this.b = b || (this.c = c); +//// } +////} + +for (const varName of "abcd".split("")) { + confirmNormalizedJsDoc(varName, /*newTextOffset*/ 8, ` +/** + * + */`); +} + +confirmNormalizedJsDoc("e", /*newTextOffset*/ 8, ` +/** + * + * @param x + * @param y + * @param z + */`); + +confirmNormalizedJsDoc("f", /*newTextOffset*/ 8, ` +/** + * + * @param a + * @param b + * @param c + */`); \ No newline at end of file diff --git a/tests/cases/fourslash/docCommentTemplateVariableStatements02.ts b/tests/cases/fourslash/docCommentTemplateVariableStatements02.ts new file mode 100644 index 00000000000..9339e703570 --- /dev/null +++ b/tests/cases/fourslash/docCommentTemplateVariableStatements02.ts @@ -0,0 +1,54 @@ +/// + +const CRLF = "\r\n"; +/** + * @returns the given value with '\n' normalized to '\r\n' and with no leading newline + */ +function useCRLFAndStripLeadingNewline(str: string): string { + str = str.replace(/\r?\n/g, CRLF); + if (str.indexOf(CRLF) === 0) { + str = str.slice(CRLF.length); + } + return str; +} + +function confirmNormalizedJsDoc(markerName: string, newTextOffset: number, template: string): void { + goTo.marker(markerName); + const normalized = useCRLFAndStripLeadingNewline(template); + verify.DocCommentTemplate(normalized, newTextOffset); +} + +/////*a*/ +////var a1 = 10, a2 = 20; +//// +/////*b*/ +////let b1 = "", b2 = true; +//// +/////*c*/ +////const c1 = 30, c2 = 40; +//// +/////*d*/ +////let d1 = function d(x, y, z) { +//// return +(x + y + z); +////}, d2 = 50; +//// +/////*e*/ +////let e1 = class E { +//// constructor(a, b, c) { +//// this.a = a; +//// this.b = b || (this.c = c); +//// } +////}, e2 = () => 100; +//// +/////*f*/ +////let f1 = { +//// foo: 10, +//// bar: "20" +////}, f2 = null; + +for (const varName of "abcdef".split("")) { + confirmNormalizedJsDoc(varName, /*newTextOffset*/ 8, ` +/** + * + */`); +} diff --git a/tests/cases/fourslash/docCommentTemplateVariableStatements03.ts b/tests/cases/fourslash/docCommentTemplateVariableStatements03.ts new file mode 100644 index 00000000000..e473cb798b7 --- /dev/null +++ b/tests/cases/fourslash/docCommentTemplateVariableStatements03.ts @@ -0,0 +1,90 @@ +/// + +const CRLF = "\r\n"; +/** + * @returns the given value with '\n' normalized to '\r\n' and with no leading newline + */ +function useCRLFAndStripLeadingNewline(str: string): string { + str = str.replace(/\r?\n/g, CRLF); + if (str.indexOf(CRLF) === 0) { + str = str.slice(CRLF.length); + } + return str; +} + +function confirmNormalizedJsDoc(markerName: string, newTextOffset: number, template: string): void { + goTo.marker(markerName); + const normalized = useCRLFAndStripLeadingNewline(template); + verify.DocCommentTemplate(normalized, newTextOffset); +} + +/////*a*/ +////var a = x => x +//// +/////*b*/ +////let b = (x,y,z) => x + y + z; +//// +/////*c*/ +////const c = ((x => +x)) +//// +/////*d*/ +////let d = (function () { }) +//// +/////*e*/ +////let e = function e([a,b,c]) { +//// return "hello" +////}; +//// +/////*f*/ +////let f = class { +////} +//// +/////*g*/ +////const g = ((class G { +//// constructor(private x); +//// constructor(x,y,z); +//// constructor(x,y,z, ...okayThatsEnough) { +//// } +////})) + +confirmNormalizedJsDoc("a", /*newTextOffset*/ 8, ` +/** + * + * @param x + */`); + +confirmNormalizedJsDoc("b", /*newTextOffset*/ 8, ` +/** + * + * @param x + * @param y + * @param z + */`); + +confirmNormalizedJsDoc("c", /*newTextOffset*/ 8, ` +/** + * + * @param x + */`); + +confirmNormalizedJsDoc("d", /*newTextOffset*/ 8, ` +/** + * + */`); + +confirmNormalizedJsDoc("e", /*newTextOffset*/ 8, ` +/** + * + * @param param0 + */`); + +confirmNormalizedJsDoc("f", /*newTextOffset*/ 8, ` +/** + * + */`); + +confirmNormalizedJsDoc("g", /*newTextOffset*/ 8, ` +/** + * + * @param x + */`); \ No newline at end of file diff --git a/tests/cases/fourslash/findAllRefsForVariableInExtendsClause01.ts b/tests/cases/fourslash/findAllRefsForVariableInExtendsClause01.ts new file mode 100644 index 00000000000..1ec144d7e82 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForVariableInExtendsClause01.ts @@ -0,0 +1,15 @@ +/// + + +////var [|Base|] = class { }; +////class C extends [|Base|] { } + +let ranges = test.ranges(); +for (let range of ranges) { + goTo.position(range.start); + + verify.referencesCountIs(ranges.length); + for (let expectedReference of ranges) { + verify.referencesAtPositionContains(expectedReference); + } +} \ No newline at end of file diff --git a/tests/cases/fourslash/findAllRefsForVariableInExtendsClause02.ts b/tests/cases/fourslash/findAllRefsForVariableInExtendsClause02.ts new file mode 100644 index 00000000000..0f06a3c4202 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForVariableInExtendsClause02.ts @@ -0,0 +1,17 @@ +/// + +////interface [|Base|] { } +////namespace n { +//// var Base = class { }; +//// interface I extends [|Base|] { } +////} + +let ranges = test.ranges(); +for (let range of ranges) { + goTo.position(range.start); + + verify.referencesCountIs(ranges.length); + for (let expectedReference of ranges) { + verify.referencesAtPositionContains(expectedReference); + } +} \ No newline at end of file diff --git a/tests/cases/fourslash/findAllRefsForVariableInImplementsClause01.ts b/tests/cases/fourslash/findAllRefsForVariableInImplementsClause01.ts new file mode 100644 index 00000000000..93f8cec8109 --- /dev/null +++ b/tests/cases/fourslash/findAllRefsForVariableInImplementsClause01.ts @@ -0,0 +1,10 @@ +/// + + +////var Base = class { }; +////class C extends Base implements [|Base|] { } + +let ranges = test.ranges(); +for (let range of ranges) { + verify.referencesCountIs(0); +} \ No newline at end of file diff --git a/tests/cases/fourslash/formatAsyncKeyword.ts b/tests/cases/fourslash/formatAsyncKeyword.ts new file mode 100644 index 00000000000..305d4ea4244 --- /dev/null +++ b/tests/cases/fourslash/formatAsyncKeyword.ts @@ -0,0 +1,13 @@ +/// + +/////*1*/let x = async () => 1; +/////*2*/let y = async() => 1; +/////*3*/let z = async function () { return 1; }; + +format.document(); +goTo.marker("1"); +verify.currentLineContentIs("let x = async () => 1;"); +goTo.marker("2"); +verify.currentLineContentIs("let y = async () => 1;"); +goTo.marker("3"); +verify.currentLineContentIs("let z = async function() { return 1; };") \ No newline at end of file diff --git a/tests/cases/fourslash/formatInTsxFiles.ts b/tests/cases/fourslash/formatInTsxFiles.ts new file mode 100644 index 00000000000..2585520305c --- /dev/null +++ b/tests/cases/fourslash/formatInTsxFiles.ts @@ -0,0 +1,8 @@ +/// + +//@Filename: file.tsx +////interface I { +//// next: I + +////let t: number; +////t +/////*nextlineWithEqual*/=2+2; +////t= +/////*nextlineWithoutEqual*/2 +/////*nextline2*/+2; +////t +/////*addition*/+= 22 +/////*nextlineSemicolon*/; +////t +////=t +/////*chained*/=t+ 4; + +format.document(); + +goTo.marker("nextlineWithEqual"); +verify.indentationIs(4); +verify.currentLineContentIs(" = 2 + 2;"); +goTo.marker("nextlineWithoutEqual"); +verify.indentationIs(4); +verify.currentLineContentIs(" 2"); +goTo.marker("nextline2"); +verify.indentationIs(4); +verify.currentLineContentIs(" + 2;"); +goTo.marker("addition"); +verify.indentationIs(4); +verify.currentLineContentIs(" += 22"); +goTo.marker("nextlineSemicolon"); +verify.indentationIs(4); +verify.currentLineContentIs(" ;"); +goTo.marker("chained"); +verify.indentationIs(4); +verify.currentLineContentIs(" = t + 4;"); \ No newline at end of file diff --git a/tests/cases/fourslash/formattingOnStatementsWithNoSemicolon.ts b/tests/cases/fourslash/formattingOnStatementsWithNoSemicolon.ts index e33298a5a3b..6dfa61cf294 100644 --- a/tests/cases/fourslash/formattingOnStatementsWithNoSemicolon.ts +++ b/tests/cases/fourslash/formattingOnStatementsWithNoSemicolon.ts @@ -155,7 +155,7 @@ verify.currentLineContentIs(" else"); goTo.marker("61"); verify.currentLineContentIs(" x += 2"); goTo.marker("62"); -verify.currentLineContentIs(" ;"); +verify.currentLineContentIs(" ;"); goTo.marker("63"); verify.currentLineContentIs("do do do do"); goTo.marker("64"); diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts index 42cfc1248b0..54e86786d14 100644 --- a/tests/cases/fourslash/fourslash.ts +++ b/tests/cases/fourslash/fourslash.ts @@ -68,6 +68,13 @@ enum EmitReturnStatus { EmitErrorsEncountered = 4 // Emitter errors occurred during emitting process } +// This is a duplicate of the indentstyle in services.ts to expose it to testcases in fourslash +enum IndentStyle { + None, + Block, + Smart, +} + module FourSlashInterface { export interface Marker { @@ -278,8 +285,8 @@ module FourSlashInterface { FourSlash.currentTestState.verifyIndentationAtCurrentPosition(numberOfSpaces); } - public indentationAtPositionIs(fileName: string, position: number, numberOfSpaces: number) { - FourSlash.currentTestState.verifyIndentationAtPosition(fileName, position, numberOfSpaces); + public indentationAtPositionIs(fileName: string, position: number, numberOfSpaces: number, indentStyle = IndentStyle.Smart) { + FourSlash.currentTestState.verifyIndentationAtPosition(fileName, position, numberOfSpaces, indentStyle); } public textAtCaretIs(text: string) { diff --git a/tests/cases/fourslash/indentationBlock.ts b/tests/cases/fourslash/indentationBlock.ts new file mode 100644 index 00000000000..e880c4a0957 --- /dev/null +++ b/tests/cases/fourslash/indentationBlock.ts @@ -0,0 +1,183 @@ +/// + +//// +////module classes { +////{| "indent": 0 |} +//// class Bar { +////{| "indent": 4 |} +//// +//// constructor() { +////{| "indent": 8 |} +//// } +//// +//// private foo: string = ""; +////{| "indent": 8 |} +//// +//// private f() { +//// var a: any[] = [[1, 2], [3, 4], 5]; +////{| "indent": 12 |} +//// return ((1 + 1)); +//// } +//// +////{| "indent": 8 |} +//// private f2() { +//// if (true) { } { }; +//// } +//// } +////} +//// +//// +////module interfaces { +////{| "indent": 0 |} +//// interface Foo { +////{| "indent": 4 |} +//// +//// x: number; +////{| "indent": 8 |} +//// +//// foo(): number; +////{| "indent": 8 |} +//// } +////} +//// +//// +////module nestedModules { +//// module Foo2 { +////{| "indent": 4 |} +//// function f() { +//// } +////{| "indent": 8 |} +//// var x: number; +////{| "indent": 8 |} +//// } +////} +//// +//// +////module Enums { +//// enum Foo3 { +////{| "indent": 4 |} +//// val1, +////{| "indent": 8 |} +//// val2, +////{| "indent": 8 |} +//// } +////{| "indent": 4 |} +////} +//// +//// +////function controlStatements() { +//// for (var i = 0; i < 10; i++) { +////{| "indent": 4 |} +//// } +//// +//// for (var e in foo.bar) { +////{| "indent": 4 |} +//// } +//// +//// with (foo.bar) { +////{| "indent": 4 |} +//// } +//// +//// while (false) { +////{| "indent": 4 |} +//// } +//// +//// do { +////{| "indent": 4 |} +//// } while (false); +//// +//// switch (foo.bar) { +////{| "indent": 4 |} +//// } +//// +//// switch (foo.bar) { +////{| "indent": 4 |} +//// case 1: +////{| "indent": 8 |} +//// break; +//// default: +////{| "indent": 8 |} +//// break; +//// } +////} +//// +//// +////function tryCatch() { +////{| "indent": 0 |} +//// try { +////{| "indent": 4 |} +//// } +////{| "indent": 4 |} +//// catch (err) { +////{| "indent": 4 |} +//// } +////{| "indent": 4 |} +////} +//// +//// +////function tryFinally() { +////{| "indent": 0 |} +//// try { +////{| "indent": 4 |} +//// } +////{| "indent": 4 |} +//// finally { +////{| "indent": 4 |} +//// } +////{| "indent": 4 |} +////} +//// +//// +////function tryCatchFinally() { +////{| "indent": 0 |} +//// try { +////{| "indent": 4 |} +//// } +////{| "indent": 4 |} +//// catch (err) { +////{| "indent": 4 |} +//// } +////{| "indent": 4 |} +//// finally { +////{| "indent": 4 |} +//// } +////{| "indent": 4 |} +////} +//// +//// +////class indentBeforeCurly +////{| "indent": 0 |} +////{| "indent": 0 |}{ +////{| "indent": 0 |} +////} +//// +//// +////function argumentsListIndentation(bar, +//// blah, +//// {| "indent": 13 |} +////); +//// +//// +////function blockIndentAfterIndentedParameter1(bar, +//// blah) { +////{| "indent": 13 |} +////} +//// +//// +////function blockIndentAfterIndentedParameter2(bar, +//// blah) { +//// if (foo) { +////{| "indent": 4 |} +//// } +////} +//// +//// +////// Note: Do not add more tests at the end of this file, as +////// the purpose of this test is to verity smart indent +////// works for unterminated function arguments at the end of a file. +////function unterminatedListIndentation(a, +////{| "indent": 0 |} + +test.markers().forEach(marker => { + verify.indentationAtPositionIs(marker.fileName, marker.position, marker.data.indent, IndentStyle.Block); +}); diff --git a/tests/cases/fourslash/indentationNone.ts b/tests/cases/fourslash/indentationNone.ts new file mode 100644 index 00000000000..078f5ab35f6 --- /dev/null +++ b/tests/cases/fourslash/indentationNone.ts @@ -0,0 +1,183 @@ +/// + +//// +////module classes { +////{| "indent": 0 |} +//// class Bar { +////{| "indent": 0 |} +//// +//// constructor() { +////{| "indent": 0 |} +//// } +//// +//// private foo: string = ""; +////{| "indent": 0 |} +//// +//// private f() { +//// var a: any[] = [[1, 2], [3, 4], 5]; +////{| "indent": 0 |} +//// return ((1 + 1)); +//// } +//// +////{| "indent": 0 |} +//// private f2() { +//// if (true) { } { }; +//// } +//// } +////} +//// +//// +////module interfaces { +////{| "indent": 0 |} +//// interface Foo { +////{| "indent": 0 |} +//// +//// x: number; +////{| "indent": 0 |} +//// +//// foo(): number; +////{| "indent": 0 |} +//// } +////} +//// +//// +////module nestedModules { +//// module Foo2 { +////{| "indent": 0 |} +//// function f() { +//// } +////{| "indent": 0 |} +//// var x: number; +////{| "indent": 0 |} +//// } +////} +//// +//// +////module Enums { +//// enum Foo3 { +////{| "indent": 0 |} +//// val1, +////{| "indent": 0 |} +//// val2, +////{| "indent": 0 |} +//// } +////{| "indent": 0 |} +////} +//// +//// +////function controlStatements() { +//// for (var i = 0; i < 10; i++) { +////{| "indent": 0 |} +//// } +//// +//// for (var e in foo.bar) { +////{| "indent": 0 |} +//// } +//// +//// with (foo.bar) { +////{| "indent": 0 |} +//// } +//// +//// while (false) { +////{| "indent": 0 |} +//// } +//// +//// do { +////{| "indent": 0 |} +//// } while (false); +//// +//// switch (foo.bar) { +////{| "indent": 0 |} +//// } +//// +//// switch (foo.bar) { +////{| "indent": 0 |} +//// case 1: +////{| "indent": 0 |} +//// break; +//// default: +////{| "indent": 0 |} +//// break; +//// } +////} +//// +//// +////function tryCatch() { +////{| "indent": 0 |} +//// try { +////{| "indent": 0 |} +//// } +////{| "indent": 0 |} +//// catch (err) { +////{| "indent": 0 |} +//// } +////{| "indent": 0 |} +////} +//// +//// +////function tryFinally() { +////{| "indent": 0 |} +//// try { +////{| "indent": 0 |} +//// } +////{| "indent": 0 |} +//// finally { +////{| "indent": 0 |} +//// } +////{| "indent": 0 |} +////} +//// +//// +////function tryCatchFinally() { +////{| "indent": 0 |} +//// try { +////{| "indent": 0 |} +//// } +////{| "indent": 0 |} +//// catch (err) { +////{| "indent": 0 |} +//// } +////{| "indent": 0 |} +//// finally { +////{| "indent": 0 |} +//// } +////{| "indent": 0 |} +////} +//// +//// +////class indentBeforeCurly +////{| "indent": 0 |} +////{| "indent": 0 |}{ +////{| "indent": 0 |} +////} +//// +//// +////function argumentsListIndentation(bar, +//// blah, +//// {| "indent": 0 |} +////); +//// +//// +////function blockIndentAfterIndentedParameter1(bar, +//// blah) { +////{| "indent": 0 |} +////} +//// +//// +////function blockIndentAfterIndentedParameter2(bar, +//// blah) { +//// if (foo) { +////{| "indent": 0 |} +//// } +////} +//// +//// +////// Note: Do not add more tests at the end of this file, as +////// the purpose of this test is to verity smart indent +////// works for unterminated function arguments at the end of a file. +////function unterminatedListIndentation(a, +////{| "indent": 0 |} + +test.markers().forEach(marker => { + verify.indentationAtPositionIs(marker.fileName, marker.position, marker.data.indent, IndentStyle.None); +}); diff --git a/tests/cases/fourslash/jsxSpreadReference.ts b/tests/cases/fourslash/jsxSpreadReference.ts new file mode 100644 index 00000000000..64ab03e6ab9 --- /dev/null +++ b/tests/cases/fourslash/jsxSpreadReference.ts @@ -0,0 +1,25 @@ +/// + +//@Filename: file.tsx +//// declare module JSX { +//// interface Element { } +//// interface IntrinsicElements { +//// } +//// interface ElementAttributesProperty { props } +//// } +//// class MyClass { +//// props: { +//// name?: string; +//// size?: number; +//// } +//// } +//// +//// var [|/*dst*/nn|]: {name?: string; size?: number}; +//// var x = ; + +goTo.marker('src'); +goTo.definition(); +verify.caretAtMarker('dst'); + +goTo.marker('src'); +verify.renameLocations(/*findInStrings*/ false, /*findInComments*/ false); diff --git a/tests/cases/fourslash/parameterWithDestructuring.ts b/tests/cases/fourslash/parameterWithDestructuring.ts new file mode 100644 index 00000000000..72dfefd553a --- /dev/null +++ b/tests/cases/fourslash/parameterWithDestructuring.ts @@ -0,0 +1,22 @@ +/// + +// Repros from issues #4949 and #4818 + +////const result = [{ foo: 'hello' }] +//// .map(({ /*1*/foo }) => /*2*/foo) +//// .map(foo => foo); +//// +////const f = (foo: (bar: string[]) => void) => { }; +//// +////f(([a, b]) => { +//// /*3*/a.charAt(0); // Not okay: inferred as `any` +////}); + +goTo.marker('1'); +verify.quickInfoIs('var foo: string'); + +goTo.marker('2'); +verify.quickInfoIs('var foo: string'); + +goTo.marker('3'); +verify.quickInfoIs('var a: string'); diff --git a/tests/cases/fourslash/tsxCompletion8.ts b/tests/cases/fourslash/tsxCompletion8.ts new file mode 100644 index 00000000000..59ad8385b9d --- /dev/null +++ b/tests/cases/fourslash/tsxCompletion8.ts @@ -0,0 +1,19 @@ +/// + +//@Filename: file.tsx +//// declare module JSX { +//// interface Element { } +//// interface IntrinsicElements { +//// div: { ONE: string; TWO: number; } +//// } +//// } +//// var x =
; + + +goTo.marker('1'); +verify.completionListContains("ONE"); +verify.not.completionListAllowsNewIdentifier(); + +goTo.marker('2'); +verify.completionListContains("ONE"); +verify.not.completionListAllowsNewIdentifier(); diff --git a/tests/cases/fourslash/whiteSpaceTrimming2.ts b/tests/cases/fourslash/whiteSpaceTrimming2.ts new file mode 100644 index 00000000000..de7bd0ae446 --- /dev/null +++ b/tests/cases/fourslash/whiteSpaceTrimming2.ts @@ -0,0 +1,21 @@ +/// + +////let noSubTemplate = `/* /*1*/`; +////let templateHead = `/* /*2*/${1 + 2}`; +////let templateMiddle = `/* ${1 + 2 /*3*/}`; +////let templateTail = `/* ${1 + 2} /*4*/`; + +goTo.marker('1'); +edit.insert("\n"); + +goTo.marker('2'); +edit.insert("\n"); + +goTo.marker('3'); +edit.insert("\n"); + +goTo.marker('4'); +edit.insert("\n"); + + +verify.currentFileContentIs("let noSubTemplate = `/* \n`;\nlet templateHead = `/* \n${1 + 2}`;\nlet templateMiddle = `/* ${1 + 2\n }`;\nlet templateTail = `/* ${1 + 2} \n`;"); diff --git a/tests/cases/fourslash/whiteSpaceTrimming3.ts b/tests/cases/fourslash/whiteSpaceTrimming3.ts new file mode 100644 index 00000000000..93d236773e4 --- /dev/null +++ b/tests/cases/fourslash/whiteSpaceTrimming3.ts @@ -0,0 +1,10 @@ +/// + +////let t = "foo \ +////bar \ +////"/*1*/ + +goTo.marker('1'); +edit.insert(";"); + +verify.currentFileContentIs("let t = \"foo \\\nbar \\ \n\";"); diff --git a/tests/cases/fourslash/whiteSpaceTrimming4.ts b/tests/cases/fourslash/whiteSpaceTrimming4.ts new file mode 100644 index 00000000000..59223197681 --- /dev/null +++ b/tests/cases/fourslash/whiteSpaceTrimming4.ts @@ -0,0 +1,8 @@ +/// + +////var re = /\w+ /*1*//; + +goTo.marker('1'); +edit.insert("\n"); + +verify.currentFileContentIs("var re = /\\w+ \n /;"); diff --git a/tests/cases/unittests/moduleResolution.ts b/tests/cases/unittests/moduleResolution.ts index 3055754de58..b5c2c70e491 100644 --- a/tests/cases/unittests/moduleResolution.ts +++ b/tests/cases/unittests/moduleResolution.ts @@ -178,4 +178,70 @@ module ts { ]); }); }); + + describe("Module resolution - relative imports", () => { + it("should find all modules", () => { + const options: CompilerOptions = { module: ModuleKind.CommonJS }; + const files: Map = { + "/a/b/c/first/shared.ts": ` +class A {} +export = A`, + "/a/b/c/first/second/class_a.ts": ` +import Shared = require('../shared'); +import C = require('../../third/class_c'); +class B {} +export = B;`, + "/a/b/c/third/class_c.ts":` +import Shared = require('../first/shared'); +class C {} +export = C; + ` + }; + const currentDirectory = "/a/b/c/first/second"; + const host: CompilerHost = { + getSourceFile: (fileName: string, languageVersion: ScriptTarget) => { + let path = normalizePath(combinePaths(currentDirectory, fileName)); + return hasProperty(files, path) ? createSourceFile(fileName, files[path], languageVersion) : undefined; + }, + getDefaultLibFileName: () => "lib.d.ts", + writeFile: (fileName, content): void => { throw new Error("NotImplemented"); }, + getCurrentDirectory: () => currentDirectory, + getCanonicalFileName: fileName => fileName.toLowerCase(), + getNewLine: () => "\r\n", + useCaseSensitiveFileNames: () => false, + fileExists: fileName => { + let path = normalizePath(combinePaths(currentDirectory, fileName)); + return hasProperty(files, path); + }, + readFile: (fileName): string => { throw new Error("NotImplemented"); } + }; + + const program = createProgram(["class_a.ts"], options, host); + + assert.equal(program.getSourceFiles().length, 3); + const syntacticDiagnostics = program.getSyntacticDiagnostics(); + assert.equal(syntacticDiagnostics.length, 0, `expect no syntactic diagnostics, got: ${JSON.stringify(syntacticDiagnostics.map(diagnosticToString))}`); + const semanticDiagnostics = program.getSemanticDiagnostics(); + assert.equal(semanticDiagnostics.length, 0, `expect no semantic diagnostics, got: ${JSON.stringify(semanticDiagnostics.map(diagnosticToString))}`); + + // try to get file using a relative name + const fileC = program.getSourceFile("../../../c/third/class_c.ts"); + assert.isTrue(fileC !== undefined, `expected to get file by relative name, got ${fileC}`); + }); + + function diagnosticToString(diagnostic: Diagnostic) { + let output = ""; + + if (diagnostic.file) { + let loc = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start); + + output += `${ diagnostic.file.fileName }(${ loc.line + 1 },${ loc.character + 1 }): `; + } + + let category = DiagnosticCategory[diagnostic.category].toLowerCase(); + output += `${ category } TS${ diagnostic.code }: ${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }${ sys.newLine }`; + + return output; + } + }); } \ No newline at end of file diff --git a/tests/cases/unittests/transpile.ts b/tests/cases/unittests/transpile.ts index 9336c323bb4..1d688f091a4 100644 --- a/tests/cases/unittests/transpile.ts +++ b/tests/cases/unittests/transpile.ts @@ -43,7 +43,7 @@ module ts { } if (canUseOldTranspile) { - let diagnostics: Diagnostic[] = []; + let diagnostics: Diagnostic[] = []; let transpileResult = transpile(input, transpileOptions.compilerOptions, transpileOptions.fileName, diagnostics, transpileOptions.moduleName); checkDiagnostics(diagnostics, testSettings.expectedDiagnosticCodes); if (testSettings.expectedOutput) { @@ -57,10 +57,10 @@ module ts { } if (!transpileOptions.fileName) { - transpileOptions.fileName = "file.ts"; + transpileOptions.fileName = transpileOptions.compilerOptions.jsx ? "file.tsx" : "file.ts"; } - transpileOptions.compilerOptions.sourceMap = true; + transpileOptions.compilerOptions.sourceMap = true; let transpileModuleResultWithSourceMap = transpileModule(input, transpileOptions); assert.isTrue(transpileModuleResultWithSourceMap.sourceMapText !== undefined); @@ -68,7 +68,7 @@ module ts { let expectedSourceMappingUrlLine = `//# sourceMappingURL=${expectedSourceMapFileName}`; if (testSettings.expectedOutput !== undefined) { - assert.equal(transpileModuleResultWithSourceMap.outputText, testSettings.expectedOutput + expectedSourceMappingUrlLine); + assert.equal(transpileModuleResultWithSourceMap.outputText, testSettings.expectedOutput + expectedSourceMappingUrlLine); } else { // expected output is not set, just verify that output text has sourceMappingURL as a last line @@ -78,7 +78,7 @@ module ts { assert.equal(output, expectedSourceMappingUrlLine); } else { - let suffix = getNewLineCharacter(transpileOptions.compilerOptions) + expectedSourceMappingUrlLine + let suffix = getNewLineCharacter(transpileOptions.compilerOptions) + expectedSourceMappingUrlLine assert.isTrue(output.indexOf(suffix, output.length - suffix.length) !== -1); } } @@ -202,14 +202,14 @@ var x = 0;`, `declare function use(a: any);\n` + `use(foo);` let output = - `(function (deps, factory) {\n` + + `(function (factory) {\n` + ` if (typeof module === 'object' && typeof module.exports === 'object') {\n` + ` var v = factory(require, exports); if (v !== undefined) module.exports = v;\n` + ` }\n` + ` else if (typeof define === 'function' && define.amd) {\n` + - ` define(deps, factory);\n` + + ` define(["require", "exports", "SomeOtherName"], factory);\n` + ` }\n` + - `})(["require", "exports", "SomeOtherName"], function (require, exports) {\n` + + `})(function (require, exports) {\n` + ` var SomeName_1 = require("SomeOtherName");\n` + ` use(SomeName_1.foo);\n` + `});\n`; @@ -274,5 +274,14 @@ var x = 0;`, it("Supports backslashes in file name", () => { test("var x", { expectedOutput: "var x;\r\n", options: { fileName: "a\\b.ts" }}); }); + + it("transpile file as 'tsx' if 'jsx' is specified", () => { + let input = `var x =
`; + let output = `var x = React.createElement("div", null);\n`; + test(input, { + expectedOutput: output, + options: { compilerOptions: { jsx: JsxEmit.React, newLine: NewLineKind.LineFeed } } + }) + }); }); } diff --git a/tslint.json b/tslint.json index 1e83ef90ffe..19ccd30ca9f 100644 --- a/tslint.json +++ b/tslint.json @@ -11,8 +11,6 @@ "check-open-brace", "check-whitespace" ], - "no-unreachable": true, - "no-use-before-declare": true, "no-var-keyword": true, "quotemark": [true, "double"