diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index c12a9afad62ae..3d7d980706b21 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -10,6 +10,21 @@ namespace ts { ConstEnumOnly = 2 } + const enum Reachability { + Unintialized = 1 << 0, + Reachable = 1 << 1, + Unreachable = 1 << 2, + ReportedUnreachable = 1 << 3 + } + + function or(state1: Reachability, state2: Reachability): Reachability { + return (state1 | state2) & Reachability.Reachable + ? Reachability.Reachable + : (state1 & state2) & Reachability.ReportedUnreachable + ? Reachability.ReportedUnreachable + : Reachability.Unreachable; + } + export function getModuleInstanceState(node: Node): ModuleInstanceState { // A module is uninstantiated if it contains only // 1. interface declarations, type alias declarations @@ -77,35 +92,64 @@ namespace ts { IsContainerWithLocals = IsContainer | HasLocals } - export function bindSourceFile(file: SourceFile) { + const binder = createBinder(); + + export function bindSourceFile(file: SourceFile, options: CompilerOptions) { let start = new Date().getTime(); - bindSourceFileWorker(file); + binder(file, options); bindTime += new Date().getTime() - start; } - function bindSourceFileWorker(file: SourceFile) { + function createBinder(): (file: SourceFile, options: CompilerOptions) => void { + let file: SourceFile; + let options: CompilerOptions; let parent: Node; let container: Node; let blockScopeContainer: Node; let lastContainer: Node; let seenThisKeyword: boolean; + // state used by reachability checks + let hasExplicitReturn: boolean; + let currentReachabilityState: Reachability; + let labelStack: Reachability[]; + let labelIndexMap: Map; + let implicitLabels: number[]; + // 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 // not depending on if we see "use strict" in certain places (or if we hit a class/namespace). - let inStrictMode = !!file.externalModuleIndicator; + let inStrictMode: boolean; let symbolCount = 0; - let Symbol = objectAllocator.getSymbolConstructor(); - let classifiableNames: Map = {}; + let Symbol: { new (flags: SymbolFlags, name: string): Symbol }; + let classifiableNames: Map; + + function bindSourceFile(f: SourceFile, opts: CompilerOptions) { + file = f; + options = opts; + inStrictMode = !!file.externalModuleIndicator; + classifiableNames = {}; + Symbol = objectAllocator.getSymbolConstructor(); + + if (!file.locals) { + bind(file); + file.symbolCount = symbolCount; + file.classifiableNames = classifiableNames; + } - if (!file.locals) { - bind(file); - file.symbolCount = symbolCount; - file.classifiableNames = classifiableNames; + parent = undefined; + container = undefined; + blockScopeContainer = undefined; + lastContainer = undefined; + seenThisKeyword = false; + hasExplicitReturn = false; + labelStack = undefined; + labelIndexMap = undefined; + implicitLabels = undefined; } - return; + return bindSourceFile; function createSymbol(flags: SymbolFlags, name: string): Symbol { symbolCount++; @@ -338,13 +382,56 @@ namespace ts { blockScopeContainer.locals = undefined; } - if (node.kind === SyntaxKind.InterfaceDeclaration) { + let savedReachabilityState: Reachability; + let savedLabelStack: Reachability[]; + let savedLabels: Map; + let savedImplicitLabels: number[]; + let savedHasExplicitReturn: boolean; + + const kind = node.kind; + let flags = node.flags; + + // reset all reachability check related flags on node (for incremental scenarios) + flags &= ~NodeFlags.ReachabilityCheckFlags; + + if (kind === SyntaxKind.InterfaceDeclaration) { seenThisKeyword = false; - forEachChild(node, bind); - node.flags = seenThisKeyword ? node.flags | NodeFlags.ContainsThis : node.flags & ~NodeFlags.ContainsThis; } - else { - forEachChild(node, bind); + + let saveState = kind === SyntaxKind.SourceFile || kind === SyntaxKind.ModuleBlock || isFunctionLikeKind(kind); + if (saveState) { + savedReachabilityState = currentReachabilityState; + savedLabelStack = labelStack; + savedLabels = labelIndexMap; + savedImplicitLabels = implicitLabels; + savedHasExplicitReturn = hasExplicitReturn; + + currentReachabilityState = Reachability.Reachable; + hasExplicitReturn = false; + labelStack = labelIndexMap = implicitLabels = undefined; + } + + bindReachableStatement(node); + + if (currentReachabilityState === Reachability.Reachable && isFunctionLikeKind(kind) && nodeIsPresent((node).body)) { + flags |= NodeFlags.HasImplicitReturn; + if (hasExplicitReturn) { + flags |= NodeFlags.HasExplicitReturn; + } + } + + if (kind === SyntaxKind.InterfaceDeclaration) { + flags = seenThisKeyword ? flags | NodeFlags.ContainsThis : flags & ~NodeFlags.ContainsThis; + } + + node.flags = flags; + + if (saveState) { + hasExplicitReturn = savedHasExplicitReturn; + currentReachabilityState = savedReachabilityState; + labelStack = savedLabelStack; + labelIndexMap = savedLabels; + implicitLabels = savedImplicitLabels; } container = saveContainer; @@ -352,6 +439,220 @@ namespace ts { blockScopeContainer = savedBlockScopeContainer; } + /** + * Returns true if node and its subnodes were successfully traversed. + * Returning false means that node was not examined and caller needs to dive into the node himself. + */ + function bindReachableStatement(node: Node): void { + if (checkUnreachable(node)) { + forEachChild(node, bind); + return; + } + + switch (node.kind) { + case SyntaxKind.WhileStatement: + bindWhileStatement(node); + break; + case SyntaxKind.DoStatement: + bindDoStatement(node); + break; + case SyntaxKind.ForStatement: + bindForStatement(node); + break; + case SyntaxKind.ForInStatement: + case SyntaxKind.ForOfStatement: + bindForInOrForOfStatement(node); + break; + case SyntaxKind.IfStatement: + bindIfStatement(node); + break; + case SyntaxKind.ReturnStatement: + case SyntaxKind.ThrowStatement: + bindReturnOrThrow(node); + break; + case SyntaxKind.BreakStatement: + case SyntaxKind.ContinueStatement: + bindBreakOrContinueStatement(node); + break; + case SyntaxKind.TryStatement: + bindTryStatement(node); + break; + case SyntaxKind.SwitchStatement: + bindSwitchStatement(node); + break; + case SyntaxKind.CaseBlock: + bindCaseBlock(node); + break; + case SyntaxKind.LabeledStatement: + bindLabeledStatement(node); + break; + default: + forEachChild(node, bind); + break; + } + } + + function bindWhileStatement(n: WhileStatement): void { + const preWhileState = + n.expression.kind === SyntaxKind.FalseKeyword ? Reachability.Unreachable : currentReachabilityState; + const postWhileState = + n.expression.kind === SyntaxKind.TrueKeyword ? Reachability.Unreachable : currentReachabilityState; + + // bind expressions (don't affect reachability) + bind(n.expression); + + currentReachabilityState = preWhileState; + const postWhileLabel = pushImplicitLabel(); + bind(n.statement); + popImplicitLabel(postWhileLabel, postWhileState); + } + + function bindDoStatement(n: DoStatement): void { + const preDoState = currentReachabilityState; + + const postDoLabel = pushImplicitLabel(); + bind(n.statement); + const postDoState = n.expression.kind === SyntaxKind.TrueKeyword ? Reachability.Unreachable : preDoState; + popImplicitLabel(postDoLabel, postDoState); + + // bind expressions (don't affect reachability) + bind(n.expression); + } + + function bindForStatement(n: ForStatement): void { + const preForState = currentReachabilityState; + const postForLabel = pushImplicitLabel(); + + // bind expressions (don't affect reachability) + bind(n.initializer); + bind(n.condition); + bind(n.incrementor); + + bind(n.statement); + + // for statement is considered infinite when it condition is either omitted or is true keyword + // - for(..;;..) + // - for(..;true;..) + const isInfiniteLoop = (!n.condition || n.condition.kind === SyntaxKind.TrueKeyword); + const postForState = isInfiniteLoop ? Reachability.Unreachable : preForState; + popImplicitLabel(postForLabel, postForState); + } + + function bindForInOrForOfStatement(n: ForInStatement | ForOfStatement): void { + const preStatementState = currentReachabilityState; + const postStatementLabel = pushImplicitLabel(); + + // bind expressions (don't affect reachability) + bind(n.initializer); + bind(n.expression); + + bind(n.statement); + popImplicitLabel(postStatementLabel, preStatementState); + } + + function bindIfStatement(n: IfStatement): void { + // denotes reachability state when entering 'thenStatement' part of the if statement: + // i.e. if condition is false then thenStatement is unreachable + const ifTrueState = n.expression.kind === SyntaxKind.FalseKeyword ? Reachability.Unreachable : currentReachabilityState; + // denotes reachability state when entering 'elseStatement': + // i.e. if condition is true then elseStatement is unreachable + const ifFalseState = n.expression.kind === SyntaxKind.TrueKeyword ? Reachability.Unreachable : currentReachabilityState; + + currentReachabilityState = ifTrueState; + + // bind expression (don't affect reachability) + bind(n.expression); + + bind(n.thenStatement); + if (n.elseStatement) { + const preElseState = currentReachabilityState; + currentReachabilityState = ifFalseState; + bind(n.elseStatement); + currentReachabilityState = or(currentReachabilityState, preElseState); + } + else { + currentReachabilityState = or(currentReachabilityState, ifFalseState); + } + } + + function bindReturnOrThrow(n: ReturnStatement | ThrowStatement): void { + // bind expression (don't affect reachability) + bind(n.expression); + if (n.kind === SyntaxKind.ReturnStatement) { + hasExplicitReturn = true; + } + currentReachabilityState = Reachability.Unreachable; + } + + function bindBreakOrContinueStatement(n: BreakOrContinueStatement): void { + // call bind on label (don't affect reachability) + bind(n.label); + // for continue case touch label so it will be marked a used + const isValidJump = jumpToLabel(n.label, n.kind === SyntaxKind.BreakStatement ? currentReachabilityState : Reachability.Unreachable); + if (isValidJump) { + currentReachabilityState = Reachability.Unreachable; + } + } + + function bindTryStatement(n: TryStatement): void { + // catch\finally blocks has the same reachability as try block + const preTryState = currentReachabilityState; + bind(n.tryBlock); + const postTryState = currentReachabilityState; + + currentReachabilityState = preTryState; + bind(n.catchClause); + const postCatchState = currentReachabilityState; + + currentReachabilityState = preTryState; + bind(n.finallyBlock); + + // post catch/finally state is reachable if + // - post try state is reachable - control flow can fall out of try block + // - post catch state is reachable - control flow can fall out of catch block + currentReachabilityState = or(postTryState, postCatchState); + } + + function bindSwitchStatement(n: SwitchStatement): void { + const preSwitchState = currentReachabilityState; + const postSwitchLabel = pushImplicitLabel(); + + // bind expression (don't affect reachability) + bind(n.expression); + + bind(n.caseBlock); + + const hasDefault = forEach(n.caseBlock.clauses, c => c.kind === SyntaxKind.DefaultClause); + + // post switch state is unreachable if switch is exaustive (has a default case ) and does not have fallthrough from the last case + const postSwitchState = hasDefault && currentReachabilityState !== Reachability.Reachable ? Reachability.Unreachable : preSwitchState; + + popImplicitLabel(postSwitchLabel, postSwitchState); + } + + function bindCaseBlock(n: CaseBlock): void { + const startState = currentReachabilityState; + + for (let clause of n.clauses) { + currentReachabilityState = startState; + bind(clause); + if (clause.statements.length && currentReachabilityState === Reachability.Reachable && options.noFallthroughCasesInSwitch) { + errorOnFirstToken(clause, Diagnostics.Fallthrough_case_in_switch); + } + } + } + + function bindLabeledStatement(n: LabeledStatement): void { + // call bind on label (don't affect reachability) + bind(n.label); + + const ok = pushNamedLabel(n.label); + bind(n.statement); + if (ok) { + popNamedLabel(n.label, currentReachabilityState); + } + } + function getContainerFlags(node: Node): ContainerFlags { switch (node.kind) { case SyntaxKind.ClassExpression: @@ -488,17 +789,6 @@ namespace ts { : declareSymbol(file.locals, undefined, node, symbolFlags, symbolExcludes); } - function isAmbientContext(node: Node): boolean { - while (node) { - if (node.flags & NodeFlags.Ambient) { - return true; - } - - node = node.parent; - } - return false; - } - function hasExportDeclarations(node: ModuleDeclaration | SourceFile): boolean { let body = node.kind === SyntaxKind.SourceFile ? node : (node).body; if (body.kind === SyntaxKind.SourceFile || body.kind === SyntaxKind.ModuleBlock) { @@ -514,7 +804,7 @@ namespace ts { function setExportContextFlag(node: ModuleDeclaration | SourceFile) { // A declaration source file or ambient module declaration that contains no export declarations (but possibly regular // declarations with export modifiers) is an export context in which declarations are implicitly exported. - if (isAmbientContext(node) && !hasExportDeclarations(node)) { + if (isInAmbientContext(node) && !hasExportDeclarations(node)) { node.flags |= NodeFlags.ExportContext; } else { @@ -766,11 +1056,11 @@ namespace ts { function checkStrictModeWithStatement(node: WithStatement) { // Grammar checking for withStatement if (inStrictMode) { - grammarErrorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_strict_mode); + errorOnFirstToken(node, Diagnostics.with_statements_are_not_allowed_in_strict_mode); } } - function grammarErrorOnFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any) { + function errorOnFirstToken(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any) { let span = getSpanOfTokenAtPosition(file, node.pos); file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2)); } @@ -780,6 +1070,10 @@ namespace ts { } function bind(node: Node) { + if (!node) { + return; + } + node.parent = parent; let savedInStrictMode = inStrictMode; @@ -1084,5 +1378,135 @@ namespace ts { ? bindAnonymousDeclaration(node, symbolFlags, "__computed") : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes); } + + // reachability checks + + function pushNamedLabel(name: Identifier): boolean { + initializeReachabilityStateIfNecessary(); + + if (hasProperty(labelIndexMap, name.text)) { + return false; + } + labelIndexMap[name.text] = labelStack.push(Reachability.Unintialized) - 1; + return true; + } + + function pushImplicitLabel(): number { + initializeReachabilityStateIfNecessary(); + + let index = labelStack.push(Reachability.Unintialized) - 1; + implicitLabels.push(index); + return index; + } + + function popNamedLabel(label: Identifier, outerState: Reachability): void { + let index = labelIndexMap[label.text]; + Debug.assert(index !== undefined); + Debug.assert(labelStack.length == index + 1); + + labelIndexMap[label.text] = undefined; + + setCurrentStateAtLabel(labelStack.pop(), outerState, label); + } + + function popImplicitLabel(implicitLabelIndex: number, outerState: Reachability): void { + if (labelStack.length !== implicitLabelIndex + 1) { + Debug.assert(false, `Label stack: ${labelStack.length}, index:${implicitLabelIndex}`); + } + + let i = implicitLabels.pop(); + + if (implicitLabelIndex !== i) { + Debug.assert(false, `i: ${i}, index: ${implicitLabelIndex}`); + } + + setCurrentStateAtLabel(labelStack.pop(), outerState, /*name*/ undefined); + } + + function setCurrentStateAtLabel(innerMergedState: Reachability, outerState: Reachability, label: Identifier): void { + if (innerMergedState === Reachability.Unintialized) { + if (label && !options.allowUnusedLabels) { + file.bindDiagnostics.push(createDiagnosticForNode(label, Diagnostics.Unused_label)); + } + currentReachabilityState = outerState; + } + else { + currentReachabilityState = or(innerMergedState, outerState); + } + } + + function jumpToLabel(label: Identifier, outerState: Reachability): boolean { + initializeReachabilityStateIfNecessary(); + + const index = label ? labelIndexMap[label.text] : lastOrUndefined(implicitLabels); + if (index === undefined) { + // reference to unknown label or + // break/continue used outside of loops + return false; + } + const stateAtLabel = labelStack[index]; + labelStack[index] = stateAtLabel === Reachability.Unintialized ? outerState : or(stateAtLabel, outerState); + return true; + } + + function checkUnreachable(node: Node): boolean { + switch (currentReachabilityState) { + case Reachability.Unreachable: + const reportError = + // report error on all statements + isStatement(node) || + // report error on class declarations + node.kind === SyntaxKind.ClassDeclaration || + // report error on instantiated modules or const-enums only modules if preserveConstEnums is set + (node.kind === SyntaxKind.ModuleDeclaration && shouldReportErrorOnModuleDeclaration(node)) || + // report error on regular enums and const enums if preserveConstEnums is set + (node.kind === SyntaxKind.EnumDeclaration && (!isConstEnumDeclaration(node) || options.preserveConstEnums)); + + if (reportError) { + currentReachabilityState = Reachability.ReportedUnreachable; + + // unreachable code is reported if + // - user has explicitly asked about it AND + // - statement is in not ambient context (statements in ambient context is already an error + // so we should not report extras) AND + // - node is not variable statement OR + // - node is block scoped variable statement OR + // - node is not block scoped variable statement and at least one variable declaration has initializer + // Rationale: we don't want to report errors on non-initialized var's since they are hoisted + // On the other side we do want to report errors on non-initialized 'lets' because of TDZ + const reportUnreachableCode = + !options.allowUnreachableCode && + !isInAmbientContext(node) && + ( + node.kind !== SyntaxKind.VariableStatement || + getCombinedNodeFlags((node).declarationList) & NodeFlags.BlockScoped || + forEach((node).declarationList.declarations, d => d.initializer) + ); + + if (reportUnreachableCode) { + errorOnFirstToken(node, Diagnostics.Unreachable_code_detected); + } + } + case Reachability.ReportedUnreachable: + return true; + default: + return false; + } + + function shouldReportErrorOnModuleDeclaration(node: ModuleDeclaration): boolean { + const instanceState = getModuleInstanceState(node); + return instanceState === ModuleInstanceState.Instantiated || (instanceState === ModuleInstanceState.ConstEnumOnly && options.preserveConstEnums); + } + } + + function initializeReachabilityStateIfNecessary(): void { + if (labelIndexMap) { + return; + } + currentReachabilityState = Reachability.Reachable; + labelIndexMap = {}; + labelStack = []; + implicitLabels = []; + } } } diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 99b3d97b7beee..d031f47be4bc7 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -160,6 +160,8 @@ namespace ts { let getGlobalPromiseConstructorLikeType: () => ObjectType; let getGlobalThenableType: () => ObjectType; + let jsxElementClassType: Type; + let tupleTypes: Map = {}; let unionTypes: Map = {}; let intersectionTypes: Map = {}; @@ -7873,7 +7875,6 @@ namespace ts { return prop || unknownSymbol; } - let jsxElementClassType: Type = undefined; function getJsxGlobalElementClassType(): Type { if (!jsxElementClassType) { jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass); @@ -9619,21 +9620,11 @@ namespace ts { return aggregatedTypes; } - function bodyContainsAReturnStatement(funcBody: Block) { - return forEachReturnStatement(funcBody, returnStatement => { - return true; - }); - } - - function bodyContainsSingleThrowStatement(body: Block) { - return (body.statements.length === 1) && (body.statements[0].kind === SyntaxKind.ThrowStatement); - } - // TypeScript Specification 1.0 (6.3) - July 2014 // An explicitly typed function whose return type isn't the Void or the Any type // must have at least one return statement somewhere in its body. // An exception to this rule is if the function implementation consists of a single 'throw' statement. - function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func: FunctionLikeDeclaration, returnType: Type): void { + function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func: FunctionLikeDeclaration, returnType: Type): void { if (!produceDiagnostics) { return; } @@ -9644,26 +9635,20 @@ namespace ts { } // If all we have is a function signature, or an arrow function with an expression body, then there is nothing to check. - if (nodeIsMissing(func.body) || func.body.kind !== SyntaxKind.Block) { + // also if HasImplicitReturnValue flags is not set this means that all codepaths in function body end with return of throw + if (nodeIsMissing(func.body) || func.body.kind !== SyntaxKind.Block || !(func.flags & NodeFlags.HasImplicitReturn)) { return; } - let bodyBlock = func.body; - - // Ensure the body has at least one return expression. - if (bodyContainsAReturnStatement(bodyBlock)) { - return; + if (func.flags & NodeFlags.HasExplicitReturn) { + if (compilerOptions.noImplicitReturns) { + error(func.type, Diagnostics.Not_all_code_paths_return_a_value); + } } - - // If there are no return expressions, then we need to check if - // the function body consists solely of a throw statement; - // this is to make an exception for unimplemented functions. - if (bodyContainsSingleThrowStatement(bodyBlock)) { - return; + else { + // This function does not conform to the specification. + error(func.type, Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value); } - - // This function does not conform to the specification. - error(func.type, Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_or_consist_of_a_single_throw_statement); } function checkFunctionExpressionOrObjectLiteralMethod(node: FunctionExpression | MethodDeclaration, contextualMapper?: TypeMapper): Type { @@ -9743,7 +9728,7 @@ namespace ts { } if (returnType && !node.asteriskToken) { - checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType); + checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType); } if (node.body) { @@ -10944,8 +10929,15 @@ namespace ts { checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name); if (node.kind === SyntaxKind.GetAccessor) { - if (!isInAmbientContext(node) && nodeIsPresent(node.body) && !(bodyContainsAReturnStatement(node.body) || bodyContainsSingleThrowStatement(node.body))) { - error(node.name, Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement); + if (!isInAmbientContext(node) && nodeIsPresent(node.body) && (node.flags & NodeFlags.HasImplicitReturn)) { + if (node.flags & NodeFlags.HasExplicitReturn) { + if (compilerOptions.noImplicitReturns) { + error(node.name, Diagnostics.Not_all_code_paths_return_a_value); + } + } + else { + error(node.name, Diagnostics.A_get_accessor_must_return_a_value); + } } } @@ -11876,7 +11868,7 @@ namespace ts { promisedType = checkAsyncFunctionReturnType(node); } - checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(node, isAsync ? promisedType : returnType); + checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, isAsync ? promisedType : returnType); } if (produceDiagnostics && !node.type) { @@ -14914,7 +14906,7 @@ namespace ts { function initializeTypeChecker() { // Bind all source files and propagate errors forEach(host.getSourceFiles(), file => { - bindSourceFile(file); + bindSourceFile(file, compilerOptions); }); // Initialize global symbol table diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts index 84496fdbeb313..3b9e75e6c7675 100644 --- a/src/compiler/commandLineParser.ts +++ b/src/compiler/commandLineParser.ts @@ -248,11 +248,31 @@ namespace ts { description: Diagnostics.Specifies_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6, error: Diagnostics.Argument_for_moduleResolution_option_must_be_node_or_classic, }, + { + name: "allowUnusedLabels", + type: "boolean", + description: Diagnostics.Do_not_report_errors_on_unused_labels + }, + { + name: "noImplicitReturns", + type: "boolean", + description: Diagnostics.Report_error_when_not_all_code_paths_in_function_return_a_value + }, + { + name: "noFallthroughCasesInSwitch", + type: "boolean", + description: Diagnostics.Report_errors_for_fallthrough_cases_in_switch_statement + }, + { + name: "allowUnreachableCode", + type: "boolean", + description: Diagnostics.Do_not_report_errors_on_unreachable_code + }, { name: "forceConsistentCasingInFileNames", type: "boolean", description: Diagnostics.Disallow_inconsistently_cased_references_to_the_same_file - }, + } ]; /* @internal */ diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 4b4b3ab204d25..dd7fbe14d6eab 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -1012,7 +1012,7 @@ "category": "Error", "code": 2354 }, - "A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement.": { + "A function whose declared type is neither 'void' nor 'any' must return a value.": { "category": "Error", "code": 2355 }, @@ -1096,7 +1096,7 @@ "category": "Error", "code": 2377 }, - "A 'get' accessor must return a value or consist of a single 'throw' statement.": { + "A 'get' accessor must return a value.": { "category": "Error", "code": 2378 }, @@ -2298,6 +2298,22 @@ "category": "Message", "code": 6073 }, + "Do not report errors on unused labels.": { + "category": "Message", + "code": 6074 + }, + "Report error when not all code paths in function return a value.": { + "category": "Message", + "code": 6075 + }, + "Report errors for fallthrough cases in switch statement.": { + "category": "Message", + "code": 6076 + }, + "Do not report errors on unreachable code.": { + "category": "Message", + "code": 6077 + }, "Variable '{0}' implicitly has an '{1}' type.": { "category": "Error", "code": 7005 @@ -2366,8 +2382,22 @@ "category": "Error", "code": 7026 }, - - + "Unreachable code detected.": { + "category": "Error", + "code": 7027 + }, + "Unused label.": { + "category": "Error", + "code": 7028 + }, + "Fallthrough case in switch.": { + "category": "Error", + "code": 7029 + }, + "Not all code paths return a value.": { + "category": "Error", + "code": 7030 + }, "You cannot rename this element.": { "category": "Error", "code": 8000 diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts index b2fa553a73734..8837972a916ce 100644 --- a/src/compiler/emitter.ts +++ b/src/compiler/emitter.ts @@ -9,6 +9,12 @@ namespace ts { type DependencyGroup = Array; + const enum Jump { + Break = 1 << 1, + Continue = 1 << 2, + Return = 1 << 3 + } + let entities: Map = { "quot": 0x0022, "amp": 0x0026, @@ -379,12 +385,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi return true; } - const enum Jump { - Break = 1 << 1, - Continue = 1 << 2, - Return = 1 << 3 - } - interface ConvertedLoopState { /* * set of labels that occured inside the converted loop diff --git a/src/compiler/types.ts b/src/compiler/types.ts index ae08ba7ff3261..484cc56d3b386 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -362,28 +362,31 @@ namespace ts { export const enum NodeFlags { None = 0, - Export = 0x00000001, // Declarations - Ambient = 0x00000002, // Declarations - Public = 0x00000010, // Property/Method - Private = 0x00000020, // Property/Method - Protected = 0x00000040, // Property/Method - Static = 0x00000080, // Property/Method - Abstract = 0x00000100, // Class/Method/ConstructSignature - Async = 0x00000200, // Property/Method/Function - Default = 0x00000400, // Function/Class (export default declaration) - MultiLine = 0x00000800, // Multi-line array or object literal - Synthetic = 0x00001000, // Synthetic node (for full fidelity) - DeclarationFile = 0x00002000, // Node is a .d.ts file - Let = 0x00004000, // Variable declaration - Const = 0x00008000, // Variable declaration - OctalLiteral = 0x00010000, // Octal numeric literal - Namespace = 0x00020000, // Namespace declaration - ExportContext = 0x00040000, // Export context (initialized by binding) - ContainsThis = 0x00080000, // Interface contains references to "this" - + Export = 1 << 1, // Declarations + Ambient = 1 << 2, // Declarations + Public = 1 << 3, // Property/Method + Private = 1 << 4, // Property/Method + Protected = 1 << 5, // Property/Method + Static = 1 << 6, // Property/Method + Abstract = 1 << 7, // Class/Method/ConstructSignature + Async = 1 << 8, // Property/Method/Function + Default = 1 << 9, // Function/Class (export default declaration) + MultiLine = 1 << 10, // Multi-line array or object literal + Synthetic = 1 << 11, // Synthetic node (for full fidelity) + DeclarationFile = 1 << 12, // Node is a .d.ts file + Let = 1 << 13, // Variable declaration + Const = 1 << 14, // Variable declaration + OctalLiteral = 1 << 15, // Octal numeric literal + Namespace = 1 << 16, // Namespace declaration + ExportContext = 1 << 17, // Export context (initialized by binding) + ContainsThis = 1 << 18, // Interface contains references to "this" + HasImplicitReturn = 1 << 19, // If function implicitly returns on one of codepaths (initialized by binding) + HasExplicitReturn = 1 << 20, // If function has explicit reachable return on one of codepaths (initialized by binding) Modifier = Export | Ambient | Public | Private | Protected | Static | Abstract | Default | Async, AccessibilityModifier = Public | Private | Protected, - BlockScoped = Let | Const + BlockScoped = Let | Const, + + ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn } /* @internal */ @@ -2092,6 +2095,10 @@ namespace ts { experimentalDecorators?: boolean; emitDecoratorMetadata?: boolean; moduleResolution?: ModuleResolutionKind; + allowUnusedLabels?: boolean; + allowUnreachableCode?: boolean; + noImplicitReturns?: boolean; + noFallthroughCasesInSwitch?: boolean; forceConsistentCasingInFileNames?: boolean; /* @internal */ stripInternal?: boolean; diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index d8de6e0c303a5..a4dc0d11a6562 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -622,25 +622,26 @@ namespace ts { } export function isFunctionLike(node: Node): node is FunctionLikeDeclaration { - if (node) { - switch (node.kind) { - case SyntaxKind.Constructor: - case SyntaxKind.FunctionExpression: - case SyntaxKind.FunctionDeclaration: - case SyntaxKind.ArrowFunction: - case SyntaxKind.MethodDeclaration: - case SyntaxKind.MethodSignature: - case SyntaxKind.GetAccessor: - case SyntaxKind.SetAccessor: - case SyntaxKind.CallSignature: - case SyntaxKind.ConstructSignature: - case SyntaxKind.IndexSignature: - case SyntaxKind.FunctionType: - case SyntaxKind.ConstructorType: - return true; - } + return node && isFunctionLikeKind(node.kind); + } + + export function isFunctionLikeKind(kind: SyntaxKind): boolean { + switch (kind) { + case SyntaxKind.Constructor: + case SyntaxKind.FunctionExpression: + case SyntaxKind.FunctionDeclaration: + case SyntaxKind.ArrowFunction: + case SyntaxKind.MethodDeclaration: + case SyntaxKind.MethodSignature: + case SyntaxKind.GetAccessor: + case SyntaxKind.SetAccessor: + case SyntaxKind.CallSignature: + case SyntaxKind.ConstructSignature: + case SyntaxKind.IndexSignature: + case SyntaxKind.FunctionType: + case SyntaxKind.ConstructorType: + return true; } - return false; } export function introducesArgumentsExoticObject(node: Node) { @@ -1228,7 +1229,7 @@ namespace ts { case SyntaxKind.LabeledStatement: case SyntaxKind.ReturnStatement: case SyntaxKind.SwitchStatement: - case SyntaxKind.ThrowKeyword: + case SyntaxKind.ThrowStatement: case SyntaxKind.TryStatement: case SyntaxKind.VariableStatement: case SyntaxKind.WhileStatement: diff --git a/src/services/breakpoints.ts b/src/services/breakpoints.ts index 227ba6a79700e..e307b21979e26 100644 --- a/src/services/breakpoints.ts +++ b/src/services/breakpoints.ts @@ -446,7 +446,7 @@ namespace ts.BreakpointResolver { // fall through. case SyntaxKind.CatchClause: - return spanInNode(lastOrUndefined((node.parent).statements));; + return spanInNode(lastOrUndefined((node.parent).statements)); case SyntaxKind.CaseBlock: // breakpoint in last statement of the last clause @@ -493,9 +493,6 @@ namespace ts.BreakpointResolver { default: return spanInNode(node.parent); } - - // Default to parent node - return spanInNode(node.parent); } function spanInColonToken(node: Node): TextSpan { diff --git a/src/services/formatting/smartIndenter.ts b/src/services/formatting/smartIndenter.ts index 3b68cd0ebb275..de1d1b19cf256 100644 --- a/src/services/formatting/smartIndenter.ts +++ b/src/services/formatting/smartIndenter.ts @@ -360,7 +360,6 @@ namespace ts.formatting { return node; } } - return node; } } diff --git a/src/services/navigateTo.ts b/src/services/navigateTo.ts index bc506bc22f90f..2a0abba8695b7 100644 --- a/src/services/navigateTo.ts +++ b/src/services/navigateTo.ts @@ -6,6 +6,9 @@ namespace ts.NavigateTo { let patternMatcher = createPatternMatcher(searchValue); let rawItems: RawNavigateToItem[] = []; + // This means "compare in a case insensitive manner." + let baseSensitivity: Intl.CollatorOptions = { sensitivity: "base" }; + // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[] forEach(program.getSourceFiles(), sourceFile => { cancellationToken.throwIfCancellationRequested(); @@ -162,8 +165,6 @@ namespace ts.NavigateTo { return bestMatchKind; } - // This means "compare in a case insensitive manner." - let baseSensitivity: Intl.CollatorOptions = { sensitivity: "base" }; function compareNavigateToItems(i1: RawNavigateToItem, i2: RawNavigateToItem) { // TODO(cyrusn): get the gamut of comparisons that VS already uses here. // Right now we just sort by kind first, and then by name of the item. diff --git a/src/services/services.ts b/src/services/services.ts index 5815e2ab1d1c8..90e4abd96d4bd 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -4929,7 +4929,7 @@ namespace ts { else if (!isFunctionLike(node)) { forEachChild(node, aggregate); } - }; + } } /** @@ -4976,7 +4976,7 @@ namespace ts { else if (!isFunctionLike(node)) { forEachChild(node, aggregate); } - }; + } } function ownsBreakOrContinueStatement(owner: Node, statement: BreakOrContinueStatement): boolean { @@ -6285,8 +6285,6 @@ namespace ts { } return SemanticMeaning.Value | SemanticMeaning.Type | SemanticMeaning.Namespace; - - Debug.fail("Unknown declaration type"); } function isTypeReference(node: Node): boolean { diff --git a/src/services/shims.ts b/src/services/shims.ts index e919625395d0c..8482cb50975b6 100644 --- a/src/services/shims.ts +++ b/src/services/shims.ts @@ -323,7 +323,6 @@ namespace ts { // TODO: should this be '==='? if (settingsJson == null || settingsJson == "") { throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings"); - return null; } return JSON.parse(settingsJson); } diff --git a/tests/baselines/reference/ParameterList5.errors.txt b/tests/baselines/reference/ParameterList5.errors.txt index 02b86633b950d..618ce74091527 100644 --- a/tests/baselines/reference/ParameterList5.errors.txt +++ b/tests/baselines/reference/ParameterList5.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/ParameterList5.ts(1,15): 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/ParameterList5.ts(1,15): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. tests/cases/compiler/ParameterList5.ts(1,16): error TS2369: A parameter property is only allowed in a constructor implementation. tests/cases/compiler/ParameterList5.ts(1,29): error TS2304: Cannot find name 'C'. @@ -6,7 +6,7 @@ tests/cases/compiler/ParameterList5.ts(1,29): error TS2304: Cannot find name 'C' ==== tests/cases/compiler/ParameterList5.ts (3 errors) ==== function A(): (public B) => C { ~~~~~~~~~~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. ~~~~~~~~ !!! error TS2369: A parameter property is only allowed in a constructor implementation. ~ diff --git a/tests/baselines/reference/YieldExpression17_es6.errors.txt b/tests/baselines/reference/YieldExpression17_es6.errors.txt index bc2622125265e..f987517371f87 100644 --- a/tests/baselines/reference/YieldExpression17_es6.errors.txt +++ b/tests/baselines/reference/YieldExpression17_es6.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,15): error TS2378: A 'get' accessor must return a value. tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): error TS1163: A 'yield' expression is only allowed in a generator body. @@ -8,6 +8,6 @@ tests/cases/conformance/es6/yieldExpressions/YieldExpression17_es6.ts(1,23): err ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. ~~~~~ !!! error TS1163: A 'yield' expression is only allowed in a generator body. \ No newline at end of file diff --git a/tests/baselines/reference/assignmentLHSIsValue.errors.txt b/tests/baselines/reference/assignmentLHSIsValue.errors.txt index cf747b44b3e94..bf253df5e70d0 100644 --- a/tests/baselines/reference/assignmentLHSIsValue.errors.txt +++ b/tests/baselines/reference/assignmentLHSIsValue.errors.txt @@ -13,6 +13,7 @@ tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(2 tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(30,1): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(31,1): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(32,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(35,3): error TS7028: Unused label. tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(35,9): error TS1128: Declaration or statement expected. tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(38,2): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(38,6): error TS2364: Invalid left-hand side of assignment expression. @@ -38,7 +39,7 @@ tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(6 tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(70,1): error TS2364: Invalid left-hand side of assignment expression. -==== tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts (38 errors) ==== +==== tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts (39 errors) ==== // expected error for all the LHS of assignments var value; @@ -104,6 +105,8 @@ tests/cases/conformance/expressions/assignmentOperator/assignmentLHSIsValue.ts(7 // object literals { a: 0} = value; + ~ +!!! error TS7028: Unused label. ~ !!! error TS1128: Declaration or statement expected. diff --git a/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt b/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt index 2476eaec6e360..08e59e69b9f15 100644 --- a/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt +++ b/tests/baselines/reference/asyncArrowFunction10_es6.errors.txt @@ -1,7 +1,7 @@ tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,11): error TS2304: Cannot find name 'async'. tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,17): error TS1005: ',' expected. tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,20): error TS1005: '=' expected. -tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,24): 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/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(2,24): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts(4,11): error TS2304: Cannot find name 'await'. @@ -15,7 +15,7 @@ tests/cases/conformance/async/es6/asyncArrowFunction/asyncArrowFunction10_es6.ts ~ !!! error TS1005: '=' expected. ~~~~~~~~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. // Legal to use 'await' in a type context. var v: await; ~~~~~ diff --git a/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt b/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt index 978492f0744c8..43df8e21659cd 100644 --- a/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt +++ b/tests/baselines/reference/asyncFunctionDeclaration12_es6.errors.txt @@ -1,6 +1,6 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,24): error TS1005: '(' expected. tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,29): error TS1005: '=' expected. -tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,33): 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/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,33): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration12_es6.ts(1,47): error TS1005: '=>' expected. @@ -11,6 +11,6 @@ tests/cases/conformance/async/es6/functionDeclarations/asyncFunctionDeclaration1 ~ !!! error TS1005: '=' expected. ~~~~~~~~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. ~ !!! error TS1005: '=>' expected. \ No newline at end of file diff --git a/tests/baselines/reference/asyncGetter_es6.errors.txt b/tests/baselines/reference/asyncGetter_es6.errors.txt index 5f5a9f6b1d7f9..f6deea16d0699 100644 --- a/tests/baselines/reference/asyncGetter_es6.errors.txt +++ b/tests/baselines/reference/asyncGetter_es6.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/async/es6/asyncGetter_es6.ts(2,3): error TS1042: 'async' modifier cannot be used here. -tests/cases/conformance/async/es6/asyncGetter_es6.ts(2,13): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/async/es6/asyncGetter_es6.ts(2,13): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/async/es6/asyncGetter_es6.ts (2 errors) ==== @@ -8,6 +8,6 @@ tests/cases/conformance/async/es6/asyncGetter_es6.ts(2,13): error TS2378: A 'get ~~~~~ !!! error TS1042: 'async' modifier cannot be used here. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } } \ No newline at end of file diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.js b/tests/baselines/reference/bestCommonTypeReturnStatement.js index f4ab98ed1c68a..6d6f73bc0cfd6 100644 --- a/tests/baselines/reference/bestCommonTypeReturnStatement.js +++ b/tests/baselines/reference/bestCommonTypeReturnStatement.js @@ -1,4 +1,5 @@ //// [bestCommonTypeReturnStatement.ts] + interface IPromise { then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise; } diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.symbols b/tests/baselines/reference/bestCommonTypeReturnStatement.symbols index 43e04ef037d60..14e770ae2554b 100644 --- a/tests/baselines/reference/bestCommonTypeReturnStatement.symbols +++ b/tests/baselines/reference/bestCommonTypeReturnStatement.symbols @@ -1,34 +1,35 @@ === tests/cases/compiler/bestCommonTypeReturnStatement.ts === + interface IPromise { >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0)) ->T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 0, 19)) +>T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 1, 19)) then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise; ->then : Symbol(then, Decl(bestCommonTypeReturnStatement.ts, 0, 23)) ->successCallback : Symbol(successCallback, Decl(bestCommonTypeReturnStatement.ts, 1, 9)) ->promiseValue : Symbol(promiseValue, Decl(bestCommonTypeReturnStatement.ts, 1, 27)) ->T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 0, 19)) ->errorCallback : Symbol(errorCallback, Decl(bestCommonTypeReturnStatement.ts, 1, 51)) ->reason : Symbol(reason, Decl(bestCommonTypeReturnStatement.ts, 1, 69)) +>then : Symbol(then, Decl(bestCommonTypeReturnStatement.ts, 1, 23)) +>successCallback : Symbol(successCallback, Decl(bestCommonTypeReturnStatement.ts, 2, 9)) +>promiseValue : Symbol(promiseValue, Decl(bestCommonTypeReturnStatement.ts, 2, 27)) +>T : Symbol(T, Decl(bestCommonTypeReturnStatement.ts, 1, 19)) +>errorCallback : Symbol(errorCallback, Decl(bestCommonTypeReturnStatement.ts, 2, 51)) +>reason : Symbol(reason, Decl(bestCommonTypeReturnStatement.ts, 2, 69)) >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0)) } function f() { ->f : Symbol(f, Decl(bestCommonTypeReturnStatement.ts, 2, 1)) +>f : Symbol(f, Decl(bestCommonTypeReturnStatement.ts, 3, 1)) if (true) return b(); ->b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 7, 1)) +>b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 8, 1)) return d(); ->d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 10, 45)) +>d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 11, 45)) } function b(): IPromise { return null; } ->b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 7, 1)) +>b : Symbol(b, Decl(bestCommonTypeReturnStatement.ts, 8, 1)) >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0)) function d(): IPromise { return null; } ->d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 10, 45)) +>d : Symbol(d, Decl(bestCommonTypeReturnStatement.ts, 11, 45)) >IPromise : Symbol(IPromise, Decl(bestCommonTypeReturnStatement.ts, 0, 0)) diff --git a/tests/baselines/reference/bestCommonTypeReturnStatement.types b/tests/baselines/reference/bestCommonTypeReturnStatement.types index 28974f064a541..31f72ab93b4da 100644 --- a/tests/baselines/reference/bestCommonTypeReturnStatement.types +++ b/tests/baselines/reference/bestCommonTypeReturnStatement.types @@ -1,4 +1,5 @@ === tests/cases/compiler/bestCommonTypeReturnStatement.ts === + interface IPromise { >IPromise : IPromise >T : T diff --git a/tests/baselines/reference/breakTarget3.js b/tests/baselines/reference/breakTarget3.js index 0fa6cd2d2988a..b36eeb3902b75 100644 --- a/tests/baselines/reference/breakTarget3.js +++ b/tests/baselines/reference/breakTarget3.js @@ -1,4 +1,5 @@ //// [breakTarget3.ts] + target1: target2: while (true) { diff --git a/tests/baselines/reference/breakTarget3.symbols b/tests/baselines/reference/breakTarget3.symbols index 580706bbd4a46..a0b1743550481 100644 --- a/tests/baselines/reference/breakTarget3.symbols +++ b/tests/baselines/reference/breakTarget3.symbols @@ -1,5 +1,6 @@ === tests/cases/compiler/breakTarget3.ts === -target1: + +No type information for this code.target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. break target1; diff --git a/tests/baselines/reference/breakTarget3.types b/tests/baselines/reference/breakTarget3.types index 785bf00ef6e98..e4b5f8a1c6110 100644 --- a/tests/baselines/reference/breakTarget3.types +++ b/tests/baselines/reference/breakTarget3.types @@ -1,4 +1,5 @@ === tests/cases/compiler/breakTarget3.ts === + target1: >target1 : any diff --git a/tests/baselines/reference/breakTarget4.js b/tests/baselines/reference/breakTarget4.js index 4586301d71b7c..0c91e44ecbdf9 100644 --- a/tests/baselines/reference/breakTarget4.js +++ b/tests/baselines/reference/breakTarget4.js @@ -1,4 +1,5 @@ //// [breakTarget4.ts] + target1: target2: while (true) { diff --git a/tests/baselines/reference/breakTarget4.symbols b/tests/baselines/reference/breakTarget4.symbols index aba35ddcfdf3d..d4edcb17e1afd 100644 --- a/tests/baselines/reference/breakTarget4.symbols +++ b/tests/baselines/reference/breakTarget4.symbols @@ -1,5 +1,6 @@ === tests/cases/compiler/breakTarget4.ts === -target1: + +No type information for this code.target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. break target2; diff --git a/tests/baselines/reference/breakTarget4.types b/tests/baselines/reference/breakTarget4.types index eb4c14f638656..8b6ccf600ad32 100644 --- a/tests/baselines/reference/breakTarget4.types +++ b/tests/baselines/reference/breakTarget4.types @@ -1,4 +1,5 @@ === tests/cases/compiler/breakTarget4.ts === + target1: >target1 : any diff --git a/tests/baselines/reference/breakTarget5.errors.txt b/tests/baselines/reference/breakTarget5.errors.txt index a54a415b9907b..d92f29d67eea7 100644 --- a/tests/baselines/reference/breakTarget5.errors.txt +++ b/tests/baselines/reference/breakTarget5.errors.txt @@ -1,7 +1,8 @@ -tests/cases/compiler/breakTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary. +tests/cases/compiler/breakTarget5.ts(6,7): error TS1107: Jump target cannot cross function boundary. ==== tests/cases/compiler/breakTarget5.ts (1 errors) ==== + target: while (true) { function f() { diff --git a/tests/baselines/reference/breakTarget5.js b/tests/baselines/reference/breakTarget5.js index 197e4e147bd7e..9f6b063a8c4ea 100644 --- a/tests/baselines/reference/breakTarget5.js +++ b/tests/baselines/reference/breakTarget5.js @@ -1,4 +1,5 @@ //// [breakTarget5.ts] + target: while (true) { function f() { diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js index 0e78aac2b1b42..73270c240cb34 100644 --- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js +++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.js @@ -1,4 +1,5 @@ //// [callSignatureWithoutReturnTypeAnnotationInference.ts] + // Call signatures without a return type should infer one from the function body (if present) // Simple types diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols index 1c5a6786ab707..faba4e427ec18 100644 --- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols +++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.symbols @@ -1,55 +1,56 @@ === tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts === + // Call signatures without a return type should infer one from the function body (if present) // Simple types function foo(x) { >foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 3, 13)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 4, 13)) return 1; } var r = foo(1); ->r : Symbol(r, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 6, 3)) +>r : Symbol(r, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 3)) >foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0)) function foo2(x) { ->foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 6, 15)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 8, 14)) +>foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 15)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 9, 14)) return foo(x); >foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 0, 0)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 8, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 9, 14)) } var r2 = foo2(1); ->r2 : Symbol(r2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 3)) ->foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 6, 15)) +>r2 : Symbol(r2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 3)) +>foo2 : Symbol(foo2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 7, 15)) function foo3() { ->foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 17)) +>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17)) return foo3(); ->foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 17)) +>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17)) } var r3 = foo3(); ->r3 : Symbol(r3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 16, 3)) ->foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 11, 17)) +>r3 : Symbol(r3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 3)) +>foo3 : Symbol(foo3, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 12, 17)) function foo4(x: T) { ->foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 16, 16)) ->T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 14)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 17)) ->T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 14)) +>foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 16)) +>T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 17)) +>T : Symbol(T, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 14)) return x; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 18, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 19, 17)) } var r4 = foo4(1); ->r4 : Symbol(r4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 21, 3)) ->foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 16, 16)) +>r4 : Symbol(r4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 3)) +>foo4 : Symbol(foo4, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 17, 16)) function foo5(x) { ->foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 21, 17)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 23, 14)) +>foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 24, 14)) if (true) { return 1; @@ -58,17 +59,17 @@ function foo5(x) { } } var r5 = foo5(1); ->r5 : Symbol(r5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 30, 3)) ->foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 21, 17)) +>r5 : Symbol(r5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 3)) +>foo5 : Symbol(foo5, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 22, 17)) function foo6(x) { ->foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 30, 17)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 32, 14)) +>foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 33, 14)) try { } catch (e) { ->e : Symbol(e, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 35, 11)) +>e : Symbol(e, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 36, 11)) return []; } @@ -77,179 +78,179 @@ function foo6(x) { } } var r6 = foo6(1); ->r6 : Symbol(r6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 42, 3)) ->foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 30, 17)) +>r6 : Symbol(r6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 3)) +>foo6 : Symbol(foo6, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 31, 17)) function foo7(x) { ->foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 42, 17)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 44, 14)) +>foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 45, 14)) return typeof x; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 44, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 45, 14)) } var r7 = foo7(1); ->r7 : Symbol(r7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 47, 3)) ->foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 42, 17)) +>r7 : Symbol(r7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 3)) +>foo7 : Symbol(foo7, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 43, 17)) // object types function foo8(x: number) { ->foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 47, 17)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 50, 14)) +>foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 17)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 14)) return { x: x }; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 12)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 50, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 52, 12)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 51, 14)) } var r8 = foo8(1); ->r8 : Symbol(r8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 53, 3)) ->foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 47, 17)) +>r8 : Symbol(r8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 3)) +>foo8 : Symbol(foo8, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 48, 17)) interface I { ->I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 53, 17)) +>I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 17)) foo: string; ->foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 55, 13)) +>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 56, 13)) } function foo9(x: number) { ->foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 57, 1)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 14)) +>foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 1)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 14)) var i: I; ->i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 7)) ->I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 53, 17)) +>i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 60, 7)) +>I : Symbol(I, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 54, 17)) return i; ->i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 59, 7)) +>i : Symbol(i, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 60, 7)) } var r9 = foo9(1); ->r9 : Symbol(r9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 62, 3)) ->foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 57, 1)) +>r9 : Symbol(r9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 3)) +>foo9 : Symbol(foo9, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 58, 1)) class C { ->C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 62, 17)) +>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 17)) foo: string; ->foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 64, 9)) +>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 65, 9)) } function foo10(x: number) { ->foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 66, 1)) ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 15)) +>foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 1)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 15)) var c: C; ->c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 7)) ->C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 62, 17)) +>c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 69, 7)) +>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 63, 17)) return c; ->c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 68, 7)) +>c : Symbol(c, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 69, 7)) } var r10 = foo10(1); ->r10 : Symbol(r10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 71, 3)) ->foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 66, 1)) +>r10 : Symbol(r10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 3)) +>foo10 : Symbol(foo10, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 67, 1)) module M { ->M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 71, 19)) +>M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 19)) export var x = 1; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 74, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 14)) export class C { foo: string } ->C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 74, 21)) ->foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 20)) +>C : Symbol(C, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 75, 21)) +>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 20)) } function foo11() { ->foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 1)) +>foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 77, 1)) return M; ->M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 71, 19)) +>M : Symbol(M, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 72, 19)) } var r11 = foo11(); ->r11 : Symbol(r11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 3)) ->foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 76, 1)) +>r11 : Symbol(r11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 3)) +>foo11 : Symbol(foo11, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 77, 1)) // merged declarations interface I2 { ->I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 85, 1)) +>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1)) x: number; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 83, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 84, 14)) } interface I2 { ->I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 85, 1)) +>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1)) y: number; ->y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 14)) +>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 87, 14)) } function foo12() { ->foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 88, 1)) +>foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 89, 1)) var i2: I2; ->i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 90, 7)) ->I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 80, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 85, 1)) +>i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 91, 7)) +>I2 : Symbol(I2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 81, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 86, 1)) return i2; ->i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 90, 7)) +>i2 : Symbol(i2, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 91, 7)) } var r12 = foo12(); ->r12 : Symbol(r12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 3)) ->foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 88, 1)) +>r12 : Symbol(r12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 3)) +>foo12 : Symbol(foo12, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 89, 1)) function m1() { return 1; } ->m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 95, 27)) +>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27)) module m1 { export var y = 2; } ->m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 95, 27)) ->y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 22)) +>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27)) +>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 22)) function foo13() { ->foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 31)) +>foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 31)) return m1; ->m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 93, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 95, 27)) +>m1 : Symbol(m1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 94, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 27)) } var r13 = foo13(); ->r13 : Symbol(r13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 3)) ->foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 96, 31)) +>r13 : Symbol(r13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 3)) +>foo13 : Symbol(foo13, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 97, 31)) class c1 { ->c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 1)) +>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1)) foo: string; ->foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 102, 10)) +>foo : Symbol(foo, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 103, 10)) constructor(x) { } ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 104, 16)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 16)) } module c1 { ->c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 1)) +>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1)) export var x = 1; ->x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 107, 14)) +>x : Symbol(x, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 14)) } function foo14() { ->foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 1)) +>foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 109, 1)) return c1; ->c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 100, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 105, 1)) +>c1 : Symbol(c1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 101, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 106, 1)) } var r14 = foo14(); ->r14 : Symbol(r14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 3)) ->foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 108, 1)) +>r14 : Symbol(r14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 3)) +>foo14 : Symbol(foo14, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 109, 1)) enum e1 { A } ->e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 13)) ->A : Symbol(e1.A, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 9)) +>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13)) +>A : Symbol(e1.A, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 9)) module e1 { export var y = 1; } ->e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 13)) ->y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 22)) +>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13)) +>y : Symbol(y, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 22)) function foo15() { ->foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 31)) +>foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 31)) return e1; ->e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 112, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 114, 13)) +>e1 : Symbol(e1, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 113, 18), Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 13)) } var r15 = foo15(); ->r15 : Symbol(r15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 119, 3)) ->foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 115, 31)) +>r15 : Symbol(r15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 120, 3)) +>foo15 : Symbol(foo15, Decl(callSignatureWithoutReturnTypeAnnotationInference.ts, 116, 31)) diff --git a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types index 760451eb9c155..689ac62c35b68 100644 --- a/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types +++ b/tests/baselines/reference/callSignatureWithoutReturnTypeAnnotationInference.types @@ -1,4 +1,5 @@ === tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts === + // Call signatures without a return type should infer one from the function body (if present) // Simple types diff --git a/tests/baselines/reference/capturedLetConstInLoop9.js b/tests/baselines/reference/capturedLetConstInLoop9.js index ecdf54d6fd116..93aef628f8a6f 100644 --- a/tests/baselines/reference/capturedLetConstInLoop9.js +++ b/tests/baselines/reference/capturedLetConstInLoop9.js @@ -75,9 +75,8 @@ function foo() { break l0; } - return 100; - () => b + return 100; } @@ -207,8 +206,8 @@ function foo() { if (b === 2) { return "break-l0"; } - return { value: 100 }; (function () { return b; }); + return { value: 100 }; }; for (var _d = 0, _e = []; _d < _e.length; _d++) { var b = _e[_d]; diff --git a/tests/baselines/reference/capturedLetConstInLoop9.symbols b/tests/baselines/reference/capturedLetConstInLoop9.symbols index 5ccc1c399f3c0..37d1764b41b4d 100644 --- a/tests/baselines/reference/capturedLetConstInLoop9.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop9.symbols @@ -142,10 +142,10 @@ function foo() { break l0; } - return 100; - () => b >b : Symbol(b, Decl(capturedLetConstInLoop9.ts, 66, 16)) + + return 100; } @@ -171,25 +171,25 @@ function foo() { } function foo2() { ->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9.ts, 89, 1)) +>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9.ts, 88, 1)) for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12)) if (x === 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12)) break; } else if (x === 2) { ->x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12)) continue; } while (1 === 1) { if (x) { ->x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12)) break; } @@ -199,17 +199,17 @@ function foo2() { } switch(x) { ->x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12)) case 1: break; case 2: continue; } for (let y of []) { ->y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 114, 16)) +>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 113, 16)) switch(y) { ->y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 114, 16)) +>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 113, 16)) case 1: break; case 2: continue; @@ -219,50 +219,50 @@ function foo2() { } class C { ->C : Symbol(C, Decl(capturedLetConstInLoop9.ts, 121, 1)) +>C : Symbol(C, Decl(capturedLetConstInLoop9.ts, 120, 1)) constructor(private N: number) { } ->N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 124, 16)) +>N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 123, 16)) foo() { ->foo : Symbol(foo, Decl(capturedLetConstInLoop9.ts, 124, 38)) +>foo : Symbol(foo, Decl(capturedLetConstInLoop9.ts, 123, 38)) for (let i = 0; i < 100; i++) { ->i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 126, 16)) ->i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 126, 16)) ->i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 126, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 125, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 125, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 125, 16)) let f = () => this.N * i; ->f : Symbol(f, Decl(capturedLetConstInLoop9.ts, 127, 15)) ->this.N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 124, 16)) ->this : Symbol(C, Decl(capturedLetConstInLoop9.ts, 121, 1)) ->N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 124, 16)) ->i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 126, 16)) +>f : Symbol(f, Decl(capturedLetConstInLoop9.ts, 126, 15)) +>this.N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 123, 16)) +>this : Symbol(C, Decl(capturedLetConstInLoop9.ts, 120, 1)) +>N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 123, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 125, 16)) } } } function foo3 () { ->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9.ts, 130, 1)) +>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9.ts, 129, 1)) let x = arguments.length; ->x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 133, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 132, 7)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) for (let y of []) { ->y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 134, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 133, 12)) let z = arguments.length; ->z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 135, 11)) +>z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 134, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return y + z + arguments.length; }); ->y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 134, 12)) ->z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 135, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 133, 12)) +>z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 134, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/capturedLetConstInLoop9.types b/tests/baselines/reference/capturedLetConstInLoop9.types index 5a19361b02ec8..7f793ab66016d 100644 --- a/tests/baselines/reference/capturedLetConstInLoop9.types +++ b/tests/baselines/reference/capturedLetConstInLoop9.types @@ -197,12 +197,12 @@ function foo() { >l0 : any } - return 100; ->100 : number - () => b >() => b : () => any >b : any + + return 100; +>100 : number } diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.js b/tests/baselines/reference/capturedLetConstInLoop9_ES6.js index 4605cada8a309..0c9d8ea6a6879 100644 --- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.js +++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.js @@ -75,10 +75,8 @@ function foo() { if (b === 2) { break l0; } - - return 100; - () => b + return 100; } @@ -198,8 +196,8 @@ function foo() { if (b === 2) { break l0; } - return 100; (() => b); + return 100; } (() => a); } diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols index d1d124b85f7a0..d71a20afe47d0 100644 --- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols +++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols @@ -142,11 +142,10 @@ function foo() { break l0; } - - return 100; - () => b >b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16)) + + return 100; } @@ -172,25 +171,25 @@ function foo() { } function foo2() { ->foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9_ES6.ts, 90, 1)) +>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9_ES6.ts, 88, 1)) for (let x of []) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) if (x === 1) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) break; } else if (x === 2) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) continue; } while (1 === 1) { if (x) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) break; } @@ -200,17 +199,17 @@ function foo2() { } switch(x) { ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12)) case 1: break; case 2: continue; } for (let y of []) { ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 115, 16)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 113, 16)) switch(y) { ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 115, 16)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 113, 16)) case 1: break; case 2: continue; @@ -220,50 +219,50 @@ function foo2() { } class C { ->C : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 122, 1)) +>C : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 120, 1)) constructor(private N: number) { } ->N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) +>N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16)) foo() { ->foo : Symbol(foo, Decl(capturedLetConstInLoop9_ES6.ts, 125, 38)) +>foo : Symbol(foo, Decl(capturedLetConstInLoop9_ES6.ts, 123, 38)) for (let i = 0; i < 100; i++) { ->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 127, 16)) ->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 127, 16)) ->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 127, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) let f = () => this.N * i; ->f : Symbol(f, Decl(capturedLetConstInLoop9_ES6.ts, 128, 15)) ->this.N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) ->this : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 122, 1)) ->N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) ->i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 127, 16)) +>f : Symbol(f, Decl(capturedLetConstInLoop9_ES6.ts, 126, 15)) +>this.N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16)) +>this : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 120, 1)) +>N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16)) +>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16)) } } } function foo3 () { ->foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9_ES6.ts, 131, 1)) +>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9_ES6.ts, 129, 1)) let x = arguments.length; ->x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 134, 7)) +>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 132, 7)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) for (let y of []) { ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 135, 12)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 133, 12)) let z = arguments.length; ->z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 136, 11)) +>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 134, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) (function() { return y + z + arguments.length; }); ->y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 135, 12)) ->z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 136, 11)) +>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 133, 12)) +>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 134, 11)) >arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) >arguments : Symbol(arguments) >length : Symbol(IArguments.length, Decl(lib.d.ts, --, --)) diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.types b/tests/baselines/reference/capturedLetConstInLoop9_ES6.types index e5afe21a29f3d..dfbfa387ed409 100644 --- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.types +++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.types @@ -197,13 +197,12 @@ function foo() { break l0; >l0 : any } - - return 100; ->100 : number - () => b >() => b : () => any >b : any + + return 100; +>100 : number } diff --git a/tests/baselines/reference/cf.errors.txt b/tests/baselines/reference/cf.errors.txt new file mode 100644 index 0000000000000..75b285c37c647 --- /dev/null +++ b/tests/baselines/reference/cf.errors.txt @@ -0,0 +1,72 @@ +tests/cases/compiler/cf.ts(9,13): error TS7027: Unreachable code detected. +tests/cases/compiler/cf.ts(21,17): error TS7027: Unreachable code detected. +tests/cases/compiler/cf.ts(32,13): error TS7027: Unreachable code detected. +tests/cases/compiler/cf.ts(36,13): error TS7027: Unreachable code detected. + + +==== tests/cases/compiler/cf.ts (4 errors) ==== + function f() { + var z; + var x=10; + var y=3; + + L1: for (var i=0;i<19;i++) { + if (y==7) { + continue L1; + x=11; + ~ +!!! error TS7027: Unreachable code detected. + } + if (y==3) { + y++; + } + else { + y--; + } + do { + y+=2; + if (y==20) { + break; + x=12; + ~ +!!! error TS7027: Unreachable code detected. + } + } while (y<41); + y++; + } + while (y>2) { + y=y>>1; + } + L2: try { + L3: if (xf : Symbol(f, Decl(cf.ts, 0, 0)) - - var z; ->z : Symbol(z, Decl(cf.ts, 1, 7)) - - var x=10; ->x : Symbol(x, Decl(cf.ts, 2, 7)) - - var y=3; ->y : Symbol(y, Decl(cf.ts, 3, 7)) - - L1: for (var i=0;i<19;i++) { ->i : Symbol(i, Decl(cf.ts, 5, 16)) ->i : Symbol(i, Decl(cf.ts, 5, 16)) ->i : Symbol(i, Decl(cf.ts, 5, 16)) - - if (y==7) { ->y : Symbol(y, Decl(cf.ts, 3, 7)) - - continue L1; - x=11; ->x : Symbol(x, Decl(cf.ts, 2, 7)) - } - if (y==3) { ->y : Symbol(y, Decl(cf.ts, 3, 7)) - - y++; ->y : Symbol(y, Decl(cf.ts, 3, 7)) - } - else { - y--; ->y : Symbol(y, Decl(cf.ts, 3, 7)) - } - do { - y+=2; ->y : Symbol(y, Decl(cf.ts, 3, 7)) - - if (y==20) { ->y : Symbol(y, Decl(cf.ts, 3, 7)) - - break; - x=12; ->x : Symbol(x, Decl(cf.ts, 2, 7)) - } - } while (y<41); ->y : Symbol(y, Decl(cf.ts, 3, 7)) - - y++; ->y : Symbol(y, Decl(cf.ts, 3, 7)) - } - while (y>2) { ->y : Symbol(y, Decl(cf.ts, 3, 7)) - - y=y>>1; ->y : Symbol(y, Decl(cf.ts, 3, 7)) ->y : Symbol(y, Decl(cf.ts, 3, 7)) - } - L2: try { - L3: if (xx : Symbol(x, Decl(cf.ts, 2, 7)) ->y : Symbol(y, Decl(cf.ts, 3, 7)) - - break L2; - x=13; ->x : Symbol(x, Decl(cf.ts, 2, 7)) - } - else { - break L3; - x=14; ->x : Symbol(x, Decl(cf.ts, 2, 7)) - } - } - catch (e) { ->e : Symbol(e, Decl(cf.ts, 38, 11)) - - x++; ->x : Symbol(x, Decl(cf.ts, 2, 7)) - } - finally { - x+=3; ->x : Symbol(x, Decl(cf.ts, 2, 7)) - } - y++; ->y : Symbol(y, Decl(cf.ts, 3, 7)) - - for (var k=0;k<10;k++) { ->k : Symbol(k, Decl(cf.ts, 45, 12)) ->k : Symbol(k, Decl(cf.ts, 45, 12)) ->k : Symbol(k, Decl(cf.ts, 45, 12)) - - z; ->z : Symbol(z, Decl(cf.ts, 1, 7)) - - break; - } - for (k=0;k<10;k++) { ->k : Symbol(k, Decl(cf.ts, 45, 12)) ->k : Symbol(k, Decl(cf.ts, 45, 12)) ->k : Symbol(k, Decl(cf.ts, 45, 12)) - - if (k==6) { ->k : Symbol(k, Decl(cf.ts, 45, 12)) - - continue; - } - break; - } -} - diff --git a/tests/baselines/reference/cf.types b/tests/baselines/reference/cf.types deleted file mode 100644 index 397e3469ece2e..0000000000000 --- a/tests/baselines/reference/cf.types +++ /dev/null @@ -1,169 +0,0 @@ -=== tests/cases/compiler/cf.ts === -function f() { ->f : () => void - - var z; ->z : any - - var x=10; ->x : number ->10 : number - - var y=3; ->y : number ->3 : number - - L1: for (var i=0;i<19;i++) { ->L1 : any ->i : number ->0 : number ->i<19 : boolean ->i : number ->19 : number ->i++ : number ->i : number - - if (y==7) { ->y==7 : boolean ->y : number ->7 : number - - continue L1; ->L1 : any - - x=11; ->x=11 : number ->x : number ->11 : number - } - if (y==3) { ->y==3 : boolean ->y : number ->3 : number - - y++; ->y++ : number ->y : number - } - else { - y--; ->y-- : number ->y : number - } - do { - y+=2; ->y+=2 : number ->y : number ->2 : number - - if (y==20) { ->y==20 : boolean ->y : number ->20 : number - - break; - x=12; ->x=12 : number ->x : number ->12 : number - } - } while (y<41); ->y<41 : boolean ->y : number ->41 : number - - y++; ->y++ : number ->y : number - } - while (y>2) { ->y>2 : boolean ->y : number ->2 : number - - y=y>>1; ->y=y>>1 : number ->y : number ->y>>1 : number ->y : number ->1 : number - } - L2: try { ->L2 : any - - L3: if (xL3 : any ->xx : number ->y : number - - break L2; ->L2 : any - - x=13; ->x=13 : number ->x : number ->13 : number - } - else { - break L3; ->L3 : any - - x=14; ->x=14 : number ->x : number ->14 : number - } - } - catch (e) { ->e : any - - x++; ->x++ : number ->x : number - } - finally { - x+=3; ->x+=3 : number ->x : number ->3 : number - } - y++; ->y++ : number ->y : number - - for (var k=0;k<10;k++) { ->k : number ->0 : number ->k<10 : boolean ->k : number ->10 : number ->k++ : number ->k : number - - z; ->z : any - - break; - } - for (k=0;k<10;k++) { ->k=0 : number ->k : number ->0 : number ->k<10 : boolean ->k : number ->10 : number ->k++ : number ->k : number - - if (k==6) { ->k==6 : boolean ->k : number ->6 : number - - continue; - } - break; - } -} - diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.js b/tests/baselines/reference/commentEmitAtEndOfFile1.js index 1be031fa84af6..cada7754002a7 100644 --- a/tests/baselines/reference/commentEmitAtEndOfFile1.js +++ b/tests/baselines/reference/commentEmitAtEndOfFile1.js @@ -1,4 +1,5 @@ //// [commentEmitAtEndOfFile1.ts] + // test var f = '' // test #2 diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.symbols b/tests/baselines/reference/commentEmitAtEndOfFile1.symbols index 1fc0ad0955348..cb06d088307c7 100644 --- a/tests/baselines/reference/commentEmitAtEndOfFile1.symbols +++ b/tests/baselines/reference/commentEmitAtEndOfFile1.symbols @@ -1,17 +1,18 @@ === tests/cases/compiler/commentEmitAtEndOfFile1.ts === + // test var f = '' ->f : Symbol(f, Decl(commentEmitAtEndOfFile1.ts, 1, 3)) +>f : Symbol(f, Decl(commentEmitAtEndOfFile1.ts, 2, 3)) // test #2 module foo { ->foo : Symbol(foo, Decl(commentEmitAtEndOfFile1.ts, 1, 10)) +>foo : Symbol(foo, Decl(commentEmitAtEndOfFile1.ts, 2, 10)) function bar() { } ->bar : Symbol(bar, Decl(commentEmitAtEndOfFile1.ts, 3, 12)) +>bar : Symbol(bar, Decl(commentEmitAtEndOfFile1.ts, 4, 12)) } // test #3 module empty { ->empty : Symbol(empty, Decl(commentEmitAtEndOfFile1.ts, 5, 1)) +>empty : Symbol(empty, Decl(commentEmitAtEndOfFile1.ts, 6, 1)) } // test #4 diff --git a/tests/baselines/reference/commentEmitAtEndOfFile1.types b/tests/baselines/reference/commentEmitAtEndOfFile1.types index d88d7ffa5fcda..f96a1069a06cf 100644 --- a/tests/baselines/reference/commentEmitAtEndOfFile1.types +++ b/tests/baselines/reference/commentEmitAtEndOfFile1.types @@ -1,4 +1,5 @@ === tests/cases/compiler/commentEmitAtEndOfFile1.ts === + // test var f = '' >f : string diff --git a/tests/baselines/reference/commentsAtEndOfFile1.js b/tests/baselines/reference/commentsAtEndOfFile1.js index 2d4dae39e6ba3..d93dded59b062 100644 --- a/tests/baselines/reference/commentsAtEndOfFile1.js +++ b/tests/baselines/reference/commentsAtEndOfFile1.js @@ -1,4 +1,5 @@ //// [commentsAtEndOfFile1.ts] + Input: ; //Testing two diff --git a/tests/baselines/reference/commentsAtEndOfFile1.symbols b/tests/baselines/reference/commentsAtEndOfFile1.symbols index c09a435f1a7fe..d35b4f251f6ab 100644 --- a/tests/baselines/reference/commentsAtEndOfFile1.symbols +++ b/tests/baselines/reference/commentsAtEndOfFile1.symbols @@ -1,5 +1,6 @@ === tests/cases/compiler/commentsAtEndOfFile1.ts === -Input: + +No type information for this code.Input: No type information for this code.; No type information for this code.//Testing two No type information for this code. diff --git a/tests/baselines/reference/commentsAtEndOfFile1.types b/tests/baselines/reference/commentsAtEndOfFile1.types index 6bac675706143..71eb367738b1a 100644 --- a/tests/baselines/reference/commentsAtEndOfFile1.types +++ b/tests/baselines/reference/commentsAtEndOfFile1.types @@ -1,4 +1,5 @@ === tests/cases/compiler/commentsAtEndOfFile1.ts === + Input: >Input : any diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt b/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt index 7b26fc4bf9e04..392e1781dd5f5 100644 --- a/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt +++ b/tests/baselines/reference/compoundAssignmentLHSIsValue.errors.txt @@ -1,80 +1,81 @@ -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(7,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(8,9): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(11,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(12,9): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(15,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(16,9): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(21,5): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(8,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(9,9): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(12,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(13,9): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(16,9): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(17,9): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(22,5): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(25,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(23,5): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(26,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(30,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(31,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(33,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(34,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(37,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(38,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(40,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(41,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(44,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(27,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(31,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(32,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(34,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(35,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(38,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(39,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(41,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(42,1): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(45,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(46,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(47,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(48,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(49,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(46,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(47,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(48,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(49,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(50,1): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(51,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(52,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(53,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(54,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(55,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(58,9): error TS1128: Declaration or statement expected. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(52,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(53,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(54,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(55,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(56,1): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(59,9): error TS1128: Declaration or statement expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(62,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(63,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(69,15): error TS1034: 'super' must be followed by an argument list or member access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(60,9): error TS1128: Declaration or statement expected. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(63,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(64,1): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(70,15): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(74,15): error TS1034: 'super' must be followed by an argument list or member access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(71,15): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(75,15): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(79,15): error TS1034: 'super' must be followed by an argument list or member access. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(76,15): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(80,15): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(85,21): error TS1128: Declaration or statement expected. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(81,15): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(86,21): error TS1128: Declaration or statement expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(87,11): error TS1005: ';' expected. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(87,21): error TS1128: Declaration or statement expected. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(88,11): error TS1005: ';' expected. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(91,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(92,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(95,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(89,11): error TS1005: ';' expected. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(92,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(93,1): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(96,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(97,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(98,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(99,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(100,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(101,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(102,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(103,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(104,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(97,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(98,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(99,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(100,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(101,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(102,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(103,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(104,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(105,1): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(106,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(107,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(108,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(107,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(108,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(109,1): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(110,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(111,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(112,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(113,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(114,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(115,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(116,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(117,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(118,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(119,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(120,1): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(121,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(122,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(111,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(112,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(113,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(114,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(115,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(116,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(117,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(118,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(119,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(120,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(121,1): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(122,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts(123,1): error TS2364: Invalid left-hand side of assignment expression. ==== tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts (74 errors) ==== + // expected error for all the LHS of compound assignments (arithmetic and addition) var value; diff --git a/tests/baselines/reference/compoundAssignmentLHSIsValue.js b/tests/baselines/reference/compoundAssignmentLHSIsValue.js index 833c1e1ea7c1e..bf66183b70a62 100644 --- a/tests/baselines/reference/compoundAssignmentLHSIsValue.js +++ b/tests/baselines/reference/compoundAssignmentLHSIsValue.js @@ -1,4 +1,5 @@ //// [compoundAssignmentLHSIsValue.ts] + // expected error for all the LHS of compound assignments (arithmetic and addition) var value; diff --git a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt index bee6f75ff5cbe..23720468bb7d5 100644 --- a/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt +++ b/tests/baselines/reference/compoundExponentiationAssignmentLHSIsValue.errors.txt @@ -13,6 +13,7 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(38,1): error TS2364: Invalid left-hand side of assignment expression. tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(39,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(40,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(43,3): error TS7028: Unused label. tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(43,10): error TS1128: Declaration or statement expected. tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(46,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(52,15): error TS1034: 'super' must be followed by an argument list or member access. @@ -37,7 +38,7 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts(85,1): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -==== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts (37 errors) ==== +==== tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignmentLHSIsValue.ts (38 errors) ==== // expected error for all the LHS of compound assignments (arithmetic and addition) var value; @@ -111,6 +112,8 @@ tests/cases/conformance/es7/exponentiationOperator/compoundExponentiationAssignm // object literals { a: 0 } **= value; + ~ +!!! error TS7028: Unused label. ~~~ !!! error TS1128: Declaration or statement expected. diff --git a/tests/baselines/reference/computedPropertyNames2_ES5.errors.txt b/tests/baselines/reference/computedPropertyNames2_ES5.errors.txt index 2fbf68b443770..e704126c055f4 100644 --- a/tests/baselines/reference/computedPropertyNames2_ES5.errors.txt +++ b/tests/baselines/reference/computedPropertyNames2_ES5.errors.txt @@ -1,5 +1,5 @@ -tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES5.ts(6,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. -tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES5.ts(8,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES5.ts(6,9): error TS2378: A 'get' accessor must return a value. +tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES5.ts(8,16): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES5.ts (2 errors) ==== @@ -10,10 +10,10 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES5.ts(8,1 static [methodName]() { } get [accessorName]() { } ~~~~~~~~~~~~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. set [accessorName](v) { } static get [accessorName]() { } ~~~~~~~~~~~~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. static set [accessorName](v) { } } \ No newline at end of file diff --git a/tests/baselines/reference/computedPropertyNames2_ES6.errors.txt b/tests/baselines/reference/computedPropertyNames2_ES6.errors.txt index 3f18a8764b40e..6b2949816385f 100644 --- a/tests/baselines/reference/computedPropertyNames2_ES6.errors.txt +++ b/tests/baselines/reference/computedPropertyNames2_ES6.errors.txt @@ -1,5 +1,5 @@ -tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES6.ts(6,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. -tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES6.ts(8,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES6.ts(6,9): error TS2378: A 'get' accessor must return a value. +tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES6.ts(8,16): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES6.ts (2 errors) ==== @@ -10,10 +10,10 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames2_ES6.ts(8,1 static [methodName]() { } get [accessorName]() { } ~~~~~~~~~~~~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. set [accessorName](v) { } static get [accessorName]() { } ~~~~~~~~~~~~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. static set [accessorName](v) { } } \ No newline at end of file diff --git a/tests/baselines/reference/computedPropertyNames3_ES5.errors.txt b/tests/baselines/reference/computedPropertyNames3_ES5.errors.txt index a31965dc69e9a..fd6f8e8bdc1c6 100644 --- a/tests/baselines/reference/computedPropertyNames3_ES5.errors.txt +++ b/tests/baselines/reference/computedPropertyNames3_ES5.errors.txt @@ -1,9 +1,9 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(4,12): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. -tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(5,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(5,9): error TS2378: A 'get' accessor must return a value. tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(5,9): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(5,17): error TS1102: 'delete' cannot be called on an identifier in strict mode. tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(6,9): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. -tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,16): error TS2378: A 'get' accessor must return a value. tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,16): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. @@ -16,7 +16,7 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,1 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. get [delete id]() { } ~~~~~~~~~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. ~~~~~~~~~~~ !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. ~~ @@ -26,7 +26,7 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES5.ts(7,1 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. static get [""]() { } ~~~~~~~~~~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. ~~~~~~~~~~~~ !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. static set [id.toString()](v) { } diff --git a/tests/baselines/reference/computedPropertyNames3_ES6.errors.txt b/tests/baselines/reference/computedPropertyNames3_ES6.errors.txt index b90091123473a..4299437777d5e 100644 --- a/tests/baselines/reference/computedPropertyNames3_ES6.errors.txt +++ b/tests/baselines/reference/computedPropertyNames3_ES6.errors.txt @@ -1,9 +1,9 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(4,12): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. -tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(5,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(5,9): error TS2378: A 'get' accessor must return a value. tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(5,9): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(5,17): error TS1102: 'delete' cannot be called on an identifier in strict mode. tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(6,9): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. -tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(7,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(7,16): error TS2378: A 'get' accessor must return a value. tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(7,16): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. @@ -16,7 +16,7 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(7,1 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. get [delete id]() { } ~~~~~~~~~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. ~~~~~~~~~~~ !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. ~~ @@ -26,7 +26,7 @@ tests/cases/conformance/es6/computedProperties/computedPropertyNames3_ES6.ts(7,1 !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. static get [""]() { } ~~~~~~~~~~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. ~~~~~~~~~~~~ !!! error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'. static set [id.toString()](v) { } diff --git a/tests/baselines/reference/conditionalExpressions2.js b/tests/baselines/reference/conditionalExpressions2.js index 6749a2c0ac080..8ac7df12cfa25 100644 --- a/tests/baselines/reference/conditionalExpressions2.js +++ b/tests/baselines/reference/conditionalExpressions2.js @@ -1,4 +1,5 @@ //// [conditionalExpressions2.ts] + var a = false ? 1 : null; var b = false ? undefined : 0; var c = false ? 1 : 0; diff --git a/tests/baselines/reference/conditionalExpressions2.symbols b/tests/baselines/reference/conditionalExpressions2.symbols index 63c8b41747756..e6edd635b4043 100644 --- a/tests/baselines/reference/conditionalExpressions2.symbols +++ b/tests/baselines/reference/conditionalExpressions2.symbols @@ -1,33 +1,34 @@ === tests/cases/compiler/conditionalExpressions2.ts === + var a = false ? 1 : null; ->a : Symbol(a, Decl(conditionalExpressions2.ts, 0, 3)) +>a : Symbol(a, Decl(conditionalExpressions2.ts, 1, 3)) var b = false ? undefined : 0; ->b : Symbol(b, Decl(conditionalExpressions2.ts, 1, 3)) +>b : Symbol(b, Decl(conditionalExpressions2.ts, 2, 3)) >undefined : Symbol(undefined) var c = false ? 1 : 0; ->c : Symbol(c, Decl(conditionalExpressions2.ts, 2, 3)) +>c : Symbol(c, Decl(conditionalExpressions2.ts, 3, 3)) var d = false ? false : true; ->d : Symbol(d, Decl(conditionalExpressions2.ts, 3, 3)) +>d : Symbol(d, Decl(conditionalExpressions2.ts, 4, 3)) var e = false ? "foo" : "bar"; ->e : Symbol(e, Decl(conditionalExpressions2.ts, 4, 3)) +>e : Symbol(e, Decl(conditionalExpressions2.ts, 5, 3)) var f = false ? null : undefined; ->f : Symbol(f, Decl(conditionalExpressions2.ts, 5, 3)) +>f : Symbol(f, Decl(conditionalExpressions2.ts, 6, 3)) >undefined : Symbol(undefined) var g = true ? {g:5} : null; ->g : Symbol(g, Decl(conditionalExpressions2.ts, 6, 3)) ->g : Symbol(g, Decl(conditionalExpressions2.ts, 6, 16)) +>g : Symbol(g, Decl(conditionalExpressions2.ts, 7, 3)) +>g : Symbol(g, Decl(conditionalExpressions2.ts, 7, 16)) var h = [{h:5}, null]; ->h : Symbol(h, Decl(conditionalExpressions2.ts, 7, 3)) ->h : Symbol(h, Decl(conditionalExpressions2.ts, 7, 10)) +>h : Symbol(h, Decl(conditionalExpressions2.ts, 8, 3)) +>h : Symbol(h, Decl(conditionalExpressions2.ts, 8, 10)) function i() { if (true) { return { x: 5 }; } else { return null; } } ->i : Symbol(i, Decl(conditionalExpressions2.ts, 7, 22)) ->x : Symbol(x, Decl(conditionalExpressions2.ts, 8, 35)) +>i : Symbol(i, Decl(conditionalExpressions2.ts, 8, 22)) +>x : Symbol(x, Decl(conditionalExpressions2.ts, 9, 35)) diff --git a/tests/baselines/reference/conditionalExpressions2.types b/tests/baselines/reference/conditionalExpressions2.types index 5f49410b1e4ac..77714e664fb01 100644 --- a/tests/baselines/reference/conditionalExpressions2.types +++ b/tests/baselines/reference/conditionalExpressions2.types @@ -1,4 +1,5 @@ === tests/cases/compiler/conditionalExpressions2.ts === + var a = false ? 1 : null; >a : number >false ? 1 : null : number diff --git a/tests/baselines/reference/conflictingTypeAnnotatedVar.errors.txt b/tests/baselines/reference/conflictingTypeAnnotatedVar.errors.txt index 0b667108b5f0d..afae9d4043191 100644 --- a/tests/baselines/reference/conflictingTypeAnnotatedVar.errors.txt +++ b/tests/baselines/reference/conflictingTypeAnnotatedVar.errors.txt @@ -1,8 +1,8 @@ tests/cases/compiler/conflictingTypeAnnotatedVar.ts(1,5): error TS2300: Duplicate identifier 'foo'. tests/cases/compiler/conflictingTypeAnnotatedVar.ts(2,10): error TS2300: Duplicate identifier 'foo'. -tests/cases/compiler/conflictingTypeAnnotatedVar.ts(2,17): 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/conflictingTypeAnnotatedVar.ts(2,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. tests/cases/compiler/conflictingTypeAnnotatedVar.ts(3,10): error TS2300: Duplicate identifier 'foo'. -tests/cases/compiler/conflictingTypeAnnotatedVar.ts(3,17): 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/conflictingTypeAnnotatedVar.ts(3,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. ==== tests/cases/compiler/conflictingTypeAnnotatedVar.ts (5 errors) ==== @@ -13,9 +13,9 @@ tests/cases/compiler/conflictingTypeAnnotatedVar.ts(3,17): error TS2355: A funct ~~~ !!! error TS2300: Duplicate identifier 'foo'. ~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. function foo(): number { } ~~~ !!! error TS2300: Duplicate identifier 'foo'. ~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. \ No newline at end of file +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. \ No newline at end of file diff --git a/tests/baselines/reference/constDeclarations-scopes.errors.txt b/tests/baselines/reference/constDeclarations-scopes.errors.txt index 138acd9b16d1c..4c9f7ce51633f 100644 --- a/tests/baselines/reference/constDeclarations-scopes.errors.txt +++ b/tests/baselines/reference/constDeclarations-scopes.errors.txt @@ -1,7 +1,9 @@ +tests/cases/compiler/constDeclarations-scopes.ts(13,5): error TS7027: Unreachable code detected. +tests/cases/compiler/constDeclarations-scopes.ts(22,1): error TS7027: Unreachable code detected. tests/cases/compiler/constDeclarations-scopes.ts(28,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'. -==== tests/cases/compiler/constDeclarations-scopes.ts (1 errors) ==== +==== tests/cases/compiler/constDeclarations-scopes.ts (3 errors) ==== // global const c = "string"; @@ -15,6 +17,8 @@ tests/cases/compiler/constDeclarations-scopes.ts(28,7): error TS2410: All symbol } else { const c = 0; + ~~~~~ +!!! error TS7027: Unreachable code detected. n = c; } @@ -24,6 +28,8 @@ tests/cases/compiler/constDeclarations-scopes.ts(28,7): error TS2410: All symbol } do { + ~~ +!!! error TS7027: Unreachable code detected. const c = 0; n = c; } while (true); diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt index 12f397ff06c59..b9804b1b6dbcb 100644 --- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt +++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.errors.txt @@ -1,89 +1,90 @@ -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2304: Cannot find name 'module'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,13): error TS2503: Cannot find namespace 'module'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(11,19): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(22,35): error TS1005: ')' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(22,39): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(24,28): error TS1005: ':' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(24,29): error TS1005: ',' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(27,18): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(27,26): error TS2304: Cannot find name 'bfs'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,30): error TS1005: '=' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(31,18): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,26): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(34,28): error TS2304: Cannot find name 'bfs'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(38,17): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,28): error TS2304: Cannot find name 'bfs'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,41): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(40,45): error TS1002: Unterminated string literal. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(47,17): error TS2304: Cannot find name 'console'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(49,13): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(53,13): error TS2304: Cannot find name 'console'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(58,5): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(69,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(72,37): error TS1127: Invalid character. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(81,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(89,23): error TS2364: Invalid left-hand side of assignment expression. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(90,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(105,29): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(106,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(108,24): error TS2365: Operator '+' cannot be applied to types 'number' and 'boolean'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(138,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(141,32): error TS1005: '{' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(143,13): error TS1005: 'try' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,24): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,30): error TS1005: '(' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(159,31): error TS2304: Cannot find name 'Property'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(166,13): error TS2365: Operator '+=' cannot be applied to types 'number' and 'void'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(180,40): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(205,28): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(213,16): error TS2304: Cannot find name 'bool'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(218,10): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(223,23): error TS2304: Cannot find name 'bool'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(227,13): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(234,14): error TS1005: '{' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,9): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,16): error TS2304: Cannot find name 'method1'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,24): error TS2304: Cannot find name 'val'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,27): error TS1005: ',' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,28): error TS2304: Cannot find name 'number'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,36): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,9): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,16): error TS2304: Cannot find name 'method2'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(238,26): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(241,5): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(246,25): error TS2339: Property 'method1' does not exist on type 'B'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,9): error TS2390: Constructor implementation is missing. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,21): error TS2369: A parameter property is only allowed in a constructor implementation. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,44): error TS2369: A parameter property is only allowed in a constructor implementation. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(254,69): error TS1110: Type expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,9): error TS1128: Declaration or statement expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,16): error TS2304: Cannot find name 'Overloads'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,26): error TS2304: Cannot find name 'value'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,31): error TS1005: ',' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(256,33): error TS2304: Cannot find name 'string'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,13): error TS2304: Cannot find name 'module'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,13): error TS2503: Cannot find namespace 'module'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(12,19): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(23,35): error TS1005: ')' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(23,39): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(25,28): error TS1005: ':' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(25,29): error TS1005: ',' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,18): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(28,26): error TS2304: Cannot find name 'bfs'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(29,30): error TS1005: '=' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(32,18): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,17): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,26): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(35,28): error TS2304: Cannot find name 'bfs'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(36,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(39,17): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,28): error TS2304: Cannot find name 'bfs'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,41): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(41,45): error TS1002: Unterminated string literal. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(42,21): error TS2365: Operator '!=' cannot be applied to types 'boolean' and 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(48,17): error TS2304: Cannot find name 'console'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(50,13): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(54,13): error TS2304: Cannot find name 'console'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(59,5): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(70,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(73,37): error TS1127: Invalid character. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(82,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(90,23): error TS2364: Invalid left-hand side of assignment expression. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(91,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(106,29): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(107,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(109,24): error TS2365: Operator '+' cannot be applied to types 'number' and 'boolean'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(139,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(142,32): error TS1005: '{' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(144,13): error TS1005: 'try' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,24): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,30): error TS1005: '(' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(160,31): error TS2304: Cannot find name 'Property'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(167,13): error TS2365: Operator '+=' cannot be applied to types 'number' and 'void'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(181,40): error TS2447: The '^' operator is not allowed for boolean types. Consider using '!==' instead. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(206,28): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(214,16): error TS2304: Cannot find name 'bool'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(219,10): error TS1068: Unexpected token. A constructor, method, accessor, or property was expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(224,23): error TS2304: Cannot find name 'bool'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(228,13): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(235,14): error TS1005: '{' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,9): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,16): error TS2304: Cannot find name 'method1'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,24): error TS2304: Cannot find name 'val'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,27): error TS1005: ',' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,28): error TS2304: Cannot find name 'number'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(236,36): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,9): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,16): error TS2304: Cannot find name 'method2'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(239,26): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(242,5): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(247,25): error TS2339: Property 'method1' does not exist on type 'B'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,9): error TS2390: Constructor implementation is missing. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,21): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,44): error TS2369: A parameter property is only allowed in a constructor implementation. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(255,69): error TS1110: Type expected. tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,9): error TS1128: Declaration or statement expected. tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,16): error TS2304: Cannot find name 'Overloads'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,27): error TS1135: Argument expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,33): error TS1005: '(' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,35): error TS2304: Cannot find name 'string'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,43): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,52): error TS2304: Cannot find name 'string'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,60): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,65): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,9): error TS2304: Cannot find name 'public'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,16): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,16): error TS2304: Cannot find name 'DefaultValue'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,29): error TS2304: Cannot find name 'value'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,35): error TS1109: Expression expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,37): error TS2304: Cannot find name 'string'. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(259,55): error TS1005: ';' expected. -tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(261,1): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,26): error TS2304: Cannot find name 'value'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,31): error TS1005: ',' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(257,33): error TS2304: Cannot find name 'string'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,9): error TS1128: Declaration or statement expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,16): error TS2304: Cannot find name 'Overloads'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,27): error TS1135: Argument expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,33): error TS1005: '(' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,35): error TS2304: Cannot find name 'string'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,43): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,52): error TS2304: Cannot find name 'string'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,60): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(258,65): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,9): error TS2304: Cannot find name 'public'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,16): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,16): error TS2304: Cannot find name 'DefaultValue'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,29): error TS2304: Cannot find name 'value'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,35): error TS1109: Expression expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,37): error TS2304: Cannot find name 'string'. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(260,55): error TS1005: ';' expected. +tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts(262,1): error TS1128: Declaration or statement expected. ==== tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts (83 errors) ==== + declare module "fs" { export class File { constructor(filename: string); diff --git a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js index 5a61d4d5d7e96..4765d1de28344 100644 --- a/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js +++ b/tests/baselines/reference/constructorWithIncompleteTypeAnnotation.js @@ -1,4 +1,5 @@ //// [constructorWithIncompleteTypeAnnotation.ts] + declare module "fs" { export class File { constructor(filename: string); diff --git a/tests/baselines/reference/continueNotInIterationStatement4.errors.txt b/tests/baselines/reference/continueNotInIterationStatement4.errors.txt index 1c80f7057b878..dec899c7218f7 100644 --- a/tests/baselines/reference/continueNotInIterationStatement4.errors.txt +++ b/tests/baselines/reference/continueNotInIterationStatement4.errors.txt @@ -1,7 +1,8 @@ -tests/cases/compiler/continueNotInIterationStatement4.ts(4,5): error TS1107: Jump target cannot cross function boundary. +tests/cases/compiler/continueNotInIterationStatement4.ts(5,5): error TS1107: Jump target cannot cross function boundary. ==== tests/cases/compiler/continueNotInIterationStatement4.ts (1 errors) ==== + TWO: while (true){ var x = () => { diff --git a/tests/baselines/reference/continueNotInIterationStatement4.js b/tests/baselines/reference/continueNotInIterationStatement4.js index f3f52ecb48ca3..50261be23b188 100644 --- a/tests/baselines/reference/continueNotInIterationStatement4.js +++ b/tests/baselines/reference/continueNotInIterationStatement4.js @@ -1,4 +1,5 @@ //// [continueNotInIterationStatement4.ts] + TWO: while (true){ var x = () => { diff --git a/tests/baselines/reference/continueTarget3.js b/tests/baselines/reference/continueTarget3.js index 052b7b593c31d..70c2d2590e570 100644 --- a/tests/baselines/reference/continueTarget3.js +++ b/tests/baselines/reference/continueTarget3.js @@ -1,4 +1,5 @@ //// [continueTarget3.ts] + target1: target2: while (true) { diff --git a/tests/baselines/reference/continueTarget3.symbols b/tests/baselines/reference/continueTarget3.symbols index a1b930f2f5ac2..a5decfe16d102 100644 --- a/tests/baselines/reference/continueTarget3.symbols +++ b/tests/baselines/reference/continueTarget3.symbols @@ -1,5 +1,6 @@ === tests/cases/compiler/continueTarget3.ts === -target1: + +No type information for this code.target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. continue target1; diff --git a/tests/baselines/reference/continueTarget3.types b/tests/baselines/reference/continueTarget3.types index 3336b47772c86..d55f1c3f6d223 100644 --- a/tests/baselines/reference/continueTarget3.types +++ b/tests/baselines/reference/continueTarget3.types @@ -1,4 +1,5 @@ === tests/cases/compiler/continueTarget3.ts === + target1: >target1 : any diff --git a/tests/baselines/reference/continueTarget4.js b/tests/baselines/reference/continueTarget4.js index 0f6211f9202cb..23c20a03260f9 100644 --- a/tests/baselines/reference/continueTarget4.js +++ b/tests/baselines/reference/continueTarget4.js @@ -1,4 +1,5 @@ //// [continueTarget4.ts] + target1: target2: while (true) { diff --git a/tests/baselines/reference/continueTarget4.symbols b/tests/baselines/reference/continueTarget4.symbols index ea1989a3e4d22..fc69a881a60a3 100644 --- a/tests/baselines/reference/continueTarget4.symbols +++ b/tests/baselines/reference/continueTarget4.symbols @@ -1,5 +1,6 @@ === tests/cases/compiler/continueTarget4.ts === -target1: + +No type information for this code.target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. continue target2; diff --git a/tests/baselines/reference/continueTarget4.types b/tests/baselines/reference/continueTarget4.types index 5d2b7c29bbe33..e3e3ae82dfee8 100644 --- a/tests/baselines/reference/continueTarget4.types +++ b/tests/baselines/reference/continueTarget4.types @@ -1,4 +1,5 @@ === tests/cases/compiler/continueTarget4.ts === + target1: >target1 : any diff --git a/tests/baselines/reference/continueTarget5.errors.txt b/tests/baselines/reference/continueTarget5.errors.txt index 401c5874ee043..854f57017b620 100644 --- a/tests/baselines/reference/continueTarget5.errors.txt +++ b/tests/baselines/reference/continueTarget5.errors.txt @@ -1,7 +1,8 @@ -tests/cases/compiler/continueTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary. +tests/cases/compiler/continueTarget5.ts(6,7): error TS1107: Jump target cannot cross function boundary. ==== tests/cases/compiler/continueTarget5.ts (1 errors) ==== + target: while (true) { function f() { diff --git a/tests/baselines/reference/continueTarget5.js b/tests/baselines/reference/continueTarget5.js index 5bf309d2690e8..030a1c2589c59 100644 --- a/tests/baselines/reference/continueTarget5.js +++ b/tests/baselines/reference/continueTarget5.js @@ -1,4 +1,5 @@ //// [continueTarget5.ts] + target: while (true) { function f() { diff --git a/tests/baselines/reference/doWhileBreakStatements.js b/tests/baselines/reference/doWhileBreakStatements.js index a2bc0d3c549af..8e272ceed0a55 100644 --- a/tests/baselines/reference/doWhileBreakStatements.js +++ b/tests/baselines/reference/doWhileBreakStatements.js @@ -1,4 +1,5 @@ //// [doWhileBreakStatements.ts] + do { break; } while(true) diff --git a/tests/baselines/reference/doWhileBreakStatements.symbols b/tests/baselines/reference/doWhileBreakStatements.symbols index 7d9db9a5ebb51..14db540598df2 100644 --- a/tests/baselines/reference/doWhileBreakStatements.symbols +++ b/tests/baselines/reference/doWhileBreakStatements.symbols @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts === + do { break; } while(true) @@ -34,7 +35,7 @@ do do do break SEVEN; while (true) while (true) while (true) EIGHT: do{ var fn = function () { } ->fn : Symbol(fn, Decl(doWhileBreakStatements.ts, 34, 7)) +>fn : Symbol(fn, Decl(doWhileBreakStatements.ts, 35, 7)) break EIGHT; }while(true) diff --git a/tests/baselines/reference/doWhileBreakStatements.types b/tests/baselines/reference/doWhileBreakStatements.types index c3ca932910a5e..f143cb17d0884 100644 --- a/tests/baselines/reference/doWhileBreakStatements.types +++ b/tests/baselines/reference/doWhileBreakStatements.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts === + do { break; } while(true) diff --git a/tests/baselines/reference/doWhileContinueStatements.js b/tests/baselines/reference/doWhileContinueStatements.js index 7f73157fd994f..51bac3c4e0913 100644 --- a/tests/baselines/reference/doWhileContinueStatements.js +++ b/tests/baselines/reference/doWhileContinueStatements.js @@ -1,4 +1,5 @@ //// [doWhileContinueStatements.ts] + do { continue; } while(true) diff --git a/tests/baselines/reference/doWhileContinueStatements.symbols b/tests/baselines/reference/doWhileContinueStatements.symbols index e4c6d577d5aa4..36ca2dde764d7 100644 --- a/tests/baselines/reference/doWhileContinueStatements.symbols +++ b/tests/baselines/reference/doWhileContinueStatements.symbols @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts === + do { continue; } while(true) @@ -34,7 +35,7 @@ do do do continue SEVEN; while (true) while (true) while (true) EIGHT: do{ var fn = function () { } ->fn : Symbol(fn, Decl(doWhileContinueStatements.ts, 34, 7)) +>fn : Symbol(fn, Decl(doWhileContinueStatements.ts, 35, 7)) continue EIGHT; }while(true) diff --git a/tests/baselines/reference/doWhileContinueStatements.types b/tests/baselines/reference/doWhileContinueStatements.types index 90c9f59842a8c..e4d3191d040d6 100644 --- a/tests/baselines/reference/doWhileContinueStatements.types +++ b/tests/baselines/reference/doWhileContinueStatements.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts === + do { continue; } while(true) diff --git a/tests/baselines/reference/downlevelLetConst16.errors.txt b/tests/baselines/reference/downlevelLetConst16.errors.txt index 905d1a607e81d..a6ada633016ff 100644 --- a/tests/baselines/reference/downlevelLetConst16.errors.txt +++ b/tests/baselines/reference/downlevelLetConst16.errors.txt @@ -1,12 +1,13 @@ -tests/cases/compiler/downlevelLetConst16.ts(151,15): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -tests/cases/compiler/downlevelLetConst16.ts(164,17): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. -tests/cases/compiler/downlevelLetConst16.ts(195,14): error TS2461: Type 'undefined' is not an array type. -tests/cases/compiler/downlevelLetConst16.ts(202,15): error TS2459: Type 'undefined' has no property 'a' and no string index signature. -tests/cases/compiler/downlevelLetConst16.ts(216,16): error TS2461: Type 'undefined' is not an array type. -tests/cases/compiler/downlevelLetConst16.ts(223,17): error TS2459: Type 'undefined' has no property 'a' and no string index signature. +tests/cases/compiler/downlevelLetConst16.ts(152,15): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/compiler/downlevelLetConst16.ts(165,17): error TS2525: Initializer provides no value for this binding element and the binding element has no default value. +tests/cases/compiler/downlevelLetConst16.ts(196,14): error TS2461: Type 'undefined' is not an array type. +tests/cases/compiler/downlevelLetConst16.ts(203,15): error TS2459: Type 'undefined' has no property 'a' and no string index signature. +tests/cases/compiler/downlevelLetConst16.ts(217,16): error TS2461: Type 'undefined' is not an array type. +tests/cases/compiler/downlevelLetConst16.ts(224,17): error TS2459: Type 'undefined' has no property 'a' and no string index signature. ==== tests/cases/compiler/downlevelLetConst16.ts (6 errors) ==== + 'use strict' declare function use(a: any); diff --git a/tests/baselines/reference/downlevelLetConst16.js b/tests/baselines/reference/downlevelLetConst16.js index 874fc12119128..d6f05f7584a7c 100644 --- a/tests/baselines/reference/downlevelLetConst16.js +++ b/tests/baselines/reference/downlevelLetConst16.js @@ -1,4 +1,5 @@ //// [downlevelLetConst16.ts] + 'use strict' declare function use(a: any); diff --git a/tests/baselines/reference/downlevelLetConst18.errors.txt b/tests/baselines/reference/downlevelLetConst18.errors.txt deleted file mode 100644 index 066c75abeb11e..0000000000000 --- a/tests/baselines/reference/downlevelLetConst18.errors.txt +++ /dev/null @@ -1,39 +0,0 @@ -tests/cases/compiler/downlevelLetConst18.ts(4,14): error TS2393: Duplicate function implementation. -tests/cases/compiler/downlevelLetConst18.ts(8,14): error TS2393: Duplicate function implementation. - - -==== tests/cases/compiler/downlevelLetConst18.ts (2 errors) ==== - 'use strict' - - for (let x; ;) { - function foo() { x }; - ~~~ -!!! error TS2393: Duplicate function implementation. - } - - for (let x; ;) { - function foo() { x }; - ~~~ -!!! error TS2393: Duplicate function implementation. - } - - for (let x; ;) { - (() => { x })(); - } - - for (const x = 1; ;) { - (() => { x })(); - } - - for (let x; ;) { - ({ foo() { x }}) - } - - for (let x; ;) { - ({ get foo() { return x } }) - } - - for (let x; ;) { - ({ set foo(v) { x } }) - } - \ No newline at end of file diff --git a/tests/baselines/reference/downlevelLetConst18.js b/tests/baselines/reference/downlevelLetConst18.js index 59bd316f8a3ba..cc11c1eef3a5d 100644 --- a/tests/baselines/reference/downlevelLetConst18.js +++ b/tests/baselines/reference/downlevelLetConst18.js @@ -1,4 +1,5 @@ //// [downlevelLetConst18.ts] + 'use strict' for (let x; ;) { @@ -6,7 +7,7 @@ for (let x; ;) { } for (let x; ;) { - function foo() { x }; + function foo1() { x }; } for (let x; ;) { @@ -40,7 +41,7 @@ for (var x = void 0;;) { _loop_1(x); } var _loop_2 = function(x) { - function foo() { x; } + function foo1() { x; } ; }; for (var x = void 0;;) { diff --git a/tests/baselines/reference/downlevelLetConst18.symbols b/tests/baselines/reference/downlevelLetConst18.symbols new file mode 100644 index 0000000000000..a1df0dc6ae981 --- /dev/null +++ b/tests/baselines/reference/downlevelLetConst18.symbols @@ -0,0 +1,59 @@ +=== tests/cases/compiler/downlevelLetConst18.ts === + +'use strict' + +for (let x; ;) { +>x : Symbol(x, Decl(downlevelLetConst18.ts, 3, 8)) + + function foo() { x }; +>foo : Symbol(foo, Decl(downlevelLetConst18.ts, 3, 16)) +>x : Symbol(x, Decl(downlevelLetConst18.ts, 3, 8)) +} + +for (let x; ;) { +>x : Symbol(x, Decl(downlevelLetConst18.ts, 7, 8)) + + function foo1() { x }; +>foo1 : Symbol(foo1, Decl(downlevelLetConst18.ts, 7, 16)) +>x : Symbol(x, Decl(downlevelLetConst18.ts, 7, 8)) +} + +for (let x; ;) { +>x : Symbol(x, Decl(downlevelLetConst18.ts, 11, 8)) + + (() => { x })(); +>x : Symbol(x, Decl(downlevelLetConst18.ts, 11, 8)) +} + +for (const x = 1; ;) { +>x : Symbol(x, Decl(downlevelLetConst18.ts, 15, 10)) + + (() => { x })(); +>x : Symbol(x, Decl(downlevelLetConst18.ts, 15, 10)) +} + +for (let x; ;) { +>x : Symbol(x, Decl(downlevelLetConst18.ts, 19, 8)) + + ({ foo() { x }}) +>foo : Symbol(foo, Decl(downlevelLetConst18.ts, 20, 6)) +>x : Symbol(x, Decl(downlevelLetConst18.ts, 19, 8)) +} + +for (let x; ;) { +>x : Symbol(x, Decl(downlevelLetConst18.ts, 23, 8)) + + ({ get foo() { return x } }) +>foo : Symbol(foo, Decl(downlevelLetConst18.ts, 24, 6)) +>x : Symbol(x, Decl(downlevelLetConst18.ts, 23, 8)) +} + +for (let x; ;) { +>x : Symbol(x, Decl(downlevelLetConst18.ts, 27, 8)) + + ({ set foo(v) { x } }) +>foo : Symbol(foo, Decl(downlevelLetConst18.ts, 28, 6)) +>v : Symbol(v, Decl(downlevelLetConst18.ts, 28, 15)) +>x : Symbol(x, Decl(downlevelLetConst18.ts, 27, 8)) +} + diff --git a/tests/baselines/reference/downlevelLetConst18.types b/tests/baselines/reference/downlevelLetConst18.types new file mode 100644 index 0000000000000..42421aa80c065 --- /dev/null +++ b/tests/baselines/reference/downlevelLetConst18.types @@ -0,0 +1,73 @@ +=== tests/cases/compiler/downlevelLetConst18.ts === + +'use strict' +>'use strict' : string + +for (let x; ;) { +>x : any + + function foo() { x }; +>foo : () => void +>x : any +} + +for (let x; ;) { +>x : any + + function foo1() { x }; +>foo1 : () => void +>x : any +} + +for (let x; ;) { +>x : any + + (() => { x })(); +>(() => { x })() : void +>(() => { x }) : () => void +>() => { x } : () => void +>x : any +} + +for (const x = 1; ;) { +>x : number +>1 : number + + (() => { x })(); +>(() => { x })() : void +>(() => { x }) : () => void +>() => { x } : () => void +>x : number +} + +for (let x; ;) { +>x : any + + ({ foo() { x }}) +>({ foo() { x }}) : { foo(): void; } +>{ foo() { x }} : { foo(): void; } +>foo : () => void +>x : any +} + +for (let x; ;) { +>x : any + + ({ get foo() { return x } }) +>({ get foo() { return x } }) : { foo: any; } +>{ get foo() { return x } } : { foo: any; } +>foo : any +>x : any +} + +for (let x; ;) { +>x : any + + ({ set foo(v) { x } }) +>({ set foo(v) { x } }) : { foo: any; } +>{ set foo(v) { x } } : { foo: any; } +>foo : any +>v : any +>x : any +} + diff --git a/tests/baselines/reference/duplicateLabel1.errors.txt b/tests/baselines/reference/duplicateLabel1.errors.txt index b34f1f771e02b..cf116f656fc22 100644 --- a/tests/baselines/reference/duplicateLabel1.errors.txt +++ b/tests/baselines/reference/duplicateLabel1.errors.txt @@ -1,7 +1,8 @@ -tests/cases/compiler/duplicateLabel1.ts(2,1): error TS1114: Duplicate label 'target' +tests/cases/compiler/duplicateLabel1.ts(3,1): error TS1114: Duplicate label 'target' ==== tests/cases/compiler/duplicateLabel1.ts (1 errors) ==== + target: target: ~~~~~~ diff --git a/tests/baselines/reference/duplicateLabel1.js b/tests/baselines/reference/duplicateLabel1.js index e7976895c94d8..5251cec3e3683 100644 --- a/tests/baselines/reference/duplicateLabel1.js +++ b/tests/baselines/reference/duplicateLabel1.js @@ -1,4 +1,5 @@ //// [duplicateLabel1.ts] + target: target: while (true) { diff --git a/tests/baselines/reference/duplicateLabel2.errors.txt b/tests/baselines/reference/duplicateLabel2.errors.txt index 307596cf4e8cc..2a87ed966485d 100644 --- a/tests/baselines/reference/duplicateLabel2.errors.txt +++ b/tests/baselines/reference/duplicateLabel2.errors.txt @@ -1,7 +1,8 @@ -tests/cases/compiler/duplicateLabel2.ts(3,3): error TS1114: Duplicate label 'target' +tests/cases/compiler/duplicateLabel2.ts(4,3): error TS1114: Duplicate label 'target' ==== tests/cases/compiler/duplicateLabel2.ts (1 errors) ==== + target: while (true) { target: diff --git a/tests/baselines/reference/duplicateLabel2.js b/tests/baselines/reference/duplicateLabel2.js index 9ee9671d59de8..40a5ee4595e76 100644 --- a/tests/baselines/reference/duplicateLabel2.js +++ b/tests/baselines/reference/duplicateLabel2.js @@ -1,4 +1,5 @@ //// [duplicateLabel2.ts] + target: while (true) { target: diff --git a/tests/baselines/reference/duplicateLabel3.js b/tests/baselines/reference/duplicateLabel3.js index 37e9619e8f6bb..a1d33e46fc19b 100644 --- a/tests/baselines/reference/duplicateLabel3.js +++ b/tests/baselines/reference/duplicateLabel3.js @@ -1,4 +1,5 @@ //// [duplicateLabel3.ts] + target: while (true) { function f() { diff --git a/tests/baselines/reference/duplicateLabel3.symbols b/tests/baselines/reference/duplicateLabel3.symbols index 07d0ded29232e..89f2d5ee48a69 100644 --- a/tests/baselines/reference/duplicateLabel3.symbols +++ b/tests/baselines/reference/duplicateLabel3.symbols @@ -1,8 +1,9 @@ === tests/cases/compiler/duplicateLabel3.ts === + target: while (true) { function f() { ->f : Symbol(f, Decl(duplicateLabel3.ts, 1, 14)) +>f : Symbol(f, Decl(duplicateLabel3.ts, 2, 14)) target: while (true) { diff --git a/tests/baselines/reference/duplicateLabel3.types b/tests/baselines/reference/duplicateLabel3.types index 8d75b08c768d1..920a077aa9ef2 100644 --- a/tests/baselines/reference/duplicateLabel3.types +++ b/tests/baselines/reference/duplicateLabel3.types @@ -1,4 +1,5 @@ === tests/cases/compiler/duplicateLabel3.ts === + target: >target : any diff --git a/tests/baselines/reference/duplicateLabel4.js b/tests/baselines/reference/duplicateLabel4.js index 22d072d38d730..d5b81b1e5bb8f 100644 --- a/tests/baselines/reference/duplicateLabel4.js +++ b/tests/baselines/reference/duplicateLabel4.js @@ -1,4 +1,5 @@ //// [duplicateLabel4.ts] + target: while (true) { } diff --git a/tests/baselines/reference/duplicateLabel4.symbols b/tests/baselines/reference/duplicateLabel4.symbols index c671abcef35d6..5660782e2ecdd 100644 --- a/tests/baselines/reference/duplicateLabel4.symbols +++ b/tests/baselines/reference/duplicateLabel4.symbols @@ -1,5 +1,6 @@ === tests/cases/compiler/duplicateLabel4.ts === -target: + +No type information for this code.target: No type information for this code.while (true) { No type information for this code.} No type information for this code. diff --git a/tests/baselines/reference/duplicateLabel4.types b/tests/baselines/reference/duplicateLabel4.types index 9238986b582be..a10a06fe7a2fe 100644 --- a/tests/baselines/reference/duplicateLabel4.types +++ b/tests/baselines/reference/duplicateLabel4.types @@ -1,4 +1,5 @@ === tests/cases/compiler/duplicateLabel4.ts === + target: >target : any diff --git a/tests/baselines/reference/duplicateLocalVariable1.errors.txt b/tests/baselines/reference/duplicateLocalVariable1.errors.txt index e4217d4d41126..bd6d535d88eaa 100644 --- a/tests/baselines/reference/duplicateLocalVariable1.errors.txt +++ b/tests/baselines/reference/duplicateLocalVariable1.errors.txt @@ -1,7 +1,19 @@ -tests/cases/compiler/duplicateLocalVariable1.ts(185,22): error TS2403: Subsequent variable declarations must have the same type. Variable 'i' must be of type 'any', but here has type 'number'. +tests/cases/compiler/duplicateLocalVariable1.ts(2,4): error TS1005: ';' expected. +tests/cases/compiler/duplicateLocalVariable1.ts(2,11): error TS1146: Declaration expected. +tests/cases/compiler/duplicateLocalVariable1.ts(2,13): error TS2304: Cannot find name 'commonjs'. +tests/cases/compiler/duplicateLocalVariable1.ts(12,14): error TS1148: Cannot compile modules unless the '--module' flag is provided. +tests/cases/compiler/duplicateLocalVariable1.ts(187,22): error TS2403: Subsequent variable declarations must have the same type. Variable 'i' must be of type 'any', but here has type 'number'. -==== tests/cases/compiler/duplicateLocalVariable1.ts (1 errors) ==== +==== tests/cases/compiler/duplicateLocalVariable1.ts (5 errors) ==== + + / /@module: commonjs + ~ +!!! error TS1005: ';' expected. + +!!! error TS1146: Declaration expected. + ~~~~~~~~ +!!! error TS2304: Cannot find name 'commonjs'. //import FileManager = require('filemanager'); //import App = require('app'); @@ -12,6 +24,8 @@ tests/cases/compiler/duplicateLocalVariable1.ts(185,22): error TS2403: Subsequen var TestFileDir = ".\\TempTestFiles"; export class TestCase { + ~~~~~~~~ +!!! error TS1148: Cannot compile modules unless the '--module' flag is provided. constructor (public name: string, public test: ()=>boolean, public errorMessageRegEx?: string) { } } diff --git a/tests/baselines/reference/duplicateLocalVariable1.js b/tests/baselines/reference/duplicateLocalVariable1.js index 62e291f28c083..ecde1ff24077e 100644 --- a/tests/baselines/reference/duplicateLocalVariable1.js +++ b/tests/baselines/reference/duplicateLocalVariable1.js @@ -1,5 +1,7 @@ //// [duplicateLocalVariable1.ts] +/ /@module: commonjs + //import FileManager = require('filemanager'); //import App = require('app'); @@ -344,8 +346,8 @@ export var tests: TestRunner = (function () { })(); //// [duplicateLocalVariable1.js] -//import FileManager = require('filemanager'); -//import App = require('app'); +/ /; +commonjs; var TestFileDir = ".\\TempTestFiles"; var TestCase = (function () { function TestCase(name, test, errorMessageRegEx) { diff --git a/tests/baselines/reference/duplicateVariablesByScope.js b/tests/baselines/reference/duplicateVariablesByScope.js index d87fd966f32b7..43b6e89d412db 100644 --- a/tests/baselines/reference/duplicateVariablesByScope.js +++ b/tests/baselines/reference/duplicateVariablesByScope.js @@ -1,4 +1,5 @@ //// [duplicateVariablesByScope.ts] + // duplicate local variables are only reported at global scope module M { diff --git a/tests/baselines/reference/duplicateVariablesByScope.symbols b/tests/baselines/reference/duplicateVariablesByScope.symbols index bc94dc9b80779..9dd280d2756f1 100644 --- a/tests/baselines/reference/duplicateVariablesByScope.symbols +++ b/tests/baselines/reference/duplicateVariablesByScope.symbols @@ -1,56 +1,57 @@ === tests/cases/compiler/duplicateVariablesByScope.ts === + // duplicate local variables are only reported at global scope module M { >M : Symbol(M, Decl(duplicateVariablesByScope.ts, 0, 0)) for (var j = 0; j < 10; j++) { ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) } for (var j = 0; j < 10; j++) { ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) ->j : Symbol(j, Decl(duplicateVariablesByScope.ts, 3, 12), Decl(duplicateVariablesByScope.ts, 6, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) +>j : Symbol(j, Decl(duplicateVariablesByScope.ts, 4, 12), Decl(duplicateVariablesByScope.ts, 7, 12)) } } function foo() { ->foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 8, 1)) +>foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 9, 1)) var x = 2; ->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 11, 7), Decl(duplicateVariablesByScope.ts, 12, 7)) +>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 12, 7), Decl(duplicateVariablesByScope.ts, 13, 7)) var x = 1; ->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 11, 7), Decl(duplicateVariablesByScope.ts, 12, 7)) +>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 12, 7), Decl(duplicateVariablesByScope.ts, 13, 7)) if (true) { var result = 1; ->result : Symbol(result, Decl(duplicateVariablesByScope.ts, 14, 11), Decl(duplicateVariablesByScope.ts, 17, 11)) +>result : Symbol(result, Decl(duplicateVariablesByScope.ts, 15, 11), Decl(duplicateVariablesByScope.ts, 18, 11)) } else { var result = 2; ->result : Symbol(result, Decl(duplicateVariablesByScope.ts, 14, 11), Decl(duplicateVariablesByScope.ts, 17, 11)) +>result : Symbol(result, Decl(duplicateVariablesByScope.ts, 15, 11), Decl(duplicateVariablesByScope.ts, 18, 11)) } } class C { ->C : Symbol(C, Decl(duplicateVariablesByScope.ts, 19, 1)) +>C : Symbol(C, Decl(duplicateVariablesByScope.ts, 20, 1)) foo() { ->foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 21, 9)) +>foo : Symbol(foo, Decl(duplicateVariablesByScope.ts, 22, 9)) try { var x = 1; ->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 24, 15), Decl(duplicateVariablesByScope.ts, 27, 15)) +>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 25, 15), Decl(duplicateVariablesByScope.ts, 28, 15)) } catch (e) { ->e : Symbol(e, Decl(duplicateVariablesByScope.ts, 26, 15)) +>e : Symbol(e, Decl(duplicateVariablesByScope.ts, 27, 15)) var x = 2; ->x : Symbol(x, Decl(duplicateVariablesByScope.ts, 24, 15), Decl(duplicateVariablesByScope.ts, 27, 15)) +>x : Symbol(x, Decl(duplicateVariablesByScope.ts, 25, 15), Decl(duplicateVariablesByScope.ts, 28, 15)) } } } diff --git a/tests/baselines/reference/duplicateVariablesByScope.types b/tests/baselines/reference/duplicateVariablesByScope.types index 42d8cae2a3c86..30e68d921caff 100644 --- a/tests/baselines/reference/duplicateVariablesByScope.types +++ b/tests/baselines/reference/duplicateVariablesByScope.types @@ -1,4 +1,5 @@ === tests/cases/compiler/duplicateVariablesByScope.ts === + // duplicate local variables are only reported at global scope module M { diff --git a/tests/baselines/reference/errorOnContextuallyTypedReturnType.errors.txt b/tests/baselines/reference/errorOnContextuallyTypedReturnType.errors.txt index 5b66a377307cf..403e79b874271 100644 --- a/tests/baselines/reference/errorOnContextuallyTypedReturnType.errors.txt +++ b/tests/baselines/reference/errorOnContextuallyTypedReturnType.errors.txt @@ -1,6 +1,6 @@ tests/cases/compiler/errorOnContextuallyTypedReturnType.ts(1,5): error TS2322: Type '() => void' is not assignable to type '() => boolean'. Type 'void' is not assignable to type 'boolean'. -tests/cases/compiler/errorOnContextuallyTypedReturnType.ts(2,37): 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/errorOnContextuallyTypedReturnType.ts(2,37): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. ==== tests/cases/compiler/errorOnContextuallyTypedReturnType.ts (2 errors) ==== @@ -10,5 +10,5 @@ tests/cases/compiler/errorOnContextuallyTypedReturnType.ts(2,37): error TS2355: !!! error TS2322: Type 'void' is not assignable to type 'boolean'. var n2: () => boolean = function ():boolean { }; // expect an error here ~~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. \ No newline at end of file diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.js b/tests/baselines/reference/es6ClassSuperCodegenBug.js index 62c96f6260d6c..9f15af96be810 100644 --- a/tests/baselines/reference/es6ClassSuperCodegenBug.js +++ b/tests/baselines/reference/es6ClassSuperCodegenBug.js @@ -1,4 +1,5 @@ //// [es6ClassSuperCodegenBug.ts] + class A { constructor(str1:string, str2:string) {} } diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.symbols b/tests/baselines/reference/es6ClassSuperCodegenBug.symbols index d520ec3ceb1c3..bb500a1d2c286 100644 --- a/tests/baselines/reference/es6ClassSuperCodegenBug.symbols +++ b/tests/baselines/reference/es6ClassSuperCodegenBug.symbols @@ -1,13 +1,14 @@ === tests/cases/compiler/es6ClassSuperCodegenBug.ts === + class A { >A : Symbol(A, Decl(es6ClassSuperCodegenBug.ts, 0, 0)) constructor(str1:string, str2:string) {} ->str1 : Symbol(str1, Decl(es6ClassSuperCodegenBug.ts, 1, 13)) ->str2 : Symbol(str2, Decl(es6ClassSuperCodegenBug.ts, 1, 25)) +>str1 : Symbol(str1, Decl(es6ClassSuperCodegenBug.ts, 2, 13)) +>str2 : Symbol(str2, Decl(es6ClassSuperCodegenBug.ts, 2, 25)) } class B extends A { ->B : Symbol(B, Decl(es6ClassSuperCodegenBug.ts, 2, 1)) +>B : Symbol(B, Decl(es6ClassSuperCodegenBug.ts, 3, 1)) >A : Symbol(A, Decl(es6ClassSuperCodegenBug.ts, 0, 0)) constructor() { diff --git a/tests/baselines/reference/es6ClassSuperCodegenBug.types b/tests/baselines/reference/es6ClassSuperCodegenBug.types index bdf8ebde8f23e..65269c99997ae 100644 --- a/tests/baselines/reference/es6ClassSuperCodegenBug.types +++ b/tests/baselines/reference/es6ClassSuperCodegenBug.types @@ -1,4 +1,5 @@ === tests/cases/compiler/es6ClassSuperCodegenBug.ts === + class A { >A : A diff --git a/tests/baselines/reference/escapedIdentifiers.js b/tests/baselines/reference/escapedIdentifiers.js index 5ab7dcc5a5a57..64eaaa5784fde 100644 --- a/tests/baselines/reference/escapedIdentifiers.js +++ b/tests/baselines/reference/escapedIdentifiers.js @@ -1,4 +1,5 @@ //// [escapedIdentifiers.ts] + /* 0 .. \u0030 9 .. \u0039 diff --git a/tests/baselines/reference/escapedIdentifiers.symbols b/tests/baselines/reference/escapedIdentifiers.symbols index 6c84b25647f6a..a99e067b898f9 100644 --- a/tests/baselines/reference/escapedIdentifiers.symbols +++ b/tests/baselines/reference/escapedIdentifiers.symbols @@ -1,4 +1,5 @@ === tests/cases/compiler/escapedIdentifiers.ts === + /* 0 .. \u0030 9 .. \u0039 @@ -12,222 +13,222 @@ // var decl var \u0061 = 1; ->\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 12, 3)) +>\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3)) a ++; ->a : Symbol(\u0061, Decl(escapedIdentifiers.ts, 12, 3)) +>a : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3)) \u0061 ++; ->\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 12, 3)) +>\u0061 : Symbol(\u0061, Decl(escapedIdentifiers.ts, 13, 3)) var b = 1; ->b : Symbol(b, Decl(escapedIdentifiers.ts, 16, 3)) +>b : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3)) b ++; ->b : Symbol(b, Decl(escapedIdentifiers.ts, 16, 3)) +>b : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3)) \u0062 ++; ->\u0062 : Symbol(b, Decl(escapedIdentifiers.ts, 16, 3)) +>\u0062 : Symbol(b, Decl(escapedIdentifiers.ts, 17, 3)) // modules module moduleType1 { ->moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 18, 10)) +>moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10)) export var baz1: number; ->baz1 : Symbol(baz1, Decl(escapedIdentifiers.ts, 22, 14)) +>baz1 : Symbol(baz1, Decl(escapedIdentifiers.ts, 23, 14)) } module moduleType\u0032 { ->moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 23, 1)) +>moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1)) export var baz2: number; ->baz2 : Symbol(baz2, Decl(escapedIdentifiers.ts, 25, 14)) +>baz2 : Symbol(baz2, Decl(escapedIdentifiers.ts, 26, 14)) } moduleType1.baz1 = 3; ->moduleType1.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14)) ->moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 18, 10)) ->baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14)) +>moduleType1.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14)) +>moduleType1 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10)) +>baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14)) moduleType\u0031.baz1 = 3; ->moduleType\u0031.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14)) ->moduleType\u0031 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 18, 10)) ->baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 22, 14)) +>moduleType\u0031.baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14)) +>moduleType\u0031 : Symbol(moduleType1, Decl(escapedIdentifiers.ts, 19, 10)) +>baz1 : Symbol(moduleType1.baz1, Decl(escapedIdentifiers.ts, 23, 14)) moduleType2.baz2 = 3; ->moduleType2.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14)) ->moduleType2 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 23, 1)) ->baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14)) +>moduleType2.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14)) +>moduleType2 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1)) +>baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14)) moduleType\u0032.baz2 = 3; ->moduleType\u0032.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14)) ->moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 23, 1)) ->baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 25, 14)) +>moduleType\u0032.baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14)) +>moduleType\u0032 : Symbol(moduleType\u0032, Decl(escapedIdentifiers.ts, 24, 1)) +>baz2 : Symbol(moduleType\u0032.baz2, Decl(escapedIdentifiers.ts, 26, 14)) // classes class classType1 { ->classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 31, 26)) +>classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26)) public foo1: number; ->foo1 : Symbol(foo1, Decl(escapedIdentifiers.ts, 35, 18)) +>foo1 : Symbol(foo1, Decl(escapedIdentifiers.ts, 36, 18)) } class classType\u0032 { ->classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 37, 1)) +>classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1)) public foo2: number; ->foo2 : Symbol(foo2, Decl(escapedIdentifiers.ts, 38, 23)) +>foo2 : Symbol(foo2, Decl(escapedIdentifiers.ts, 39, 23)) } var classType1Object1 = new classType1(); ->classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 42, 3)) ->classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 31, 26)) +>classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 43, 3)) +>classType1 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26)) classType1Object1.foo1 = 2; ->classType1Object1.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) ->classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 42, 3)) ->foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) +>classType1Object1.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) +>classType1Object1 : Symbol(classType1Object1, Decl(escapedIdentifiers.ts, 43, 3)) +>foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) var classType1Object2 = new classType\u0031(); ->classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 44, 3)) ->classType\u0031 : Symbol(classType1, Decl(escapedIdentifiers.ts, 31, 26)) +>classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 45, 3)) +>classType\u0031 : Symbol(classType1, Decl(escapedIdentifiers.ts, 32, 26)) classType1Object2.foo1 = 2; ->classType1Object2.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) ->classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 44, 3)) ->foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 35, 18)) +>classType1Object2.foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) +>classType1Object2 : Symbol(classType1Object2, Decl(escapedIdentifiers.ts, 45, 3)) +>foo1 : Symbol(classType1.foo1, Decl(escapedIdentifiers.ts, 36, 18)) var classType2Object1 = new classType2(); ->classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 46, 3)) ->classType2 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 37, 1)) +>classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 47, 3)) +>classType2 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1)) classType2Object1.foo2 = 2; ->classType2Object1.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) ->classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 46, 3)) ->foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) +>classType2Object1.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) +>classType2Object1 : Symbol(classType2Object1, Decl(escapedIdentifiers.ts, 47, 3)) +>foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) var classType2Object2 = new classType\u0032(); ->classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 48, 3)) ->classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 37, 1)) +>classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 49, 3)) +>classType\u0032 : Symbol(classType\u0032, Decl(escapedIdentifiers.ts, 38, 1)) classType2Object2.foo2 = 2; ->classType2Object2.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) ->classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 48, 3)) ->foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 38, 23)) +>classType2Object2.foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) +>classType2Object2 : Symbol(classType2Object2, Decl(escapedIdentifiers.ts, 49, 3)) +>foo2 : Symbol(classType\u0032.foo2, Decl(escapedIdentifiers.ts, 39, 23)) // interfaces interface interfaceType1 { ->interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27)) +>interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27)) bar1: number; ->bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 52, 26)) +>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 53, 26)) } interface interfaceType\u0032 { ->interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1)) +>interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1)) bar2: number; ->bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 55, 31)) +>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 56, 31)) } var interfaceType1Object1 = { bar1: 0 }; ->interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 59, 3)) ->interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27)) ->bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 59, 45)) +>interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 60, 3)) +>interfaceType1 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27)) +>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 60, 45)) interfaceType1Object1.bar1 = 2; ->interfaceType1Object1.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) ->interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 59, 3)) ->bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) +>interfaceType1Object1.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) +>interfaceType1Object1 : Symbol(interfaceType1Object1, Decl(escapedIdentifiers.ts, 60, 3)) +>bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) var interfaceType1Object2 = { bar1: 0 }; ->interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 61, 3)) ->interfaceType\u0031 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 49, 27)) ->bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 61, 50)) +>interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 62, 3)) +>interfaceType\u0031 : Symbol(interfaceType1, Decl(escapedIdentifiers.ts, 50, 27)) +>bar1 : Symbol(bar1, Decl(escapedIdentifiers.ts, 62, 50)) interfaceType1Object2.bar1 = 2; ->interfaceType1Object2.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) ->interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 61, 3)) ->bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 52, 26)) +>interfaceType1Object2.bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) +>interfaceType1Object2 : Symbol(interfaceType1Object2, Decl(escapedIdentifiers.ts, 62, 3)) +>bar1 : Symbol(interfaceType1.bar1, Decl(escapedIdentifiers.ts, 53, 26)) var interfaceType2Object1 = { bar2: 0 }; ->interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 63, 3)) ->interfaceType2 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1)) ->bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 63, 45)) +>interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 64, 3)) +>interfaceType2 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1)) +>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 64, 45)) interfaceType2Object1.bar2 = 2; ->interfaceType2Object1.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) ->interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 63, 3)) ->bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) +>interfaceType2Object1.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) +>interfaceType2Object1 : Symbol(interfaceType2Object1, Decl(escapedIdentifiers.ts, 64, 3)) +>bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) var interfaceType2Object2 = { bar2: 0 }; ->interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 65, 3)) ->interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 54, 1)) ->bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 65, 50)) +>interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 66, 3)) +>interfaceType\u0032 : Symbol(interfaceType\u0032, Decl(escapedIdentifiers.ts, 55, 1)) +>bar2 : Symbol(bar2, Decl(escapedIdentifiers.ts, 66, 50)) interfaceType2Object2.bar2 = 2; ->interfaceType2Object2.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) ->interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 65, 3)) ->bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 55, 31)) +>interfaceType2Object2.bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) +>interfaceType2Object2 : Symbol(interfaceType2Object2, Decl(escapedIdentifiers.ts, 66, 3)) +>bar2 : Symbol(interfaceType\u0032.bar2, Decl(escapedIdentifiers.ts, 56, 31)) // arguments class testClass { ->testClass : Symbol(testClass, Decl(escapedIdentifiers.ts, 66, 31)) +>testClass : Symbol(testClass, Decl(escapedIdentifiers.ts, 67, 31)) public func(arg1: number, arg\u0032: string, arg\u0033: boolean, arg4: number) { ->func : Symbol(func, Decl(escapedIdentifiers.ts, 70, 17)) ->arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 71, 16)) ->arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 71, 29)) ->arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 71, 48)) ->arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 71, 68)) +>func : Symbol(func, Decl(escapedIdentifiers.ts, 71, 17)) +>arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 72, 16)) +>arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 72, 29)) +>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 72, 48)) +>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 72, 68)) arg\u0031 = 1; ->arg\u0031 : Symbol(arg1, Decl(escapedIdentifiers.ts, 71, 16)) +>arg\u0031 : Symbol(arg1, Decl(escapedIdentifiers.ts, 72, 16)) arg2 = 'string'; ->arg2 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 71, 29)) +>arg2 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 72, 29)) arg\u0033 = true; ->arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 71, 48)) +>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 72, 48)) arg4 = 2; ->arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 71, 68)) +>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 72, 68)) } } // constructors class constructorTestClass { ->constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 77, 1)) +>constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 78, 1)) constructor (public arg1: number,public arg\u0032: string,public arg\u0033: boolean,public arg4: number) { ->arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 81, 17)) ->arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 81, 37)) ->arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 81, 62)) ->arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 81, 88)) +>arg1 : Symbol(arg1, Decl(escapedIdentifiers.ts, 82, 17)) +>arg\u0032 : Symbol(arg\u0032, Decl(escapedIdentifiers.ts, 82, 37)) +>arg\u0033 : Symbol(arg\u0033, Decl(escapedIdentifiers.ts, 82, 62)) +>arg4 : Symbol(arg4, Decl(escapedIdentifiers.ts, 82, 88)) } } var constructorTestObject = new constructorTestClass(1, 'string', true, 2); ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) ->constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 77, 1)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) +>constructorTestClass : Symbol(constructorTestClass, Decl(escapedIdentifiers.ts, 78, 1)) constructorTestObject.arg\u0031 = 1; ->constructorTestObject.arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 81, 17)) ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) ->arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 81, 17)) +>constructorTestObject.arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 82, 17)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) +>arg\u0031 : Symbol(constructorTestClass.arg1, Decl(escapedIdentifiers.ts, 82, 17)) constructorTestObject.arg2 = 'string'; ->constructorTestObject.arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 81, 37)) ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) ->arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 81, 37)) +>constructorTestObject.arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 82, 37)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) +>arg2 : Symbol(constructorTestClass.arg\u0032, Decl(escapedIdentifiers.ts, 82, 37)) constructorTestObject.arg\u0033 = true; ->constructorTestObject.arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 81, 62)) ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) ->arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 81, 62)) +>constructorTestObject.arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 82, 62)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) +>arg\u0033 : Symbol(constructorTestClass.arg\u0033, Decl(escapedIdentifiers.ts, 82, 62)) constructorTestObject.arg4 = 2; ->constructorTestObject.arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 81, 88)) ->constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 84, 3)) ->arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 81, 88)) +>constructorTestObject.arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 82, 88)) +>constructorTestObject : Symbol(constructorTestObject, Decl(escapedIdentifiers.ts, 85, 3)) +>arg4 : Symbol(constructorTestClass.arg4, Decl(escapedIdentifiers.ts, 82, 88)) // Lables diff --git a/tests/baselines/reference/escapedIdentifiers.types b/tests/baselines/reference/escapedIdentifiers.types index b32d21a48cb5e..67713976bd6ee 100644 --- a/tests/baselines/reference/escapedIdentifiers.types +++ b/tests/baselines/reference/escapedIdentifiers.types @@ -1,4 +1,5 @@ === tests/cases/compiler/escapedIdentifiers.ts === + /* 0 .. \u0030 9 .. \u0039 diff --git a/tests/baselines/reference/for.errors.txt b/tests/baselines/reference/for.errors.txt index 41ed5765c9a35..d2caefbcdae5a 100644 --- a/tests/baselines/reference/for.errors.txt +++ b/tests/baselines/reference/for.errors.txt @@ -1,7 +1,8 @@ -tests/cases/compiler/for.ts(29,6): error TS1109: Expression expected. +tests/cases/compiler/for.ts(30,6): error TS1109: Expression expected. ==== tests/cases/compiler/for.ts (1 errors) ==== + for (var i = 0; i < 10; i++) { // ok var x1 = i; } diff --git a/tests/baselines/reference/for.js b/tests/baselines/reference/for.js index a77b68d8b6e45..857d42bafdbbc 100644 --- a/tests/baselines/reference/for.js +++ b/tests/baselines/reference/for.js @@ -1,4 +1,5 @@ //// [for.ts] + for (var i = 0; i < 10; i++) { // ok var x1 = i; } diff --git a/tests/baselines/reference/forBreakStatements.js b/tests/baselines/reference/forBreakStatements.js index 9ed65627c9c6a..da4fccdfd2ab0 100644 --- a/tests/baselines/reference/forBreakStatements.js +++ b/tests/baselines/reference/forBreakStatements.js @@ -1,4 +1,5 @@ //// [forBreakStatements.ts] + for (; ;) { break; } diff --git a/tests/baselines/reference/forBreakStatements.symbols b/tests/baselines/reference/forBreakStatements.symbols index 76db9309a3969..6d869b45934fa 100644 --- a/tests/baselines/reference/forBreakStatements.symbols +++ b/tests/baselines/reference/forBreakStatements.symbols @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/breakStatements/forBreakStatements.ts === + for (; ;) { break; } @@ -33,7 +34,7 @@ for (; ;) for (; ;) for (; ;) break SEVEN; EIGHT: for (; ;) { var fn = function () { } ->fn : Symbol(fn, Decl(forBreakStatements.ts, 33, 7)) +>fn : Symbol(fn, Decl(forBreakStatements.ts, 34, 7)) break EIGHT; } diff --git a/tests/baselines/reference/forBreakStatements.types b/tests/baselines/reference/forBreakStatements.types index 8469a85bd19f7..c494f6be30a21 100644 --- a/tests/baselines/reference/forBreakStatements.types +++ b/tests/baselines/reference/forBreakStatements.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/breakStatements/forBreakStatements.ts === + for (; ;) { break; } diff --git a/tests/baselines/reference/forContinueStatements.js b/tests/baselines/reference/forContinueStatements.js index 34f70bb1fc137..fc5aa0434b350 100644 --- a/tests/baselines/reference/forContinueStatements.js +++ b/tests/baselines/reference/forContinueStatements.js @@ -1,4 +1,5 @@ //// [forContinueStatements.ts] + for (; ;) { continue; } diff --git a/tests/baselines/reference/forContinueStatements.symbols b/tests/baselines/reference/forContinueStatements.symbols index e24eb2aaa9252..9e0c396acfbe8 100644 --- a/tests/baselines/reference/forContinueStatements.symbols +++ b/tests/baselines/reference/forContinueStatements.symbols @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/continueStatements/forContinueStatements.ts === + for (; ;) { continue; } @@ -33,7 +34,7 @@ for (; ;) for (; ;) for (; ;) continue SEVEN; EIGHT: for (; ;) { var fn = function () { } ->fn : Symbol(fn, Decl(forContinueStatements.ts, 33, 7)) +>fn : Symbol(fn, Decl(forContinueStatements.ts, 34, 7)) continue EIGHT; } diff --git a/tests/baselines/reference/forContinueStatements.types b/tests/baselines/reference/forContinueStatements.types index 79b78e83345de..0b52bdd5d473e 100644 --- a/tests/baselines/reference/forContinueStatements.types +++ b/tests/baselines/reference/forContinueStatements.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/continueStatements/forContinueStatements.ts === + for (; ;) { continue; } diff --git a/tests/baselines/reference/forInBreakStatements.js b/tests/baselines/reference/forInBreakStatements.js index 24b7cc57b8d43..ebbadb31277a1 100644 --- a/tests/baselines/reference/forInBreakStatements.js +++ b/tests/baselines/reference/forInBreakStatements.js @@ -1,4 +1,5 @@ //// [forInBreakStatements.ts] + for(var x in {}) { break; } diff --git a/tests/baselines/reference/forInBreakStatements.symbols b/tests/baselines/reference/forInBreakStatements.symbols index 7984edc3fd699..5f48e110835cf 100644 --- a/tests/baselines/reference/forInBreakStatements.symbols +++ b/tests/baselines/reference/forInBreakStatements.symbols @@ -1,13 +1,14 @@ === tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts === + for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) break; } ONE: for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) break ONE; } @@ -15,43 +16,43 @@ for(var x in {}) { TWO: THREE: for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) break THREE; } FOUR: for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) FIVE: for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) break FOUR; } } for(var x in {}) { ->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) SIX: for(var x in {}) break SIX; ->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) } SEVEN: for (var x in {}) for (var x in {}) for (var x in {}) break SEVEN; ->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) ->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) ->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) EIGHT: for (var x in {}){ ->x : Symbol(x, Decl(forInBreakStatements.ts, 0, 7), Decl(forInBreakStatements.ts, 5, 7), Decl(forInBreakStatements.ts, 11, 7), Decl(forInBreakStatements.ts, 16, 7), Decl(forInBreakStatements.ts, 18, 11), Decl(forInBreakStatements.ts, 23, 7), Decl(forInBreakStatements.ts, 25, 11), Decl(forInBreakStatements.ts, 29, 8), Decl(forInBreakStatements.ts, 29, 26), Decl(forInBreakStatements.ts, 29, 44), Decl(forInBreakStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInBreakStatements.ts, 1, 7), Decl(forInBreakStatements.ts, 6, 7), Decl(forInBreakStatements.ts, 12, 7), Decl(forInBreakStatements.ts, 17, 7), Decl(forInBreakStatements.ts, 19, 11), Decl(forInBreakStatements.ts, 24, 7), Decl(forInBreakStatements.ts, 26, 11), Decl(forInBreakStatements.ts, 30, 8), Decl(forInBreakStatements.ts, 30, 26), Decl(forInBreakStatements.ts, 30, 44), Decl(forInBreakStatements.ts, 33, 8)) var fn = function () { } ->fn : Symbol(fn, Decl(forInBreakStatements.ts, 33, 7)) +>fn : Symbol(fn, Decl(forInBreakStatements.ts, 34, 7)) break EIGHT; } diff --git a/tests/baselines/reference/forInBreakStatements.types b/tests/baselines/reference/forInBreakStatements.types index 05ea8e35febe1..7714429e5af42 100644 --- a/tests/baselines/reference/forInBreakStatements.types +++ b/tests/baselines/reference/forInBreakStatements.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts === + for(var x in {}) { >x : any >{} : {} diff --git a/tests/baselines/reference/forInContinueStatements.js b/tests/baselines/reference/forInContinueStatements.js index 8b036c5972179..ca530dd5d6cd5 100644 --- a/tests/baselines/reference/forInContinueStatements.js +++ b/tests/baselines/reference/forInContinueStatements.js @@ -1,4 +1,5 @@ //// [forInContinueStatements.ts] + for(var x in {}) { continue; } diff --git a/tests/baselines/reference/forInContinueStatements.symbols b/tests/baselines/reference/forInContinueStatements.symbols index 88129a50d21ce..a0edea53f3ef3 100644 --- a/tests/baselines/reference/forInContinueStatements.symbols +++ b/tests/baselines/reference/forInContinueStatements.symbols @@ -1,13 +1,14 @@ === tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts === + for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) continue; } ONE: for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) continue ONE; } @@ -15,43 +16,43 @@ for(var x in {}) { TWO: THREE: for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) continue THREE; } FOUR: for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) FIVE: for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) continue FOUR; } } for(var x in {}) { ->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) SIX: for(var x in {}) continue SIX; ->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) } SEVEN: for (var x in {}) for (var x in {}) for (var x in {}) continue SEVEN; ->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) ->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) ->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) EIGHT: for (var x in {}){ ->x : Symbol(x, Decl(forInContinueStatements.ts, 0, 7), Decl(forInContinueStatements.ts, 5, 7), Decl(forInContinueStatements.ts, 11, 7), Decl(forInContinueStatements.ts, 16, 7), Decl(forInContinueStatements.ts, 18, 11), Decl(forInContinueStatements.ts, 23, 7), Decl(forInContinueStatements.ts, 25, 11), Decl(forInContinueStatements.ts, 29, 8), Decl(forInContinueStatements.ts, 29, 26), Decl(forInContinueStatements.ts, 29, 44), Decl(forInContinueStatements.ts, 32, 8)) +>x : Symbol(x, Decl(forInContinueStatements.ts, 1, 7), Decl(forInContinueStatements.ts, 6, 7), Decl(forInContinueStatements.ts, 12, 7), Decl(forInContinueStatements.ts, 17, 7), Decl(forInContinueStatements.ts, 19, 11), Decl(forInContinueStatements.ts, 24, 7), Decl(forInContinueStatements.ts, 26, 11), Decl(forInContinueStatements.ts, 30, 8), Decl(forInContinueStatements.ts, 30, 26), Decl(forInContinueStatements.ts, 30, 44), Decl(forInContinueStatements.ts, 33, 8)) var fn = function () { } ->fn : Symbol(fn, Decl(forInContinueStatements.ts, 33, 7)) +>fn : Symbol(fn, Decl(forInContinueStatements.ts, 34, 7)) continue EIGHT; } diff --git a/tests/baselines/reference/forInContinueStatements.types b/tests/baselines/reference/forInContinueStatements.types index 95637345fa686..572fd16053d33 100644 --- a/tests/baselines/reference/forInContinueStatements.types +++ b/tests/baselines/reference/forInContinueStatements.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts === + for(var x in {}) { >x : any >{} : {} diff --git a/tests/baselines/reference/forStatements.js b/tests/baselines/reference/forStatements.js index 39fdb6c8871f6..253fafc81e85c 100644 --- a/tests/baselines/reference/forStatements.js +++ b/tests/baselines/reference/forStatements.js @@ -1,4 +1,5 @@ //// [forStatements.ts] + interface I { id: number; } diff --git a/tests/baselines/reference/forStatements.symbols b/tests/baselines/reference/forStatements.symbols index e72d55e581388..2d5250217f97c 100644 --- a/tests/baselines/reference/forStatements.symbols +++ b/tests/baselines/reference/forStatements.symbols @@ -1,145 +1,146 @@ === tests/cases/conformance/statements/forStatements/forStatements.ts === + interface I { >I : Symbol(I, Decl(forStatements.ts, 0, 0)) id: number; ->id : Symbol(id, Decl(forStatements.ts, 0, 13)) +>id : Symbol(id, Decl(forStatements.ts, 1, 13)) } class C implements I { ->C : Symbol(C, Decl(forStatements.ts, 2, 1)) +>C : Symbol(C, Decl(forStatements.ts, 3, 1)) >I : Symbol(I, Decl(forStatements.ts, 0, 0)) id: number; ->id : Symbol(id, Decl(forStatements.ts, 4, 22)) +>id : Symbol(id, Decl(forStatements.ts, 5, 22)) } class D{ ->D : Symbol(D, Decl(forStatements.ts, 6, 1)) ->T : Symbol(T, Decl(forStatements.ts, 8, 8)) +>D : Symbol(D, Decl(forStatements.ts, 7, 1)) +>T : Symbol(T, Decl(forStatements.ts, 9, 8)) source: T; ->source : Symbol(source, Decl(forStatements.ts, 8, 11)) ->T : Symbol(T, Decl(forStatements.ts, 8, 8)) +>source : Symbol(source, Decl(forStatements.ts, 9, 11)) +>T : Symbol(T, Decl(forStatements.ts, 9, 8)) recurse: D; ->recurse : Symbol(recurse, Decl(forStatements.ts, 9, 14)) ->D : Symbol(D, Decl(forStatements.ts, 6, 1)) ->T : Symbol(T, Decl(forStatements.ts, 8, 8)) +>recurse : Symbol(recurse, Decl(forStatements.ts, 10, 14)) +>D : Symbol(D, Decl(forStatements.ts, 7, 1)) +>T : Symbol(T, Decl(forStatements.ts, 9, 8)) wrapped: D> ->wrapped : Symbol(wrapped, Decl(forStatements.ts, 10, 18)) ->D : Symbol(D, Decl(forStatements.ts, 6, 1)) ->D : Symbol(D, Decl(forStatements.ts, 6, 1)) ->T : Symbol(T, Decl(forStatements.ts, 8, 8)) +>wrapped : Symbol(wrapped, Decl(forStatements.ts, 11, 18)) +>D : Symbol(D, Decl(forStatements.ts, 7, 1)) +>D : Symbol(D, Decl(forStatements.ts, 7, 1)) +>T : Symbol(T, Decl(forStatements.ts, 9, 8)) } function F(x: string): number { return 42; } ->F : Symbol(F, Decl(forStatements.ts, 12, 1)) ->x : Symbol(x, Decl(forStatements.ts, 14, 11)) +>F : Symbol(F, Decl(forStatements.ts, 13, 1)) +>x : Symbol(x, Decl(forStatements.ts, 15, 11)) module M { ->M : Symbol(M, Decl(forStatements.ts, 14, 44)) +>M : Symbol(M, Decl(forStatements.ts, 15, 44)) export class A { ->A : Symbol(A, Decl(forStatements.ts, 16, 10)) +>A : Symbol(A, Decl(forStatements.ts, 17, 10)) name: string; ->name : Symbol(name, Decl(forStatements.ts, 17, 20)) +>name : Symbol(name, Decl(forStatements.ts, 18, 20)) } 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)) +>F2 : Symbol(F2, Decl(forStatements.ts, 20, 5)) +>x : Symbol(x, Decl(forStatements.ts, 22, 23)) >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(forStatements.ts, 21, 23)) +>x : Symbol(x, Decl(forStatements.ts, 22, 23)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } for(var aNumber: number = 9.9;;){} ->aNumber : Symbol(aNumber, Decl(forStatements.ts, 24, 7)) +>aNumber : Symbol(aNumber, Decl(forStatements.ts, 25, 7)) for(var aString: string = 'this is a string';;){} ->aString : Symbol(aString, Decl(forStatements.ts, 25, 7)) +>aString : Symbol(aString, Decl(forStatements.ts, 26, 7)) for(var aDate: Date = new Date(12);;){} ->aDate : Symbol(aDate, Decl(forStatements.ts, 26, 7)) +>aDate : Symbol(aDate, Decl(forStatements.ts, 27, 7)) >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)) +>anObject : Symbol(anObject, Decl(forStatements.ts, 28, 7)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) for(var anAny: any = null;;){} ->anAny : Symbol(anAny, Decl(forStatements.ts, 29, 7)) +>anAny : Symbol(anAny, Decl(forStatements.ts, 30, 7)) for(var aSecondAny: any = undefined;;){} ->aSecondAny : Symbol(aSecondAny, Decl(forStatements.ts, 30, 7)) +>aSecondAny : Symbol(aSecondAny, Decl(forStatements.ts, 31, 7)) >undefined : Symbol(undefined) for(var aVoid: void = undefined;;){} ->aVoid : Symbol(aVoid, Decl(forStatements.ts, 31, 7)) +>aVoid : Symbol(aVoid, Decl(forStatements.ts, 32, 7)) >undefined : Symbol(undefined) for(var anInterface: I = new C();;){} ->anInterface : Symbol(anInterface, Decl(forStatements.ts, 33, 7)) +>anInterface : Symbol(anInterface, Decl(forStatements.ts, 34, 7)) >I : Symbol(I, Decl(forStatements.ts, 0, 0)) ->C : Symbol(C, Decl(forStatements.ts, 2, 1)) +>C : Symbol(C, Decl(forStatements.ts, 3, 1)) for(var aClass: C = new C();;){} ->aClass : Symbol(aClass, Decl(forStatements.ts, 34, 7)) ->C : Symbol(C, Decl(forStatements.ts, 2, 1)) ->C : Symbol(C, Decl(forStatements.ts, 2, 1)) +>aClass : Symbol(aClass, Decl(forStatements.ts, 35, 7)) +>C : Symbol(C, Decl(forStatements.ts, 3, 1)) +>C : Symbol(C, Decl(forStatements.ts, 3, 1)) for(var aGenericClass: D = new D();;){} ->aGenericClass : Symbol(aGenericClass, Decl(forStatements.ts, 35, 7)) ->D : Symbol(D, Decl(forStatements.ts, 6, 1)) ->D : Symbol(D, Decl(forStatements.ts, 6, 1)) +>aGenericClass : Symbol(aGenericClass, Decl(forStatements.ts, 36, 7)) +>D : Symbol(D, Decl(forStatements.ts, 7, 1)) +>D : Symbol(D, Decl(forStatements.ts, 7, 1)) for(var anObjectLiteral: I = { id: 12 };;){} ->anObjectLiteral : Symbol(anObjectLiteral, Decl(forStatements.ts, 36, 7)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(forStatements.ts, 37, 7)) >I : Symbol(I, Decl(forStatements.ts, 0, 0)) ->id : Symbol(id, Decl(forStatements.ts, 36, 30)) +>id : Symbol(id, Decl(forStatements.ts, 37, 30)) for(var anOtherObjectLiteral: { id: number } = new C();;){} ->anOtherObjectLiteral : Symbol(anOtherObjectLiteral, Decl(forStatements.ts, 37, 7)) ->id : Symbol(id, Decl(forStatements.ts, 37, 31)) ->C : Symbol(C, Decl(forStatements.ts, 2, 1)) +>anOtherObjectLiteral : Symbol(anOtherObjectLiteral, Decl(forStatements.ts, 38, 7)) +>id : Symbol(id, Decl(forStatements.ts, 38, 31)) +>C : Symbol(C, Decl(forStatements.ts, 3, 1)) for(var aFunction: typeof F = F;;){} ->aFunction : Symbol(aFunction, Decl(forStatements.ts, 39, 7)) ->F : Symbol(F, Decl(forStatements.ts, 12, 1)) ->F : Symbol(F, Decl(forStatements.ts, 12, 1)) +>aFunction : Symbol(aFunction, Decl(forStatements.ts, 40, 7)) +>F : Symbol(F, Decl(forStatements.ts, 13, 1)) +>F : Symbol(F, Decl(forStatements.ts, 13, 1)) for(var anOtherFunction: (x: string) => number = F;;){} ->anOtherFunction : Symbol(anOtherFunction, Decl(forStatements.ts, 40, 7)) ->x : Symbol(x, Decl(forStatements.ts, 40, 26)) ->F : Symbol(F, Decl(forStatements.ts, 12, 1)) +>anOtherFunction : Symbol(anOtherFunction, Decl(forStatements.ts, 41, 7)) +>x : Symbol(x, Decl(forStatements.ts, 41, 26)) +>F : Symbol(F, Decl(forStatements.ts, 13, 1)) for(var aLambda: typeof F = (x) => 2;;){} ->aLambda : Symbol(aLambda, Decl(forStatements.ts, 41, 7)) ->F : Symbol(F, Decl(forStatements.ts, 12, 1)) ->x : Symbol(x, Decl(forStatements.ts, 41, 29)) +>aLambda : Symbol(aLambda, Decl(forStatements.ts, 42, 7)) +>F : Symbol(F, Decl(forStatements.ts, 13, 1)) +>x : Symbol(x, Decl(forStatements.ts, 42, 29)) for(var aModule: typeof M = M;;){} ->aModule : Symbol(aModule, Decl(forStatements.ts, 43, 7)) ->M : Symbol(M, Decl(forStatements.ts, 14, 44)) ->M : Symbol(M, Decl(forStatements.ts, 14, 44)) +>aModule : Symbol(aModule, Decl(forStatements.ts, 44, 7)) +>M : Symbol(M, Decl(forStatements.ts, 15, 44)) +>M : Symbol(M, Decl(forStatements.ts, 15, 44)) for(var aClassInModule: M.A = new M.A();;){} ->aClassInModule : Symbol(aClassInModule, Decl(forStatements.ts, 44, 7)) ->M : Symbol(M, Decl(forStatements.ts, 14, 44)) ->A : Symbol(M.A, Decl(forStatements.ts, 16, 10)) ->M.A : Symbol(M.A, Decl(forStatements.ts, 16, 10)) ->M : Symbol(M, Decl(forStatements.ts, 14, 44)) ->A : Symbol(M.A, Decl(forStatements.ts, 16, 10)) +>aClassInModule : Symbol(aClassInModule, Decl(forStatements.ts, 45, 7)) +>M : Symbol(M, Decl(forStatements.ts, 15, 44)) +>A : Symbol(M.A, Decl(forStatements.ts, 17, 10)) +>M.A : Symbol(M.A, Decl(forStatements.ts, 17, 10)) +>M : Symbol(M, Decl(forStatements.ts, 15, 44)) +>A : Symbol(M.A, Decl(forStatements.ts, 17, 10)) for(var aFunctionInModule: typeof M.F2 = (x) => 'this is a string';;){} ->aFunctionInModule : Symbol(aFunctionInModule, Decl(forStatements.ts, 45, 7)) ->M.F2 : Symbol(M.F2, Decl(forStatements.ts, 19, 5)) ->M : Symbol(M, Decl(forStatements.ts, 14, 44)) ->F2 : Symbol(M.F2, Decl(forStatements.ts, 19, 5)) ->x : Symbol(x, Decl(forStatements.ts, 45, 42)) +>aFunctionInModule : Symbol(aFunctionInModule, Decl(forStatements.ts, 46, 7)) +>M.F2 : Symbol(M.F2, Decl(forStatements.ts, 20, 5)) +>M : Symbol(M, Decl(forStatements.ts, 15, 44)) +>F2 : Symbol(M.F2, Decl(forStatements.ts, 20, 5)) +>x : Symbol(x, Decl(forStatements.ts, 46, 42)) diff --git a/tests/baselines/reference/forStatements.types b/tests/baselines/reference/forStatements.types index 3fbcf2dbfb2f2..95b198a7fec7a 100644 --- a/tests/baselines/reference/forStatements.types +++ b/tests/baselines/reference/forStatements.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/forStatements/forStatements.ts === + interface I { >I : I diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt index 53ecb88363df4..f1869ae7fca29 100644 --- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt +++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.errors.txt @@ -1,18 +1,19 @@ -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(32,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'number'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(33,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'string'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(34,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'C'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(35,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'D'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(36,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'typeof M'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(39,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'b' must be of type 'I', but here has type 'C'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'b' must be of type 'I', but here has type 'C2'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(43,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(46,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr' must be of type 'string[]', but here has type 'number[]'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr' must be of type 'string[]', but here has type '(C | D)[]'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(50,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr2' must be of type 'D[]', but here has type 'D[]'. -tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(53,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'm' must be of type 'typeof M', but here has type 'typeof A'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(33,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'number'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(34,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'string'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(35,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'C'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(36,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'D'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(37,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'a' must be of type 'any', but here has type 'typeof M'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(40,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'b' must be of type 'I', but here has type 'C'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(41,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'b' must be of type 'I', but here has type 'C2'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(44,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'f' must be of type '(x: string) => number', but here has type '(x: number) => string'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(47,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr' must be of type 'string[]', but here has type 'number[]'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(48,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr' must be of type 'string[]', but here has type '(C | D)[]'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(51,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'arr2' must be of type 'D[]', but here has type 'D[]'. +tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts(54,10): error TS2403: Subsequent variable declarations must have the same type. Variable 'm' must be of type 'typeof M', but here has type 'typeof A'. ==== tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts (12 errors) ==== + interface I { id: number; } diff --git a/tests/baselines/reference/forStatementsMultipleInvalidDecl.js b/tests/baselines/reference/forStatementsMultipleInvalidDecl.js index 1dde99818800d..20639c687cbf6 100644 --- a/tests/baselines/reference/forStatementsMultipleInvalidDecl.js +++ b/tests/baselines/reference/forStatementsMultipleInvalidDecl.js @@ -1,4 +1,5 @@ //// [forStatementsMultipleInvalidDecl.ts] + interface I { id: number; } diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.js b/tests/baselines/reference/forStatementsMultipleValidDecl.js index e95e37d63ac5c..6913894a15f5d 100644 --- a/tests/baselines/reference/forStatementsMultipleValidDecl.js +++ b/tests/baselines/reference/forStatementsMultipleValidDecl.js @@ -1,4 +1,5 @@ //// [forStatementsMultipleValidDecl.ts] + // all expected to be valid for (var x: number; ;) { } diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols index 1f131bb97019d..d2d8ac0100399 100644 --- a/tests/baselines/reference/forStatementsMultipleValidDecl.symbols +++ b/tests/baselines/reference/forStatementsMultipleValidDecl.symbols @@ -1,110 +1,111 @@ === tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts === + // all expected to be valid for (var x: number; ;) { } ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 2, 8), Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 5, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8)) for (var x = 2; ;) { } ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 2, 8), Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 5, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8)) for (var x = undefined; ;) { } ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 2, 8), Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 5, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 3, 8), Decl(forStatementsMultipleValidDecl.ts, 4, 8), Decl(forStatementsMultipleValidDecl.ts, 6, 8)) >undefined : Symbol(undefined) // new declaration space, making redeclaring x as a string valid function declSpace() { ->declSpace : Symbol(declSpace, Decl(forStatementsMultipleValidDecl.ts, 5, 38)) +>declSpace : Symbol(declSpace, Decl(forStatementsMultipleValidDecl.ts, 6, 38)) for (var x = 'this is a string'; ;) { } ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 8, 12)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 9, 12)) } interface Point { x: number; y: number; } ->Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 10, 17)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 10, 28)) +>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 11, 17)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 11, 28)) for (var p: Point; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) ->Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) +>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1)) for (var p = { x: 1, y: 2 }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 13, 14)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 13, 20)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 14, 14)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 14, 20)) for (var p: Point = { x: 0, y: undefined }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) ->Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 9, 1)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 14, 21)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 14, 27)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) +>Point : Symbol(Point, Decl(forStatementsMultipleValidDecl.ts, 10, 1)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 15, 21)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 15, 27)) >undefined : Symbol(undefined) for (var p = { x: 1, y: undefined }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 15, 14)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 15, 20)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 14)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 20)) >undefined : Symbol(undefined) for (var p: { x: number; y: number; } = { x: 1, y: 2 }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 13)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 24)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 16, 41)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 16, 47)) - -for (var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) ->x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 15)) ->y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 26)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 13)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 24)) >x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 17, 41)) >y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 17, 47)) + +for (var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ;) { } +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 18, 15)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 18, 26)) +>x : Symbol(x, Decl(forStatementsMultipleValidDecl.ts, 18, 41)) +>y : Symbol(y, Decl(forStatementsMultipleValidDecl.ts, 18, 47)) >undefined : Symbol(undefined) for (var p: typeof p; ;) { } ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) ->p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 12, 8), Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) +>p : Symbol(p, Decl(forStatementsMultipleValidDecl.ts, 13, 8), Decl(forStatementsMultipleValidDecl.ts, 14, 8), Decl(forStatementsMultipleValidDecl.ts, 15, 8), Decl(forStatementsMultipleValidDecl.ts, 16, 8), Decl(forStatementsMultipleValidDecl.ts, 17, 8), Decl(forStatementsMultipleValidDecl.ts, 18, 8), Decl(forStatementsMultipleValidDecl.ts, 19, 8)) for (var fn = function (s: string) { return 42; }; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 20, 24)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 21, 24)) for (var fn = (s: string) => 3; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 21, 15)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 22, 15)) for (var fn: (s: string) => number; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 22, 14)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 23, 14)) for (var fn: { (s: string): number }; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 23, 16)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 24, 16)) for (var fn = <(s: string) => number> null; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) ->s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 24, 16)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) +>s : Symbol(s, Decl(forStatementsMultipleValidDecl.ts, 25, 16)) for (var fn: typeof fn; ;) { } ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) ->fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 20, 8), Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) +>fn : Symbol(fn, Decl(forStatementsMultipleValidDecl.ts, 21, 8), Decl(forStatementsMultipleValidDecl.ts, 22, 8), Decl(forStatementsMultipleValidDecl.ts, 23, 8), Decl(forStatementsMultipleValidDecl.ts, 24, 8), Decl(forStatementsMultipleValidDecl.ts, 25, 8), Decl(forStatementsMultipleValidDecl.ts, 26, 8)) for (var a: string[]; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) for (var a = ['a', 'b']; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) for (var 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)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) for (var a: string[] = []; ;) { } ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) 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)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) >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)) ->a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 27, 8), Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) +>a : Symbol(a, Decl(forStatementsMultipleValidDecl.ts, 28, 8), Decl(forStatementsMultipleValidDecl.ts, 29, 8), Decl(forStatementsMultipleValidDecl.ts, 30, 8), Decl(forStatementsMultipleValidDecl.ts, 31, 8), Decl(forStatementsMultipleValidDecl.ts, 32, 8), Decl(forStatementsMultipleValidDecl.ts, 33, 8)) diff --git a/tests/baselines/reference/forStatementsMultipleValidDecl.types b/tests/baselines/reference/forStatementsMultipleValidDecl.types index 9b9af5b850e02..acb26f173120b 100644 --- a/tests/baselines/reference/forStatementsMultipleValidDecl.types +++ b/tests/baselines/reference/forStatementsMultipleValidDecl.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts === + // all expected to be valid for (var x: number; ;) { } diff --git a/tests/baselines/reference/functionImplementationErrors.errors.txt b/tests/baselines/reference/functionImplementationErrors.errors.txt index 0c74588c316f8..86ecb6a60576f 100644 --- a/tests/baselines/reference/functionImplementationErrors.errors.txt +++ b/tests/baselines/reference/functionImplementationErrors.errors.txt @@ -1,20 +1,20 @@ -tests/cases/conformance/functions/functionImplementationErrors.ts(2,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/functions/functionImplementationErrors.ts(6,19): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/functions/functionImplementationErrors.ts(10,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/functions/functionImplementationErrors.ts(16,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/functions/functionImplementationErrors.ts(25,16): 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/conformance/functions/functionImplementationErrors.ts(30,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it. -tests/cases/conformance/functions/functionImplementationErrors.ts(35,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it. -tests/cases/conformance/functions/functionImplementationErrors.ts(40,28): 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/conformance/functions/functionImplementationErrors.ts(49,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/functions/functionImplementationErrors.ts(53,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/functions/functionImplementationErrors.ts(57,11): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/functions/functionImplementationErrors.ts(61,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/functions/functionImplementationErrors.ts(65,11): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/functions/functionImplementationErrors.ts(69,11): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/functions/functionImplementationErrors.ts(3,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/functions/functionImplementationErrors.ts(7,19): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/functions/functionImplementationErrors.ts(11,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/functions/functionImplementationErrors.ts(17,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/functions/functionImplementationErrors.ts(26,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/conformance/functions/functionImplementationErrors.ts(31,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it. +tests/cases/conformance/functions/functionImplementationErrors.ts(36,17): error TS2373: Initializer of parameter 'n' cannot reference identifier 'm' declared after it. +tests/cases/conformance/functions/functionImplementationErrors.ts(50,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/functions/functionImplementationErrors.ts(54,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/functions/functionImplementationErrors.ts(58,11): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/functions/functionImplementationErrors.ts(62,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/functions/functionImplementationErrors.ts(66,11): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/functions/functionImplementationErrors.ts(70,11): error TS2354: No best common type exists among return expressions. -==== tests/cases/conformance/functions/functionImplementationErrors.ts (14 errors) ==== +==== tests/cases/conformance/functions/functionImplementationErrors.ts (13 errors) ==== + // FunctionExpression with no return type annotation with multiple return statements with unrelated types var f1 = function () { ~~~~~~~~ @@ -52,7 +52,7 @@ tests/cases/conformance/functions/functionImplementationErrors.ts(69,11): error // Function implemetnation with non -void return type annotation with no return function f5(): number { ~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. } var m; @@ -72,8 +72,6 @@ tests/cases/conformance/functions/functionImplementationErrors.ts(69,11): error // FunctionExpression with non -void return type annotation with a throw, no return, and other code // Should be error but isn't undefined === function (): number { - ~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. throw undefined; var x = 4; }; diff --git a/tests/baselines/reference/functionImplementationErrors.js b/tests/baselines/reference/functionImplementationErrors.js index 42be5f21458ea..4436f1bc94f3f 100644 --- a/tests/baselines/reference/functionImplementationErrors.js +++ b/tests/baselines/reference/functionImplementationErrors.js @@ -1,4 +1,5 @@ //// [functionImplementationErrors.ts] + // FunctionExpression with no return type annotation with multiple return statements with unrelated types var f1 = function () { return ''; diff --git a/tests/baselines/reference/functionImplementations.js b/tests/baselines/reference/functionImplementations.js index 3fc040650e48a..512da960b78d6 100644 --- a/tests/baselines/reference/functionImplementations.js +++ b/tests/baselines/reference/functionImplementations.js @@ -1,4 +1,5 @@ //// [functionImplementations.ts] + // FunctionExpression with no return type annotation and no return statement returns void var v: void = function () { } (); diff --git a/tests/baselines/reference/functionImplementations.symbols b/tests/baselines/reference/functionImplementations.symbols index 3932261b27cb1..07945b5f765f0 100644 --- a/tests/baselines/reference/functionImplementations.symbols +++ b/tests/baselines/reference/functionImplementations.symbols @@ -1,109 +1,110 @@ === tests/cases/conformance/functions/functionImplementations.ts === + // FunctionExpression with no return type annotation and no return statement returns void var v: void = function () { } (); ->v : Symbol(v, Decl(functionImplementations.ts, 1, 3)) +>v : Symbol(v, Decl(functionImplementations.ts, 2, 3)) // FunctionExpression f with no return type annotation and directly references f in its body returns any var a: any = function f() { ->a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) ->f : Symbol(f, Decl(functionImplementations.ts, 4, 12)) +>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) +>f : Symbol(f, Decl(functionImplementations.ts, 5, 12)) return f; ->f : Symbol(f, Decl(functionImplementations.ts, 4, 12)) +>f : Symbol(f, Decl(functionImplementations.ts, 5, 12)) }; var a: any = function f() { ->a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) ->f : Symbol(f, Decl(functionImplementations.ts, 7, 12)) +>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) +>f : Symbol(f, Decl(functionImplementations.ts, 8, 12)) return f(); ->f : Symbol(f, Decl(functionImplementations.ts, 7, 12)) +>f : Symbol(f, Decl(functionImplementations.ts, 8, 12)) }; // FunctionExpression f with no return type annotation and indirectly references f in its body returns any var a: any = function f() { ->a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) ->f : Symbol(f, Decl(functionImplementations.ts, 12, 12)) +>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) +>f : Symbol(f, Decl(functionImplementations.ts, 13, 12)) var x = f; ->x : Symbol(x, Decl(functionImplementations.ts, 13, 7)) ->f : Symbol(f, Decl(functionImplementations.ts, 12, 12)) +>x : Symbol(x, Decl(functionImplementations.ts, 14, 7)) +>f : Symbol(f, Decl(functionImplementations.ts, 13, 12)) return x; ->x : Symbol(x, Decl(functionImplementations.ts, 13, 7)) +>x : Symbol(x, Decl(functionImplementations.ts, 14, 7)) }; // Two mutually recursive function implementations with no return type annotations function rec1() { ->rec1 : Symbol(rec1, Decl(functionImplementations.ts, 15, 2)) +>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2)) return rec2(); ->rec2 : Symbol(rec2, Decl(functionImplementations.ts, 20, 1)) +>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1)) } function rec2() { ->rec2 : Symbol(rec2, Decl(functionImplementations.ts, 20, 1)) +>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1)) return rec1(); ->rec1 : Symbol(rec1, Decl(functionImplementations.ts, 15, 2)) +>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2)) } var a = rec1(); ->a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) ->rec1 : Symbol(rec1, Decl(functionImplementations.ts, 15, 2)) +>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) +>rec1 : Symbol(rec1, Decl(functionImplementations.ts, 16, 2)) var a = rec2(); ->a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) ->rec2 : Symbol(rec2, Decl(functionImplementations.ts, 20, 1)) +>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) +>rec2 : Symbol(rec2, Decl(functionImplementations.ts, 21, 1)) // Two mutually recursive function implementations with return type annotation in one function rec3(): number { ->rec3 : Symbol(rec3, Decl(functionImplementations.ts, 25, 15)) +>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15)) return rec4(); ->rec4 : Symbol(rec4, Decl(functionImplementations.ts, 30, 1)) +>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1)) } function rec4() { ->rec4 : Symbol(rec4, Decl(functionImplementations.ts, 30, 1)) +>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1)) return rec3(); ->rec3 : Symbol(rec3, Decl(functionImplementations.ts, 25, 15)) +>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15)) } var n: number; ->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) +>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) var n = rec3(); ->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) ->rec3 : Symbol(rec3, Decl(functionImplementations.ts, 25, 15)) +>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) +>rec3 : Symbol(rec3, Decl(functionImplementations.ts, 26, 15)) var n = rec4(); ->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) ->rec4 : Symbol(rec4, Decl(functionImplementations.ts, 30, 1)) +>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) +>rec4 : Symbol(rec4, Decl(functionImplementations.ts, 31, 1)) // FunctionExpression with no return type annotation and returns a number var n = function () { ->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) +>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) return 3; } (); // FunctionExpression with no return type annotation and returns null var nu = null; ->nu : Symbol(nu, Decl(functionImplementations.ts, 44, 3), Decl(functionImplementations.ts, 45, 3)) +>nu : Symbol(nu, Decl(functionImplementations.ts, 45, 3), Decl(functionImplementations.ts, 46, 3)) var nu = function () { ->nu : Symbol(nu, Decl(functionImplementations.ts, 44, 3), Decl(functionImplementations.ts, 45, 3)) +>nu : Symbol(nu, Decl(functionImplementations.ts, 45, 3), Decl(functionImplementations.ts, 46, 3)) return null; } (); // FunctionExpression with no return type annotation and returns undefined var un = undefined; ->un : Symbol(un, Decl(functionImplementations.ts, 50, 3), Decl(functionImplementations.ts, 51, 3)) +>un : Symbol(un, Decl(functionImplementations.ts, 51, 3), Decl(functionImplementations.ts, 52, 3)) >undefined : Symbol(undefined) var un = function () { ->un : Symbol(un, Decl(functionImplementations.ts, 50, 3), Decl(functionImplementations.ts, 51, 3)) +>un : Symbol(un, Decl(functionImplementations.ts, 51, 3), Decl(functionImplementations.ts, 52, 3)) return undefined; >undefined : Symbol(undefined) @@ -112,31 +113,31 @@ var un = function () { // FunctionExpression with no return type annotation and returns a type parameter type var n = function (x: T) { ->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) ->T : Symbol(T, Decl(functionImplementations.ts, 56, 18)) ->x : Symbol(x, Decl(functionImplementations.ts, 56, 21)) ->T : Symbol(T, Decl(functionImplementations.ts, 56, 18)) +>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) +>T : Symbol(T, Decl(functionImplementations.ts, 57, 18)) +>x : Symbol(x, Decl(functionImplementations.ts, 57, 21)) +>T : Symbol(T, Decl(functionImplementations.ts, 57, 18)) return x; ->x : Symbol(x, Decl(functionImplementations.ts, 56, 21)) +>x : Symbol(x, Decl(functionImplementations.ts, 57, 21)) } (4); // FunctionExpression with no return type annotation and returns a constrained type parameter type var n = function (x: T) { ->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) ->T : Symbol(T, Decl(functionImplementations.ts, 61, 18)) ->x : Symbol(x, Decl(functionImplementations.ts, 61, 32)) ->T : Symbol(T, Decl(functionImplementations.ts, 61, 18)) +>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) +>T : Symbol(T, Decl(functionImplementations.ts, 62, 18)) +>x : Symbol(x, Decl(functionImplementations.ts, 62, 32)) +>T : Symbol(T, Decl(functionImplementations.ts, 62, 18)) return x; ->x : Symbol(x, Decl(functionImplementations.ts, 61, 32)) +>x : Symbol(x, Decl(functionImplementations.ts, 62, 32)) } (4); // FunctionExpression with no return type annotation with multiple return statements with identical types var n = function () { ->n : Symbol(n, Decl(functionImplementations.ts, 34, 3), Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 39, 3), Decl(functionImplementations.ts, 56, 3), Decl(functionImplementations.ts, 61, 3), Decl(functionImplementations.ts, 66, 3)) +>n : Symbol(n, Decl(functionImplementations.ts, 35, 3), Decl(functionImplementations.ts, 36, 3), Decl(functionImplementations.ts, 37, 3), Decl(functionImplementations.ts, 40, 3), Decl(functionImplementations.ts, 57, 3), Decl(functionImplementations.ts, 62, 3), Decl(functionImplementations.ts, 67, 3)) return 3; return 5; @@ -148,36 +149,36 @@ var n = function () { // A compile - time error occurs if no return statement expression has a type that is a supertype of each of the others. // FunctionExpression with no return type annotation with multiple return statements with subtype relation between returns class Base { private m; } ->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) ->m : Symbol(m, Decl(functionImplementations.ts, 76, 12)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>m : Symbol(m, Decl(functionImplementations.ts, 77, 12)) class Derived extends Base { private q; } ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) ->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) ->q : Symbol(q, Decl(functionImplementations.ts, 77, 28)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>q : Symbol(q, Decl(functionImplementations.ts, 78, 28)) var b: Base; ->b : Symbol(b, Decl(functionImplementations.ts, 78, 3), Decl(functionImplementations.ts, 79, 3)) ->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>b : Symbol(b, Decl(functionImplementations.ts, 79, 3), Decl(functionImplementations.ts, 80, 3)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) var b = function () { ->b : Symbol(b, Decl(functionImplementations.ts, 78, 3), Decl(functionImplementations.ts, 79, 3)) +>b : Symbol(b, Decl(functionImplementations.ts, 79, 3), Decl(functionImplementations.ts, 80, 3)) return new Base(); return new Derived(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) } (); // FunctionExpression with no return type annotation with multiple return statements with one a recursive call var a = function f() { ->a : Symbol(a, Decl(functionImplementations.ts, 4, 3), Decl(functionImplementations.ts, 7, 3), Decl(functionImplementations.ts, 12, 3), Decl(functionImplementations.ts, 24, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 84, 3)) ->f : Symbol(f, Decl(functionImplementations.ts, 84, 7)) +>a : Symbol(a, Decl(functionImplementations.ts, 5, 3), Decl(functionImplementations.ts, 8, 3), Decl(functionImplementations.ts, 13, 3), Decl(functionImplementations.ts, 25, 3), Decl(functionImplementations.ts, 26, 3), Decl(functionImplementations.ts, 85, 3)) +>f : Symbol(f, Decl(functionImplementations.ts, 85, 7)) return new Base(); return new Derived(); return f(); // ? ->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) ->f : Symbol(f, Decl(functionImplementations.ts, 84, 7)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) +>f : Symbol(f, Decl(functionImplementations.ts, 85, 7)) } (); @@ -192,59 +193,59 @@ undefined === function (): number { // Type of 'this' in function implementation is 'any' function thisFunc() { ->thisFunc : Symbol(thisFunc, Decl(functionImplementations.ts, 91, 2)) +>thisFunc : Symbol(thisFunc, Decl(functionImplementations.ts, 92, 2)) var x = this; ->x : Symbol(x, Decl(functionImplementations.ts, 95, 7), Decl(functionImplementations.ts, 96, 7)) +>x : Symbol(x, Decl(functionImplementations.ts, 96, 7), Decl(functionImplementations.ts, 97, 7)) var x: any; ->x : Symbol(x, Decl(functionImplementations.ts, 95, 7), Decl(functionImplementations.ts, 96, 7)) +>x : Symbol(x, Decl(functionImplementations.ts, 96, 7), Decl(functionImplementations.ts, 97, 7)) } // Function signature with optional parameter, no type annotation and initializer has initializer's type function opt1(n = 4) { ->opt1 : Symbol(opt1, Decl(functionImplementations.ts, 97, 1)) ->n : Symbol(n, Decl(functionImplementations.ts, 100, 14)) +>opt1 : Symbol(opt1, Decl(functionImplementations.ts, 98, 1)) +>n : Symbol(n, Decl(functionImplementations.ts, 101, 14)) var m = n; ->m : Symbol(m, Decl(functionImplementations.ts, 101, 7), Decl(functionImplementations.ts, 102, 7)) ->n : Symbol(n, Decl(functionImplementations.ts, 100, 14)) +>m : Symbol(m, Decl(functionImplementations.ts, 102, 7), Decl(functionImplementations.ts, 103, 7)) +>n : Symbol(n, Decl(functionImplementations.ts, 101, 14)) var m: number; ->m : Symbol(m, Decl(functionImplementations.ts, 101, 7), Decl(functionImplementations.ts, 102, 7)) +>m : Symbol(m, Decl(functionImplementations.ts, 102, 7), Decl(functionImplementations.ts, 103, 7)) } // Function signature with optional parameter, no type annotation and initializer has initializer's widened type function opt2(n = { x: null, y: undefined }) { ->opt2 : Symbol(opt2, Decl(functionImplementations.ts, 103, 1)) ->n : Symbol(n, Decl(functionImplementations.ts, 106, 14)) ->x : Symbol(x, Decl(functionImplementations.ts, 106, 19)) ->y : Symbol(y, Decl(functionImplementations.ts, 106, 28)) +>opt2 : Symbol(opt2, Decl(functionImplementations.ts, 104, 1)) +>n : Symbol(n, Decl(functionImplementations.ts, 107, 14)) +>x : Symbol(x, Decl(functionImplementations.ts, 107, 19)) +>y : Symbol(y, Decl(functionImplementations.ts, 107, 28)) >undefined : Symbol(undefined) var m = n; ->m : Symbol(m, Decl(functionImplementations.ts, 107, 7), Decl(functionImplementations.ts, 108, 7)) ->n : Symbol(n, Decl(functionImplementations.ts, 106, 14)) +>m : Symbol(m, Decl(functionImplementations.ts, 108, 7), Decl(functionImplementations.ts, 109, 7)) +>n : Symbol(n, Decl(functionImplementations.ts, 107, 14)) var m: { x: any; y: any }; ->m : Symbol(m, Decl(functionImplementations.ts, 107, 7), Decl(functionImplementations.ts, 108, 7)) ->x : Symbol(x, Decl(functionImplementations.ts, 108, 12)) ->y : Symbol(y, Decl(functionImplementations.ts, 108, 20)) +>m : Symbol(m, Decl(functionImplementations.ts, 108, 7), Decl(functionImplementations.ts, 109, 7)) +>x : Symbol(x, Decl(functionImplementations.ts, 109, 12)) +>y : Symbol(y, Decl(functionImplementations.ts, 109, 20)) } // Function signature with initializer referencing other parameter to the left function opt3(n: number, m = n) { ->opt3 : Symbol(opt3, Decl(functionImplementations.ts, 109, 1)) ->n : Symbol(n, Decl(functionImplementations.ts, 112, 14)) ->m : Symbol(m, Decl(functionImplementations.ts, 112, 24)) ->n : Symbol(n, Decl(functionImplementations.ts, 112, 14)) +>opt3 : Symbol(opt3, Decl(functionImplementations.ts, 110, 1)) +>n : Symbol(n, Decl(functionImplementations.ts, 113, 14)) +>m : Symbol(m, Decl(functionImplementations.ts, 113, 24)) +>n : Symbol(n, Decl(functionImplementations.ts, 113, 14)) var y = m; ->y : Symbol(y, Decl(functionImplementations.ts, 113, 7), Decl(functionImplementations.ts, 114, 7)) ->m : Symbol(m, Decl(functionImplementations.ts, 112, 24)) +>y : Symbol(y, Decl(functionImplementations.ts, 114, 7), Decl(functionImplementations.ts, 115, 7)) +>m : Symbol(m, Decl(functionImplementations.ts, 113, 24)) var y: number; ->y : Symbol(y, Decl(functionImplementations.ts, 113, 7), Decl(functionImplementations.ts, 114, 7)) +>y : Symbol(y, Decl(functionImplementations.ts, 114, 7), Decl(functionImplementations.ts, 115, 7)) } // Function signature with optional parameter has correct codegen @@ -252,93 +253,93 @@ function opt3(n: number, m = n) { // FunctionExpression with non -void return type annotation return with no expression function f6(): number { ->f6 : Symbol(f6, Decl(functionImplementations.ts, 115, 1)) +>f6 : Symbol(f6, Decl(functionImplementations.ts, 116, 1)) return; } class Derived2 extends Base { private r: string; } ->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1)) ->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) ->r : Symbol(r, Decl(functionImplementations.ts, 125, 29)) +>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) +>r : Symbol(r, Decl(functionImplementations.ts, 126, 29)) class AnotherClass { private x } ->AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 125, 50)) ->x : Symbol(x, Decl(functionImplementations.ts, 126, 20)) +>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50)) +>x : Symbol(x, Decl(functionImplementations.ts, 127, 20)) // if f is a contextually typed function expression, the inferred return type is the union type // of the types of the return statement expressions in the function body, // ignoring return statements with no expressions. var f7: (x: number) => string | number = x => { // should be (x: number) => number | string ->f7 : Symbol(f7, Decl(functionImplementations.ts, 130, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 130, 9)) ->x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) +>f7 : Symbol(f7, Decl(functionImplementations.ts, 131, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 131, 9)) +>x : Symbol(x, Decl(functionImplementations.ts, 131, 40)) if (x < 0) { return x; } ->x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) ->x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) +>x : Symbol(x, Decl(functionImplementations.ts, 131, 40)) +>x : Symbol(x, Decl(functionImplementations.ts, 131, 40)) return x.toString(); >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(functionImplementations.ts, 130, 40)) +>x : Symbol(x, Decl(functionImplementations.ts, 131, 40)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } var f8: (x: number) => any = x => { // should be (x: number) => Base ->f8 : Symbol(f8, Decl(functionImplementations.ts, 134, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 134, 9)) ->x : Symbol(x, Decl(functionImplementations.ts, 134, 28)) +>f8 : Symbol(f8, Decl(functionImplementations.ts, 135, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 135, 9)) +>x : Symbol(x, Decl(functionImplementations.ts, 135, 28)) return new Base(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) return new Derived2(); ->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1)) +>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1)) } var f9: (x: number) => any = x => { // should be (x: number) => Base ->f9 : Symbol(f9, Decl(functionImplementations.ts, 138, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 138, 9)) ->x : Symbol(x, Decl(functionImplementations.ts, 138, 28)) +>f9 : Symbol(f9, Decl(functionImplementations.ts, 139, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 139, 9)) +>x : Symbol(x, Decl(functionImplementations.ts, 139, 28)) return new Base(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) return new Derived(); ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) return new Derived2(); ->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1)) +>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1)) } var f10: (x: number) => any = x => { // should be (x: number) => Derived | Derived1 ->f10 : Symbol(f10, Decl(functionImplementations.ts, 143, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 143, 10)) ->x : Symbol(x, Decl(functionImplementations.ts, 143, 29)) +>f10 : Symbol(f10, Decl(functionImplementations.ts, 144, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 144, 10)) +>x : Symbol(x, Decl(functionImplementations.ts, 144, 29)) return new Derived(); ->Derived : Symbol(Derived, Decl(functionImplementations.ts, 76, 25)) +>Derived : Symbol(Derived, Decl(functionImplementations.ts, 77, 25)) return new Derived2(); ->Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 123, 1)) +>Derived2 : Symbol(Derived2, Decl(functionImplementations.ts, 124, 1)) } var f11: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass ->f11 : Symbol(f11, Decl(functionImplementations.ts, 147, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 147, 10)) ->x : Symbol(x, Decl(functionImplementations.ts, 147, 29)) +>f11 : Symbol(f11, Decl(functionImplementations.ts, 148, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 148, 10)) +>x : Symbol(x, Decl(functionImplementations.ts, 148, 29)) return new Base(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) return new AnotherClass(); ->AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 125, 50)) +>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50)) } var f12: (x: number) => any = x => { // should be (x: number) => Base | AnotherClass ->f12 : Symbol(f12, Decl(functionImplementations.ts, 151, 3)) ->x : Symbol(x, Decl(functionImplementations.ts, 151, 10)) ->x : Symbol(x, Decl(functionImplementations.ts, 151, 29)) +>f12 : Symbol(f12, Decl(functionImplementations.ts, 152, 3)) +>x : Symbol(x, Decl(functionImplementations.ts, 152, 10)) +>x : Symbol(x, Decl(functionImplementations.ts, 152, 29)) return new Base(); ->Base : Symbol(Base, Decl(functionImplementations.ts, 69, 4)) +>Base : Symbol(Base, Decl(functionImplementations.ts, 70, 4)) return; // should be ignored return new AnotherClass(); ->AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 125, 50)) +>AnotherClass : Symbol(AnotherClass, Decl(functionImplementations.ts, 126, 50)) } diff --git a/tests/baselines/reference/functionImplementations.types b/tests/baselines/reference/functionImplementations.types index 1398e2974f09b..6690ca68c98c6 100644 --- a/tests/baselines/reference/functionImplementations.types +++ b/tests/baselines/reference/functionImplementations.types @@ -1,4 +1,5 @@ === tests/cases/conformance/functions/functionImplementations.ts === + // FunctionExpression with no return type annotation and no return statement returns void var v: void = function () { } (); >v : void diff --git a/tests/baselines/reference/functionOverloads12.js b/tests/baselines/reference/functionOverloads12.js index 4681e43ee5b26..8d834e8180f60 100644 --- a/tests/baselines/reference/functionOverloads12.js +++ b/tests/baselines/reference/functionOverloads12.js @@ -1,4 +1,5 @@ //// [functionOverloads12.ts] + function foo():string; function foo():number; function foo():any { if (true) return ""; else return 0;} diff --git a/tests/baselines/reference/functionOverloads12.symbols b/tests/baselines/reference/functionOverloads12.symbols index 583e7f5c04572..4744f98c9f2ac 100644 --- a/tests/baselines/reference/functionOverloads12.symbols +++ b/tests/baselines/reference/functionOverloads12.symbols @@ -1,10 +1,11 @@ === tests/cases/compiler/functionOverloads12.ts === + function foo():string; ->foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 0, 22), Decl(functionOverloads12.ts, 1, 22)) +>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22)) function foo():number; ->foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 0, 22), Decl(functionOverloads12.ts, 1, 22)) +>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22)) function foo():any { if (true) return ""; else return 0;} ->foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 0, 22), Decl(functionOverloads12.ts, 1, 22)) +>foo : Symbol(foo, Decl(functionOverloads12.ts, 0, 0), Decl(functionOverloads12.ts, 1, 22), Decl(functionOverloads12.ts, 2, 22)) diff --git a/tests/baselines/reference/functionOverloads12.types b/tests/baselines/reference/functionOverloads12.types index 20f5ee5d5561f..5db8ff68cd4d7 100644 --- a/tests/baselines/reference/functionOverloads12.types +++ b/tests/baselines/reference/functionOverloads12.types @@ -1,4 +1,5 @@ === tests/cases/compiler/functionOverloads12.ts === + function foo():string; >foo : { (): string; (): number; } diff --git a/tests/baselines/reference/functionReturn.js b/tests/baselines/reference/functionReturn.js index c433eec190d72..42d0de5fd7c29 100644 --- a/tests/baselines/reference/functionReturn.js +++ b/tests/baselines/reference/functionReturn.js @@ -1,4 +1,5 @@ //// [functionReturn.ts] + function f0(): void { } function f1() { var n: any = f0(); diff --git a/tests/baselines/reference/functionReturn.symbols b/tests/baselines/reference/functionReturn.symbols index 9c6b794b3d005..630e435635be1 100644 --- a/tests/baselines/reference/functionReturn.symbols +++ b/tests/baselines/reference/functionReturn.symbols @@ -1,28 +1,29 @@ === tests/cases/compiler/functionReturn.ts === + function f0(): void { } >f0 : Symbol(f0, Decl(functionReturn.ts, 0, 0)) function f1() { ->f1 : Symbol(f1, Decl(functionReturn.ts, 0, 23)) +>f1 : Symbol(f1, Decl(functionReturn.ts, 1, 23)) var n: any = f0(); ->n : Symbol(n, Decl(functionReturn.ts, 2, 7)) +>n : Symbol(n, Decl(functionReturn.ts, 3, 7)) >f0 : Symbol(f0, Decl(functionReturn.ts, 0, 0)) } function f2(): any { } ->f2 : Symbol(f2, Decl(functionReturn.ts, 3, 1)) +>f2 : Symbol(f2, Decl(functionReturn.ts, 4, 1)) function f3(): string { return; } ->f3 : Symbol(f3, Decl(functionReturn.ts, 4, 22)) +>f3 : Symbol(f3, Decl(functionReturn.ts, 5, 22)) function f4(): string { ->f4 : Symbol(f4, Decl(functionReturn.ts, 5, 33)) +>f4 : Symbol(f4, Decl(functionReturn.ts, 6, 33)) return ''; return; } function f5(): string { ->f5 : Symbol(f5, Decl(functionReturn.ts, 9, 1)) +>f5 : Symbol(f5, Decl(functionReturn.ts, 10, 1)) return ''; return undefined; diff --git a/tests/baselines/reference/functionReturn.types b/tests/baselines/reference/functionReturn.types index 6fc9d680db90c..f9c0b36fbc23a 100644 --- a/tests/baselines/reference/functionReturn.types +++ b/tests/baselines/reference/functionReturn.types @@ -1,4 +1,5 @@ === tests/cases/compiler/functionReturn.ts === + function f0(): void { } >f0 : () => void diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.errors.txt b/tests/baselines/reference/functionWithMultipleReturnStatements.errors.txt index 8a57d8e08e663..a981d337093ea 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements.errors.txt +++ b/tests/baselines/reference/functionWithMultipleReturnStatements.errors.txt @@ -1,15 +1,16 @@ -tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(4,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(12,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(22,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(31,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(43,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(48,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(56,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(56,13): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list. -tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(56,26): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list. +tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(5,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(13,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(23,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(32,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(44,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(49,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(57,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(57,13): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list. +tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts(57,26): error TS2313: Constraint of a type parameter cannot reference any type parameter from the same type parameter list. ==== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts (9 errors) ==== + // return type of a function with multiple returns is the BCT of each return statement // it is an error if there is no single BCT, these are error cases diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements.js b/tests/baselines/reference/functionWithMultipleReturnStatements.js index 347a05d0f3355..d44c37ebbf0e7 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements.js +++ b/tests/baselines/reference/functionWithMultipleReturnStatements.js @@ -1,4 +1,5 @@ //// [functionWithMultipleReturnStatements.ts] + // return type of a function with multiple returns is the BCT of each return statement // it is an error if there is no single BCT, these are error cases diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt b/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt index bbaa5a855786c..0399c7a79a6a6 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt +++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.errors.txt @@ -1,8 +1,9 @@ -tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(58,10): error TS2354: No best common type exists among return expressions. -tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(67,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(59,10): error TS2354: No best common type exists among return expressions. +tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts(68,10): error TS2354: No best common type exists among return expressions. ==== tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts (2 errors) ==== + // return type of a function with multiple returns is the BCT of each return statement // no errors expected here diff --git a/tests/baselines/reference/functionWithMultipleReturnStatements2.js b/tests/baselines/reference/functionWithMultipleReturnStatements2.js index 4674c6db953e1..efee5816fb668 100644 --- a/tests/baselines/reference/functionWithMultipleReturnStatements2.js +++ b/tests/baselines/reference/functionWithMultipleReturnStatements2.js @@ -1,4 +1,5 @@ //// [functionWithMultipleReturnStatements2.ts] + // return type of a function with multiple returns is the BCT of each return statement // no errors expected here diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.errors.txt b/tests/baselines/reference/functionWithNoBestCommonType1.errors.txt index 3c8fef3eb4998..86234b7dd81b2 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType1.errors.txt +++ b/tests/baselines/reference/functionWithNoBestCommonType1.errors.txt @@ -1,7 +1,8 @@ -tests/cases/compiler/functionWithNoBestCommonType1.ts(1,10): error TS2354: No best common type exists among return expressions. +tests/cases/compiler/functionWithNoBestCommonType1.ts(2,10): error TS2354: No best common type exists among return expressions. ==== tests/cases/compiler/functionWithNoBestCommonType1.ts (1 errors) ==== + function foo() { ~~~ !!! error TS2354: No best common type exists among return expressions. diff --git a/tests/baselines/reference/functionWithNoBestCommonType1.js b/tests/baselines/reference/functionWithNoBestCommonType1.js index f7114fb40d891..4d197c24334ba 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType1.js +++ b/tests/baselines/reference/functionWithNoBestCommonType1.js @@ -1,4 +1,5 @@ //// [functionWithNoBestCommonType1.ts] + function foo() { return true; return bar(); diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.errors.txt b/tests/baselines/reference/functionWithNoBestCommonType2.errors.txt index 981e330d9b521..6ce898e447cf6 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType2.errors.txt +++ b/tests/baselines/reference/functionWithNoBestCommonType2.errors.txt @@ -1,7 +1,8 @@ -tests/cases/compiler/functionWithNoBestCommonType2.ts(1,9): error TS2354: No best common type exists among return expressions. +tests/cases/compiler/functionWithNoBestCommonType2.ts(2,9): error TS2354: No best common type exists among return expressions. ==== tests/cases/compiler/functionWithNoBestCommonType2.ts (1 errors) ==== + var v = function () { ~~~~~~~~ !!! error TS2354: No best common type exists among return expressions. diff --git a/tests/baselines/reference/functionWithNoBestCommonType2.js b/tests/baselines/reference/functionWithNoBestCommonType2.js index 8e903518ec0fb..06a133b2db8ec 100644 --- a/tests/baselines/reference/functionWithNoBestCommonType2.js +++ b/tests/baselines/reference/functionWithNoBestCommonType2.js @@ -1,4 +1,5 @@ //// [functionWithNoBestCommonType2.ts] + var v = function () { return true; return bar(); diff --git a/tests/baselines/reference/functionWithThrowButNoReturn1.errors.txt b/tests/baselines/reference/functionWithThrowButNoReturn1.errors.txt deleted file mode 100644 index 72f45da8d9719..0000000000000 --- a/tests/baselines/reference/functionWithThrowButNoReturn1.errors.txt +++ /dev/null @@ -1,11 +0,0 @@ -tests/cases/compiler/functionWithThrowButNoReturn1.ts(1,16): 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/functionWithThrowButNoReturn1.ts (1 errors) ==== - function fn(): number { - ~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. - throw new Error('NYI'); - var t; - } - \ No newline at end of file diff --git a/tests/baselines/reference/functionWithThrowButNoReturn1.symbols b/tests/baselines/reference/functionWithThrowButNoReturn1.symbols new file mode 100644 index 0000000000000..ebc67c6f466f9 --- /dev/null +++ b/tests/baselines/reference/functionWithThrowButNoReturn1.symbols @@ -0,0 +1,11 @@ +=== tests/cases/compiler/functionWithThrowButNoReturn1.ts === +function fn(): number { +>fn : Symbol(fn, Decl(functionWithThrowButNoReturn1.ts, 0, 0)) + + throw new Error('NYI'); +>Error : Symbol(Error, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) + + var t; +>t : Symbol(t, Decl(functionWithThrowButNoReturn1.ts, 2, 5)) +} + diff --git a/tests/baselines/reference/functionWithThrowButNoReturn1.types b/tests/baselines/reference/functionWithThrowButNoReturn1.types new file mode 100644 index 0000000000000..c136d8a407602 --- /dev/null +++ b/tests/baselines/reference/functionWithThrowButNoReturn1.types @@ -0,0 +1,13 @@ +=== tests/cases/compiler/functionWithThrowButNoReturn1.ts === +function fn(): number { +>fn : () => number + + throw new Error('NYI'); +>new Error('NYI') : Error +>Error : ErrorConstructor +>'NYI' : string + + var t; +>t : any +} + diff --git a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt index 2c5ff15f8630a..58ffd051d4d6b 100644 --- a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt +++ b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.errors.txt @@ -1,15 +1,14 @@ -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(2,16): 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/functionsMissingReturnStatementsAndExpressions.ts(64,17): 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/functionsMissingReturnStatementsAndExpressions.ts(94,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(112,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. -tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(117,5): error TS1003: Identifier expected. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(3,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(95,16): error TS2378: A 'get' accessor must return a value. +tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(118,5): error TS1003: Identifier expected. -==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (5 errors) ==== +==== tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts (3 errors) ==== + function f1(): string { ~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. // errors because there are no return statements } @@ -72,8 +71,6 @@ tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(117,5): e } function f14(): number { - ~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. // Not fine, since we can *only* consist of a single throw statement // if no return statements are present but we are annotated. throw undefined; @@ -105,7 +102,7 @@ tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(117,5): e class C { public get m1() { ~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. // Errors; get accessors must return a value. } @@ -124,8 +121,6 @@ tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts(117,5): e } public get m5() { - ~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. // Not fine, since we can *only* consist of a single throw statement // if no return statements are present but we are a get accessor. throw null; diff --git a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js index 592a03d71582c..f76e5342aee29 100644 --- a/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js +++ b/tests/baselines/reference/functionsMissingReturnStatementsAndExpressions.js @@ -1,5 +1,6 @@ //// [functionsMissingReturnStatementsAndExpressions.ts] + function f1(): string { // errors because there are no return statements } diff --git a/tests/baselines/reference/generatedContextualTyping.js b/tests/baselines/reference/generatedContextualTyping.js index 1f7d2b8035fb5..a867d4b762933 100644 --- a/tests/baselines/reference/generatedContextualTyping.js +++ b/tests/baselines/reference/generatedContextualTyping.js @@ -1,4 +1,5 @@ //// [generatedContextualTyping.ts] + class Base { private p; } class Derived1 extends Base { private m; } class Derived2 extends Base { private n; } diff --git a/tests/baselines/reference/generatedContextualTyping.symbols b/tests/baselines/reference/generatedContextualTyping.symbols index df0bb33e02f5e..bc50fcc25c60a 100644 --- a/tests/baselines/reference/generatedContextualTyping.symbols +++ b/tests/baselines/reference/generatedContextualTyping.symbols @@ -1,2831 +1,2832 @@ === tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts === + class Base { private p; } >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->p : Symbol(p, Decl(generatedContextualTyping.ts, 0, 12)) +>p : Symbol(p, Decl(generatedContextualTyping.ts, 1, 12)) class Derived1 extends Base { private m; } ->Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 0, 25)) +>Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 1, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->m : Symbol(m, Decl(generatedContextualTyping.ts, 1, 29)) +>m : Symbol(m, Decl(generatedContextualTyping.ts, 2, 29)) class Derived2 extends Base { private n; } ->Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 1, 42)) +>Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 2, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 2, 29)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 3, 29)) interface Genric { func(n: T[]); } ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) ->T : Symbol(T, Decl(generatedContextualTyping.ts, 3, 17)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 3, 21)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 3, 27)) ->T : Symbol(T, Decl(generatedContextualTyping.ts, 3, 17)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>T : Symbol(T, Decl(generatedContextualTyping.ts, 4, 17)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 4, 21)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 4, 27)) +>T : Symbol(T, Decl(generatedContextualTyping.ts, 4, 17)) var b = new Base(), d1 = new Derived1(), d2 = new Derived2(); ->b : Symbol(b, Decl(generatedContextualTyping.ts, 4, 3)) +>b : Symbol(b, Decl(generatedContextualTyping.ts, 5, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 0, 25)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 1, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>Derived1 : Symbol(Derived1, Decl(generatedContextualTyping.ts, 1, 25)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>Derived2 : Symbol(Derived2, Decl(generatedContextualTyping.ts, 2, 42)) var x1: () => Base[] = () => [d1, d2]; ->x1 : Symbol(x1, Decl(generatedContextualTyping.ts, 5, 3)) +>x1 : Symbol(x1, Decl(generatedContextualTyping.ts, 6, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x2: () => Base[] = function() { return [d1, d2] }; ->x2 : Symbol(x2, Decl(generatedContextualTyping.ts, 6, 3)) +>x2 : Symbol(x2, Decl(generatedContextualTyping.ts, 7, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x3: () => Base[] = function named() { return [d1, d2] }; ->x3 : Symbol(x3, Decl(generatedContextualTyping.ts, 7, 3)) +>x3 : Symbol(x3, Decl(generatedContextualTyping.ts, 8, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 7, 22)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 8, 22)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x4: { (): Base[]; } = () => [d1, d2]; ->x4 : Symbol(x4, Decl(generatedContextualTyping.ts, 8, 3)) +>x4 : Symbol(x4, Decl(generatedContextualTyping.ts, 9, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x5: { (): Base[]; } = function() { return [d1, d2] }; ->x5 : Symbol(x5, Decl(generatedContextualTyping.ts, 9, 3)) +>x5 : Symbol(x5, Decl(generatedContextualTyping.ts, 10, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x6: { (): Base[]; } = function named() { return [d1, d2] }; ->x6 : Symbol(x6, Decl(generatedContextualTyping.ts, 10, 3)) +>x6 : Symbol(x6, Decl(generatedContextualTyping.ts, 11, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 10, 25)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 11, 25)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x7: Base[] = [d1, d2]; ->x7 : Symbol(x7, Decl(generatedContextualTyping.ts, 11, 3)) +>x7 : Symbol(x7, Decl(generatedContextualTyping.ts, 12, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x8: Array = [d1, d2]; ->x8 : Symbol(x8, Decl(generatedContextualTyping.ts, 12, 3)) +>x8 : Symbol(x8, Decl(generatedContextualTyping.ts, 13, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x9: { [n: number]: Base; } = [d1, d2]; ->x9 : Symbol(x9, Decl(generatedContextualTyping.ts, 13, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 13, 11)) +>x9 : Symbol(x9, Decl(generatedContextualTyping.ts, 14, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x10: {n: Base[]; } = { n: [d1, d2] }; ->x10 : Symbol(x10, Decl(generatedContextualTyping.ts, 14, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 10)) +>x10 : Symbol(x10, Decl(generatedContextualTyping.ts, 15, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 10)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 14, 27)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 27)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x11: (s: Base[]) => any = n => { var n: Base[]; return null; }; ->x11 : Symbol(x11, Decl(generatedContextualTyping.ts, 15, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 15, 10)) +>x11 : Symbol(x11, Decl(generatedContextualTyping.ts, 16, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 16, 10)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 29), Decl(generatedContextualTyping.ts, 15, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 15, 29), Decl(generatedContextualTyping.ts, 15, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 29), Decl(generatedContextualTyping.ts, 16, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 29), Decl(generatedContextualTyping.ts, 16, 40)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x12: Genric = { func: n => { return [d1, d2]; } }; ->x12 : Symbol(x12, Decl(generatedContextualTyping.ts, 16, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x12 : Symbol(x12, Decl(generatedContextualTyping.ts, 17, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 16, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 16, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 17, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 17, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x13 { member: () => Base[] = () => [d1, d2] } ->x13 : Symbol(x13, Decl(generatedContextualTyping.ts, 16, 60)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 17, 11)) +>x13 : Symbol(x13, Decl(generatedContextualTyping.ts, 17, 60)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 18, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x14 { member: () => Base[] = function() { return [d1, d2] } } ->x14 : Symbol(x14, Decl(generatedContextualTyping.ts, 17, 51)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 18, 11)) +>x14 : Symbol(x14, Decl(generatedContextualTyping.ts, 18, 51)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 19, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x15 { member: () => Base[] = function named() { return [d1, d2] } } ->x15 : Symbol(x15, Decl(generatedContextualTyping.ts, 18, 67)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 19, 11)) +>x15 : Symbol(x15, Decl(generatedContextualTyping.ts, 19, 67)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 20, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 19, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 20, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x16 { member: { (): Base[]; } = () => [d1, d2] } ->x16 : Symbol(x16, Decl(generatedContextualTyping.ts, 19, 73)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 20, 11)) +>x16 : Symbol(x16, Decl(generatedContextualTyping.ts, 20, 73)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 21, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x17 { member: { (): Base[]; } = function() { return [d1, d2] } } ->x17 : Symbol(x17, Decl(generatedContextualTyping.ts, 20, 54)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 21, 11)) +>x17 : Symbol(x17, Decl(generatedContextualTyping.ts, 21, 54)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 22, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x18 { member: { (): Base[]; } = function named() { return [d1, d2] } } ->x18 : Symbol(x18, Decl(generatedContextualTyping.ts, 21, 70)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 22, 11)) +>x18 : Symbol(x18, Decl(generatedContextualTyping.ts, 22, 70)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 23, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 22, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 23, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x19 { member: Base[] = [d1, d2] } ->x19 : Symbol(x19, Decl(generatedContextualTyping.ts, 22, 76)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 23, 11)) +>x19 : Symbol(x19, Decl(generatedContextualTyping.ts, 23, 76)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 24, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x20 { member: Array = [d1, d2] } ->x20 : Symbol(x20, Decl(generatedContextualTyping.ts, 23, 39)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 24, 11)) +>x20 : Symbol(x20, Decl(generatedContextualTyping.ts, 24, 39)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 25, 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)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x21 { member: { [n: number]: Base; } = [d1, d2] } ->x21 : Symbol(x21, Decl(generatedContextualTyping.ts, 24, 44)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 25, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 25, 23)) +>x21 : Symbol(x21, Decl(generatedContextualTyping.ts, 25, 44)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 26, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 23)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x22 { member: {n: Base[]; } = { n: [d1, d2] } } ->x22 : Symbol(x22, Decl(generatedContextualTyping.ts, 25, 55)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 26, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 21)) +>x22 : Symbol(x22, Decl(generatedContextualTyping.ts, 26, 55)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 27, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 21)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 26, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x23 { member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x23 : Symbol(x23, Decl(generatedContextualTyping.ts, 26, 54)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 27, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 27, 21)) +>x23 : Symbol(x23, Decl(generatedContextualTyping.ts, 27, 54)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 28, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 28, 21)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 40), Decl(generatedContextualTyping.ts, 27, 51)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 27, 40), Decl(generatedContextualTyping.ts, 27, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 40), Decl(generatedContextualTyping.ts, 28, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 40), Decl(generatedContextualTyping.ts, 28, 51)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x24 { member: Genric = { func: n => { return [d1, d2]; } } } ->x24 : Symbol(x24, Decl(generatedContextualTyping.ts, 27, 79)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 28, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x24 : Symbol(x24, Decl(generatedContextualTyping.ts, 28, 79)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 29, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 28, 36)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 28, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 29, 36)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 29, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x25 { private member: () => Base[] = () => [d1, d2] } ->x25 : Symbol(x25, Decl(generatedContextualTyping.ts, 28, 72)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 29, 11)) +>x25 : Symbol(x25, Decl(generatedContextualTyping.ts, 29, 72)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 30, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x26 { private member: () => Base[] = function() { return [d1, d2] } } ->x26 : Symbol(x26, Decl(generatedContextualTyping.ts, 29, 59)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 30, 11)) +>x26 : Symbol(x26, Decl(generatedContextualTyping.ts, 30, 59)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 31, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x27 { private member: () => Base[] = function named() { return [d1, d2] } } ->x27 : Symbol(x27, Decl(generatedContextualTyping.ts, 30, 75)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 31, 11)) +>x27 : Symbol(x27, Decl(generatedContextualTyping.ts, 31, 75)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 32, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 31, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 32, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x28 { private member: { (): Base[]; } = () => [d1, d2] } ->x28 : Symbol(x28, Decl(generatedContextualTyping.ts, 31, 81)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 32, 11)) +>x28 : Symbol(x28, Decl(generatedContextualTyping.ts, 32, 81)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 33, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x29 { private member: { (): Base[]; } = function() { return [d1, d2] } } ->x29 : Symbol(x29, Decl(generatedContextualTyping.ts, 32, 62)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 33, 11)) +>x29 : Symbol(x29, Decl(generatedContextualTyping.ts, 33, 62)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 34, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x30 { private member: { (): Base[]; } = function named() { return [d1, d2] } } ->x30 : Symbol(x30, Decl(generatedContextualTyping.ts, 33, 78)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 34, 11)) +>x30 : Symbol(x30, Decl(generatedContextualTyping.ts, 34, 78)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 35, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 34, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 35, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x31 { private member: Base[] = [d1, d2] } ->x31 : Symbol(x31, Decl(generatedContextualTyping.ts, 34, 84)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 35, 11)) +>x31 : Symbol(x31, Decl(generatedContextualTyping.ts, 35, 84)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 36, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x32 { private member: Array = [d1, d2] } ->x32 : Symbol(x32, Decl(generatedContextualTyping.ts, 35, 47)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 36, 11)) +>x32 : Symbol(x32, Decl(generatedContextualTyping.ts, 36, 47)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 37, 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)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x33 { private member: { [n: number]: Base; } = [d1, d2] } ->x33 : Symbol(x33, Decl(generatedContextualTyping.ts, 36, 52)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 37, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 37, 31)) +>x33 : Symbol(x33, Decl(generatedContextualTyping.ts, 37, 52)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 38, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 31)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x34 { private member: {n: Base[]; } = { n: [d1, d2] } } ->x34 : Symbol(x34, Decl(generatedContextualTyping.ts, 37, 63)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 38, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 29)) +>x34 : Symbol(x34, Decl(generatedContextualTyping.ts, 38, 63)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 39, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 29)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 38, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x35 { private member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x35 : Symbol(x35, Decl(generatedContextualTyping.ts, 38, 62)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 39, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 39, 29)) +>x35 : Symbol(x35, Decl(generatedContextualTyping.ts, 39, 62)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 40, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 40, 29)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 48), Decl(generatedContextualTyping.ts, 39, 59)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 39, 48), Decl(generatedContextualTyping.ts, 39, 59)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 48), Decl(generatedContextualTyping.ts, 40, 59)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 48), Decl(generatedContextualTyping.ts, 40, 59)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x36 { private member: Genric = { func: n => { return [d1, d2]; } } } ->x36 : Symbol(x36, Decl(generatedContextualTyping.ts, 39, 87)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 40, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x36 : Symbol(x36, Decl(generatedContextualTyping.ts, 40, 87)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 41, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 40, 44)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 40, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 41, 44)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 41, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x37 { public member: () => Base[] = () => [d1, d2] } ->x37 : Symbol(x37, Decl(generatedContextualTyping.ts, 40, 80)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 41, 11)) +>x37 : Symbol(x37, Decl(generatedContextualTyping.ts, 41, 80)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 42, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x38 { public member: () => Base[] = function() { return [d1, d2] } } ->x38 : Symbol(x38, Decl(generatedContextualTyping.ts, 41, 58)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 42, 11)) +>x38 : Symbol(x38, Decl(generatedContextualTyping.ts, 42, 58)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 43, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x39 { public member: () => Base[] = function named() { return [d1, d2] } } ->x39 : Symbol(x39, Decl(generatedContextualTyping.ts, 42, 74)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 43, 11)) +>x39 : Symbol(x39, Decl(generatedContextualTyping.ts, 43, 74)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 44, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 43, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 44, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x40 { public member: { (): Base[]; } = () => [d1, d2] } ->x40 : Symbol(x40, Decl(generatedContextualTyping.ts, 43, 80)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 44, 11)) +>x40 : Symbol(x40, Decl(generatedContextualTyping.ts, 44, 80)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 45, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x41 { public member: { (): Base[]; } = function() { return [d1, d2] } } ->x41 : Symbol(x41, Decl(generatedContextualTyping.ts, 44, 61)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 45, 11)) +>x41 : Symbol(x41, Decl(generatedContextualTyping.ts, 45, 61)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 46, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x42 { public member: { (): Base[]; } = function named() { return [d1, d2] } } ->x42 : Symbol(x42, Decl(generatedContextualTyping.ts, 45, 77)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 46, 11)) +>x42 : Symbol(x42, Decl(generatedContextualTyping.ts, 46, 77)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 47, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 46, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 47, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x43 { public member: Base[] = [d1, d2] } ->x43 : Symbol(x43, Decl(generatedContextualTyping.ts, 46, 83)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 47, 11)) +>x43 : Symbol(x43, Decl(generatedContextualTyping.ts, 47, 83)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 48, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x44 { public member: Array = [d1, d2] } ->x44 : Symbol(x44, Decl(generatedContextualTyping.ts, 47, 46)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 48, 11)) +>x44 : Symbol(x44, Decl(generatedContextualTyping.ts, 48, 46)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 49, 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)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x45 { public member: { [n: number]: Base; } = [d1, d2] } ->x45 : Symbol(x45, Decl(generatedContextualTyping.ts, 48, 51)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 49, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 49, 30)) +>x45 : Symbol(x45, Decl(generatedContextualTyping.ts, 49, 51)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 50, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 30)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x46 { public member: {n: Base[]; } = { n: [d1, d2] } } ->x46 : Symbol(x46, Decl(generatedContextualTyping.ts, 49, 62)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 50, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 28)) +>x46 : Symbol(x46, Decl(generatedContextualTyping.ts, 50, 62)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 51, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 28)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 50, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x47 { public member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x47 : Symbol(x47, Decl(generatedContextualTyping.ts, 50, 61)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 51, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 51, 28)) +>x47 : Symbol(x47, Decl(generatedContextualTyping.ts, 51, 61)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 52, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 52, 28)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 47), Decl(generatedContextualTyping.ts, 51, 58)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 51, 47), Decl(generatedContextualTyping.ts, 51, 58)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 47), Decl(generatedContextualTyping.ts, 52, 58)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 47), Decl(generatedContextualTyping.ts, 52, 58)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x48 { public member: Genric = { func: n => { return [d1, d2]; } } } ->x48 : Symbol(x48, Decl(generatedContextualTyping.ts, 51, 86)) ->member : Symbol(member, Decl(generatedContextualTyping.ts, 52, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x48 : Symbol(x48, Decl(generatedContextualTyping.ts, 52, 86)) +>member : Symbol(member, Decl(generatedContextualTyping.ts, 53, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 52, 43)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 52, 49)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 53, 43)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 53, 49)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x49 { static member: () => Base[] = () => [d1, d2] } ->x49 : Symbol(x49, Decl(generatedContextualTyping.ts, 52, 79)) ->member : Symbol(x49.member, Decl(generatedContextualTyping.ts, 53, 11)) +>x49 : Symbol(x49, Decl(generatedContextualTyping.ts, 53, 79)) +>member : Symbol(x49.member, Decl(generatedContextualTyping.ts, 54, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x50 { static member: () => Base[] = function() { return [d1, d2] } } ->x50 : Symbol(x50, Decl(generatedContextualTyping.ts, 53, 58)) ->member : Symbol(x50.member, Decl(generatedContextualTyping.ts, 54, 11)) +>x50 : Symbol(x50, Decl(generatedContextualTyping.ts, 54, 58)) +>member : Symbol(x50.member, Decl(generatedContextualTyping.ts, 55, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x51 { static member: () => Base[] = function named() { return [d1, d2] } } ->x51 : Symbol(x51, Decl(generatedContextualTyping.ts, 54, 74)) ->member : Symbol(x51.member, Decl(generatedContextualTyping.ts, 55, 11)) +>x51 : Symbol(x51, Decl(generatedContextualTyping.ts, 55, 74)) +>member : Symbol(x51.member, Decl(generatedContextualTyping.ts, 56, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 55, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 56, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x52 { static member: { (): Base[]; } = () => [d1, d2] } ->x52 : Symbol(x52, Decl(generatedContextualTyping.ts, 55, 80)) ->member : Symbol(x52.member, Decl(generatedContextualTyping.ts, 56, 11)) +>x52 : Symbol(x52, Decl(generatedContextualTyping.ts, 56, 80)) +>member : Symbol(x52.member, Decl(generatedContextualTyping.ts, 57, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x53 { static member: { (): Base[]; } = function() { return [d1, d2] } } ->x53 : Symbol(x53, Decl(generatedContextualTyping.ts, 56, 61)) ->member : Symbol(x53.member, Decl(generatedContextualTyping.ts, 57, 11)) +>x53 : Symbol(x53, Decl(generatedContextualTyping.ts, 57, 61)) +>member : Symbol(x53.member, Decl(generatedContextualTyping.ts, 58, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x54 { static member: { (): Base[]; } = function named() { return [d1, d2] } } ->x54 : Symbol(x54, Decl(generatedContextualTyping.ts, 57, 77)) ->member : Symbol(x54.member, Decl(generatedContextualTyping.ts, 58, 11)) +>x54 : Symbol(x54, Decl(generatedContextualTyping.ts, 58, 77)) +>member : Symbol(x54.member, Decl(generatedContextualTyping.ts, 59, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 58, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 59, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x55 { static member: Base[] = [d1, d2] } ->x55 : Symbol(x55, Decl(generatedContextualTyping.ts, 58, 83)) ->member : Symbol(x55.member, Decl(generatedContextualTyping.ts, 59, 11)) +>x55 : Symbol(x55, Decl(generatedContextualTyping.ts, 59, 83)) +>member : Symbol(x55.member, Decl(generatedContextualTyping.ts, 60, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x56 { static member: Array = [d1, d2] } ->x56 : Symbol(x56, Decl(generatedContextualTyping.ts, 59, 46)) ->member : Symbol(x56.member, Decl(generatedContextualTyping.ts, 60, 11)) +>x56 : Symbol(x56, Decl(generatedContextualTyping.ts, 60, 46)) +>member : Symbol(x56.member, Decl(generatedContextualTyping.ts, 61, 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)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x57 { static member: { [n: number]: Base; } = [d1, d2] } ->x57 : Symbol(x57, Decl(generatedContextualTyping.ts, 60, 51)) ->member : Symbol(x57.member, Decl(generatedContextualTyping.ts, 61, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 61, 30)) +>x57 : Symbol(x57, Decl(generatedContextualTyping.ts, 61, 51)) +>member : Symbol(x57.member, Decl(generatedContextualTyping.ts, 62, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 30)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x58 { static member: {n: Base[]; } = { n: [d1, d2] } } ->x58 : Symbol(x58, Decl(generatedContextualTyping.ts, 61, 62)) ->member : Symbol(x58.member, Decl(generatedContextualTyping.ts, 62, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 28)) +>x58 : Symbol(x58, Decl(generatedContextualTyping.ts, 62, 62)) +>member : Symbol(x58.member, Decl(generatedContextualTyping.ts, 63, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 28)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 62, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x59 { static member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x59 : Symbol(x59, Decl(generatedContextualTyping.ts, 62, 61)) ->member : Symbol(x59.member, Decl(generatedContextualTyping.ts, 63, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 63, 28)) +>x59 : Symbol(x59, Decl(generatedContextualTyping.ts, 63, 61)) +>member : Symbol(x59.member, Decl(generatedContextualTyping.ts, 64, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 64, 28)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 47), Decl(generatedContextualTyping.ts, 63, 58)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 63, 47), Decl(generatedContextualTyping.ts, 63, 58)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 47), Decl(generatedContextualTyping.ts, 64, 58)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 47), Decl(generatedContextualTyping.ts, 64, 58)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x60 { static member: Genric = { func: n => { return [d1, d2]; } } } ->x60 : Symbol(x60, Decl(generatedContextualTyping.ts, 63, 86)) ->member : Symbol(x60.member, Decl(generatedContextualTyping.ts, 64, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x60 : Symbol(x60, Decl(generatedContextualTyping.ts, 64, 86)) +>member : Symbol(x60.member, Decl(generatedContextualTyping.ts, 65, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 64, 43)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 64, 49)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 65, 43)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 65, 49)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x61 { private static member: () => Base[] = () => [d1, d2] } ->x61 : Symbol(x61, Decl(generatedContextualTyping.ts, 64, 79)) ->member : Symbol(x61.member, Decl(generatedContextualTyping.ts, 65, 11)) +>x61 : Symbol(x61, Decl(generatedContextualTyping.ts, 65, 79)) +>member : Symbol(x61.member, Decl(generatedContextualTyping.ts, 66, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x62 { private static member: () => Base[] = function() { return [d1, d2] } } ->x62 : Symbol(x62, Decl(generatedContextualTyping.ts, 65, 66)) ->member : Symbol(x62.member, Decl(generatedContextualTyping.ts, 66, 11)) +>x62 : Symbol(x62, Decl(generatedContextualTyping.ts, 66, 66)) +>member : Symbol(x62.member, Decl(generatedContextualTyping.ts, 67, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x63 { private static member: () => Base[] = function named() { return [d1, d2] } } ->x63 : Symbol(x63, Decl(generatedContextualTyping.ts, 66, 82)) ->member : Symbol(x63.member, Decl(generatedContextualTyping.ts, 67, 11)) +>x63 : Symbol(x63, Decl(generatedContextualTyping.ts, 67, 82)) +>member : Symbol(x63.member, Decl(generatedContextualTyping.ts, 68, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 67, 49)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 68, 49)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x64 { private static member: { (): Base[]; } = () => [d1, d2] } ->x64 : Symbol(x64, Decl(generatedContextualTyping.ts, 67, 88)) ->member : Symbol(x64.member, Decl(generatedContextualTyping.ts, 68, 11)) +>x64 : Symbol(x64, Decl(generatedContextualTyping.ts, 68, 88)) +>member : Symbol(x64.member, Decl(generatedContextualTyping.ts, 69, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x65 { private static member: { (): Base[]; } = function() { return [d1, d2] } } ->x65 : Symbol(x65, Decl(generatedContextualTyping.ts, 68, 69)) ->member : Symbol(x65.member, Decl(generatedContextualTyping.ts, 69, 11)) +>x65 : Symbol(x65, Decl(generatedContextualTyping.ts, 69, 69)) +>member : Symbol(x65.member, Decl(generatedContextualTyping.ts, 70, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x66 { private static member: { (): Base[]; } = function named() { return [d1, d2] } } ->x66 : Symbol(x66, Decl(generatedContextualTyping.ts, 69, 85)) ->member : Symbol(x66.member, Decl(generatedContextualTyping.ts, 70, 11)) +>x66 : Symbol(x66, Decl(generatedContextualTyping.ts, 70, 85)) +>member : Symbol(x66.member, Decl(generatedContextualTyping.ts, 71, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 70, 52)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 71, 52)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x67 { private static member: Base[] = [d1, d2] } ->x67 : Symbol(x67, Decl(generatedContextualTyping.ts, 70, 91)) ->member : Symbol(x67.member, Decl(generatedContextualTyping.ts, 71, 11)) +>x67 : Symbol(x67, Decl(generatedContextualTyping.ts, 71, 91)) +>member : Symbol(x67.member, Decl(generatedContextualTyping.ts, 72, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) 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)) +>x68 : Symbol(x68, Decl(generatedContextualTyping.ts, 72, 54)) +>member : Symbol(x68.member, Decl(generatedContextualTyping.ts, 73, 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)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x69 { private static member: { [n: number]: Base; } = [d1, d2] } ->x69 : Symbol(x69, Decl(generatedContextualTyping.ts, 72, 59)) ->member : Symbol(x69.member, Decl(generatedContextualTyping.ts, 73, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 73, 38)) +>x69 : Symbol(x69, Decl(generatedContextualTyping.ts, 73, 59)) +>member : Symbol(x69.member, Decl(generatedContextualTyping.ts, 74, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 38)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x70 { private static member: {n: Base[]; } = { n: [d1, d2] } } ->x70 : Symbol(x70, Decl(generatedContextualTyping.ts, 73, 70)) ->member : Symbol(x70.member, Decl(generatedContextualTyping.ts, 74, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 36)) +>x70 : Symbol(x70, Decl(generatedContextualTyping.ts, 74, 70)) +>member : Symbol(x70.member, Decl(generatedContextualTyping.ts, 75, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 36)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 74, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x71 { private static member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x71 : Symbol(x71, Decl(generatedContextualTyping.ts, 74, 69)) ->member : Symbol(x71.member, Decl(generatedContextualTyping.ts, 75, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 75, 36)) +>x71 : Symbol(x71, Decl(generatedContextualTyping.ts, 75, 69)) +>member : Symbol(x71.member, Decl(generatedContextualTyping.ts, 76, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 76, 36)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 55), Decl(generatedContextualTyping.ts, 75, 66)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 75, 55), Decl(generatedContextualTyping.ts, 75, 66)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 55), Decl(generatedContextualTyping.ts, 76, 66)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 55), Decl(generatedContextualTyping.ts, 76, 66)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x72 { private static member: Genric = { func: n => { return [d1, d2]; } } } ->x72 : Symbol(x72, Decl(generatedContextualTyping.ts, 75, 94)) ->member : Symbol(x72.member, Decl(generatedContextualTyping.ts, 76, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x72 : Symbol(x72, Decl(generatedContextualTyping.ts, 76, 94)) +>member : Symbol(x72.member, Decl(generatedContextualTyping.ts, 77, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 76, 51)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 76, 57)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 77, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 77, 57)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x73 { public static member: () => Base[] = () => [d1, d2] } ->x73 : Symbol(x73, Decl(generatedContextualTyping.ts, 76, 87)) ->member : Symbol(x73.member, Decl(generatedContextualTyping.ts, 77, 11)) +>x73 : Symbol(x73, Decl(generatedContextualTyping.ts, 77, 87)) +>member : Symbol(x73.member, Decl(generatedContextualTyping.ts, 78, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x74 { public static member: () => Base[] = function() { return [d1, d2] } } ->x74 : Symbol(x74, Decl(generatedContextualTyping.ts, 77, 65)) ->member : Symbol(x74.member, Decl(generatedContextualTyping.ts, 78, 11)) +>x74 : Symbol(x74, Decl(generatedContextualTyping.ts, 78, 65)) +>member : Symbol(x74.member, Decl(generatedContextualTyping.ts, 79, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x75 { public static member: () => Base[] = function named() { return [d1, d2] } } ->x75 : Symbol(x75, Decl(generatedContextualTyping.ts, 78, 81)) ->member : Symbol(x75.member, Decl(generatedContextualTyping.ts, 79, 11)) +>x75 : Symbol(x75, Decl(generatedContextualTyping.ts, 79, 81)) +>member : Symbol(x75.member, Decl(generatedContextualTyping.ts, 80, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 79, 48)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 80, 48)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x76 { public static member: { (): Base[]; } = () => [d1, d2] } ->x76 : Symbol(x76, Decl(generatedContextualTyping.ts, 79, 87)) ->member : Symbol(x76.member, Decl(generatedContextualTyping.ts, 80, 11)) +>x76 : Symbol(x76, Decl(generatedContextualTyping.ts, 80, 87)) +>member : Symbol(x76.member, Decl(generatedContextualTyping.ts, 81, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x77 { public static member: { (): Base[]; } = function() { return [d1, d2] } } ->x77 : Symbol(x77, Decl(generatedContextualTyping.ts, 80, 68)) ->member : Symbol(x77.member, Decl(generatedContextualTyping.ts, 81, 11)) +>x77 : Symbol(x77, Decl(generatedContextualTyping.ts, 81, 68)) +>member : Symbol(x77.member, Decl(generatedContextualTyping.ts, 82, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x78 { public static member: { (): Base[]; } = function named() { return [d1, d2] } } ->x78 : Symbol(x78, Decl(generatedContextualTyping.ts, 81, 84)) ->member : Symbol(x78.member, Decl(generatedContextualTyping.ts, 82, 11)) +>x78 : Symbol(x78, Decl(generatedContextualTyping.ts, 82, 84)) +>member : Symbol(x78.member, Decl(generatedContextualTyping.ts, 83, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 82, 51)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 83, 51)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x79 { public static member: Base[] = [d1, d2] } ->x79 : Symbol(x79, Decl(generatedContextualTyping.ts, 82, 90)) ->member : Symbol(x79.member, Decl(generatedContextualTyping.ts, 83, 11)) +>x79 : Symbol(x79, Decl(generatedContextualTyping.ts, 83, 90)) +>member : Symbol(x79.member, Decl(generatedContextualTyping.ts, 84, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) 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)) +>x80 : Symbol(x80, Decl(generatedContextualTyping.ts, 84, 53)) +>member : Symbol(x80.member, Decl(generatedContextualTyping.ts, 85, 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)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x81 { public static member: { [n: number]: Base; } = [d1, d2] } ->x81 : Symbol(x81, Decl(generatedContextualTyping.ts, 84, 58)) ->member : Symbol(x81.member, Decl(generatedContextualTyping.ts, 85, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 85, 37)) +>x81 : Symbol(x81, Decl(generatedContextualTyping.ts, 85, 58)) +>member : Symbol(x81.member, Decl(generatedContextualTyping.ts, 86, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 37)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x82 { public static member: {n: Base[]; } = { n: [d1, d2] } } ->x82 : Symbol(x82, Decl(generatedContextualTyping.ts, 85, 69)) ->member : Symbol(x82.member, Decl(generatedContextualTyping.ts, 86, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 35)) +>x82 : Symbol(x82, Decl(generatedContextualTyping.ts, 86, 69)) +>member : Symbol(x82.member, Decl(generatedContextualTyping.ts, 87, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 35)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 86, 52)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 52)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x83 { public static member: (s: Base[]) => any = n => { var n: Base[]; return null; } } ->x83 : Symbol(x83, Decl(generatedContextualTyping.ts, 86, 68)) ->member : Symbol(x83.member, Decl(generatedContextualTyping.ts, 87, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 87, 35)) +>x83 : Symbol(x83, Decl(generatedContextualTyping.ts, 87, 68)) +>member : Symbol(x83.member, Decl(generatedContextualTyping.ts, 88, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 88, 35)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 54), Decl(generatedContextualTyping.ts, 87, 65)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 87, 54), Decl(generatedContextualTyping.ts, 87, 65)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 54), Decl(generatedContextualTyping.ts, 88, 65)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 54), Decl(generatedContextualTyping.ts, 88, 65)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x84 { public static member: Genric = { func: n => { return [d1, d2]; } } } ->x84 : Symbol(x84, Decl(generatedContextualTyping.ts, 87, 93)) ->member : Symbol(x84.member, Decl(generatedContextualTyping.ts, 88, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x84 : Symbol(x84, Decl(generatedContextualTyping.ts, 88, 93)) +>member : Symbol(x84.member, Decl(generatedContextualTyping.ts, 89, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 88, 50)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 88, 56)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 89, 50)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 89, 56)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x85 { constructor(parm: () => Base[] = () => [d1, d2]) { } } ->x85 : Symbol(x85, Decl(generatedContextualTyping.ts, 88, 86)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 89, 24)) +>x85 : Symbol(x85, Decl(generatedContextualTyping.ts, 89, 86)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 90, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x86 { constructor(parm: () => Base[] = function() { return [d1, d2] }) { } } ->x86 : Symbol(x86, Decl(generatedContextualTyping.ts, 89, 66)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 90, 24)) +>x86 : Symbol(x86, Decl(generatedContextualTyping.ts, 90, 66)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 91, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x87 { constructor(parm: () => Base[] = function named() { return [d1, d2] }) { } } ->x87 : Symbol(x87, Decl(generatedContextualTyping.ts, 90, 82)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 91, 24)) +>x87 : Symbol(x87, Decl(generatedContextualTyping.ts, 91, 82)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 92, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 91, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 92, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x88 { constructor(parm: { (): Base[]; } = () => [d1, d2]) { } } ->x88 : Symbol(x88, Decl(generatedContextualTyping.ts, 91, 88)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 92, 24)) +>x88 : Symbol(x88, Decl(generatedContextualTyping.ts, 92, 88)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 93, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x89 { constructor(parm: { (): Base[]; } = function() { return [d1, d2] }) { } } ->x89 : Symbol(x89, Decl(generatedContextualTyping.ts, 92, 69)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 93, 24)) +>x89 : Symbol(x89, Decl(generatedContextualTyping.ts, 93, 69)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 94, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x90 { constructor(parm: { (): Base[]; } = function named() { return [d1, d2] }) { } } ->x90 : Symbol(x90, Decl(generatedContextualTyping.ts, 93, 85)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 94, 24)) +>x90 : Symbol(x90, Decl(generatedContextualTyping.ts, 94, 85)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 95, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 94, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 95, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x91 { constructor(parm: Base[] = [d1, d2]) { } } ->x91 : Symbol(x91, Decl(generatedContextualTyping.ts, 94, 91)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 95, 24)) +>x91 : Symbol(x91, Decl(generatedContextualTyping.ts, 95, 91)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 96, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x92 { constructor(parm: Array = [d1, d2]) { } } ->x92 : Symbol(x92, Decl(generatedContextualTyping.ts, 95, 54)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 96, 24)) +>x92 : Symbol(x92, Decl(generatedContextualTyping.ts, 96, 54)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 97, 24)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x93 { constructor(parm: { [n: number]: Base; } = [d1, d2]) { } } ->x93 : Symbol(x93, Decl(generatedContextualTyping.ts, 96, 59)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 97, 24)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 97, 33)) +>x93 : Symbol(x93, Decl(generatedContextualTyping.ts, 97, 59)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 98, 24)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 33)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x94 { constructor(parm: {n: Base[]; } = { n: [d1, d2] }) { } } ->x94 : Symbol(x94, Decl(generatedContextualTyping.ts, 97, 70)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 98, 24)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 31)) +>x94 : Symbol(x94, Decl(generatedContextualTyping.ts, 98, 70)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 99, 24)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 31)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 98, 48)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 48)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x95 { constructor(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } } ->x95 : Symbol(x95, Decl(generatedContextualTyping.ts, 98, 69)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 99, 24)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 99, 31)) +>x95 : Symbol(x95, Decl(generatedContextualTyping.ts, 99, 69)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 100, 24)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 100, 31)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 50), Decl(generatedContextualTyping.ts, 99, 61)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 99, 50), Decl(generatedContextualTyping.ts, 99, 61)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 50), Decl(generatedContextualTyping.ts, 100, 61)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 50), Decl(generatedContextualTyping.ts, 100, 61)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x96 { constructor(parm: Genric = { func: n => { return [d1, d2]; } }) { } } ->x96 : Symbol(x96, Decl(generatedContextualTyping.ts, 99, 94)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 100, 24)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x96 : Symbol(x96, Decl(generatedContextualTyping.ts, 100, 94)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 101, 24)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 100, 46)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 100, 52)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 101, 46)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 101, 52)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x97 { constructor(public parm: () => Base[] = () => [d1, d2]) { } } ->x97 : Symbol(x97, Decl(generatedContextualTyping.ts, 100, 87)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 101, 24)) +>x97 : Symbol(x97, Decl(generatedContextualTyping.ts, 101, 87)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 102, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x98 { constructor(public parm: () => Base[] = function() { return [d1, d2] }) { } } ->x98 : Symbol(x98, Decl(generatedContextualTyping.ts, 101, 73)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 102, 24)) +>x98 : Symbol(x98, Decl(generatedContextualTyping.ts, 102, 73)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 103, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x99 { constructor(public parm: () => Base[] = function named() { return [d1, d2] }) { } } ->x99 : Symbol(x99, Decl(generatedContextualTyping.ts, 102, 89)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 103, 24)) +>x99 : Symbol(x99, Decl(generatedContextualTyping.ts, 103, 89)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 104, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 103, 51)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 104, 51)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x100 { constructor(public parm: { (): Base[]; } = () => [d1, d2]) { } } ->x100 : Symbol(x100, Decl(generatedContextualTyping.ts, 103, 95)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 104, 25)) +>x100 : Symbol(x100, Decl(generatedContextualTyping.ts, 104, 95)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 105, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x101 { constructor(public parm: { (): Base[]; } = function() { return [d1, d2] }) { } } ->x101 : Symbol(x101, Decl(generatedContextualTyping.ts, 104, 77)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 105, 25)) +>x101 : Symbol(x101, Decl(generatedContextualTyping.ts, 105, 77)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 106, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x102 { constructor(public parm: { (): Base[]; } = function named() { return [d1, d2] }) { } } ->x102 : Symbol(x102, Decl(generatedContextualTyping.ts, 105, 93)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 106, 25)) +>x102 : Symbol(x102, Decl(generatedContextualTyping.ts, 106, 93)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 107, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 106, 55)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 107, 55)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x103 { constructor(public parm: Base[] = [d1, d2]) { } } ->x103 : Symbol(x103, Decl(generatedContextualTyping.ts, 106, 99)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 107, 25)) +>x103 : Symbol(x103, Decl(generatedContextualTyping.ts, 107, 99)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 108, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x104 { constructor(public parm: Array = [d1, d2]) { } } ->x104 : Symbol(x104, Decl(generatedContextualTyping.ts, 107, 62)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 108, 25)) +>x104 : Symbol(x104, Decl(generatedContextualTyping.ts, 108, 62)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 109, 25)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x105 { constructor(public parm: { [n: number]: Base; } = [d1, d2]) { } } ->x105 : Symbol(x105, Decl(generatedContextualTyping.ts, 108, 67)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 109, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 109, 41)) +>x105 : Symbol(x105, Decl(generatedContextualTyping.ts, 109, 67)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 110, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 41)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x106 { constructor(public parm: {n: Base[]; } = { n: [d1, d2] }) { } } ->x106 : Symbol(x106, Decl(generatedContextualTyping.ts, 109, 78)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 110, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 39)) +>x106 : Symbol(x106, Decl(generatedContextualTyping.ts, 110, 78)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 111, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 39)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 110, 56)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 56)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x107 { constructor(public parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } } ->x107 : Symbol(x107, Decl(generatedContextualTyping.ts, 110, 77)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 111, 25)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 111, 39)) +>x107 : Symbol(x107, Decl(generatedContextualTyping.ts, 111, 77)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 112, 25)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 112, 39)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 58), Decl(generatedContextualTyping.ts, 111, 69)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 111, 58), Decl(generatedContextualTyping.ts, 111, 69)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 58), Decl(generatedContextualTyping.ts, 112, 69)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 58), Decl(generatedContextualTyping.ts, 112, 69)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x108 { constructor(public parm: Genric = { func: n => { return [d1, d2]; } }) { } } ->x108 : Symbol(x108, Decl(generatedContextualTyping.ts, 111, 102)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 112, 25)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x108 : Symbol(x108, Decl(generatedContextualTyping.ts, 112, 102)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 113, 25)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 112, 54)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 112, 60)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 113, 54)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 113, 60)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x109 { constructor(private parm: () => Base[] = () => [d1, d2]) { } } ->x109 : Symbol(x109, Decl(generatedContextualTyping.ts, 112, 95)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 113, 25)) +>x109 : Symbol(x109, Decl(generatedContextualTyping.ts, 113, 95)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 114, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x110 { constructor(private parm: () => Base[] = function() { return [d1, d2] }) { } } ->x110 : Symbol(x110, Decl(generatedContextualTyping.ts, 113, 75)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 114, 25)) +>x110 : Symbol(x110, Decl(generatedContextualTyping.ts, 114, 75)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 115, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x111 { constructor(private parm: () => Base[] = function named() { return [d1, d2] }) { } } ->x111 : Symbol(x111, Decl(generatedContextualTyping.ts, 114, 91)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 115, 25)) +>x111 : Symbol(x111, Decl(generatedContextualTyping.ts, 115, 91)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 116, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 115, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 116, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x112 { constructor(private parm: { (): Base[]; } = () => [d1, d2]) { } } ->x112 : Symbol(x112, Decl(generatedContextualTyping.ts, 115, 97)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 116, 25)) +>x112 : Symbol(x112, Decl(generatedContextualTyping.ts, 116, 97)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 117, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x113 { constructor(private parm: { (): Base[]; } = function() { return [d1, d2] }) { } } ->x113 : Symbol(x113, Decl(generatedContextualTyping.ts, 116, 78)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 117, 25)) +>x113 : Symbol(x113, Decl(generatedContextualTyping.ts, 117, 78)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 118, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x114 { constructor(private parm: { (): Base[]; } = function named() { return [d1, d2] }) { } } ->x114 : Symbol(x114, Decl(generatedContextualTyping.ts, 117, 94)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 118, 25)) +>x114 : Symbol(x114, Decl(generatedContextualTyping.ts, 118, 94)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 119, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 118, 56)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 119, 56)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x115 { constructor(private parm: Base[] = [d1, d2]) { } } ->x115 : Symbol(x115, Decl(generatedContextualTyping.ts, 118, 100)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 119, 25)) +>x115 : Symbol(x115, Decl(generatedContextualTyping.ts, 119, 100)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 120, 25)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x116 { constructor(private parm: Array = [d1, d2]) { } } ->x116 : Symbol(x116, Decl(generatedContextualTyping.ts, 119, 63)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 120, 25)) +>x116 : Symbol(x116, Decl(generatedContextualTyping.ts, 120, 63)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 121, 25)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x117 { constructor(private parm: { [n: number]: Base; } = [d1, d2]) { } } ->x117 : Symbol(x117, Decl(generatedContextualTyping.ts, 120, 68)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 121, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 121, 42)) +>x117 : Symbol(x117, Decl(generatedContextualTyping.ts, 121, 68)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 122, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x118 { constructor(private parm: {n: Base[]; } = { n: [d1, d2] }) { } } ->x118 : Symbol(x118, Decl(generatedContextualTyping.ts, 121, 79)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 122, 25)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 40)) +>x118 : Symbol(x118, Decl(generatedContextualTyping.ts, 122, 79)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 123, 25)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 40)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 122, 57)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 57)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) class x119 { constructor(private parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } } ->x119 : Symbol(x119, Decl(generatedContextualTyping.ts, 122, 78)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 123, 25)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 123, 40)) +>x119 : Symbol(x119, Decl(generatedContextualTyping.ts, 123, 78)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 124, 25)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 124, 40)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 59), Decl(generatedContextualTyping.ts, 123, 70)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 123, 59), Decl(generatedContextualTyping.ts, 123, 70)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 59), Decl(generatedContextualTyping.ts, 124, 70)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 59), Decl(generatedContextualTyping.ts, 124, 70)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) class x120 { constructor(private parm: Genric = { func: n => { return [d1, d2]; } }) { } } ->x120 : Symbol(x120, Decl(generatedContextualTyping.ts, 123, 103)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 124, 25)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x120 : Symbol(x120, Decl(generatedContextualTyping.ts, 124, 103)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 125, 25)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 124, 55)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 124, 61)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 125, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 125, 61)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x121(parm: () => Base[] = () => [d1, d2]) { } ->x121 : Symbol(x121, Decl(generatedContextualTyping.ts, 124, 96)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 125, 14)) +>x121 : Symbol(x121, Decl(generatedContextualTyping.ts, 125, 96)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 126, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x122(parm: () => Base[] = function() { return [d1, d2] }) { } ->x122 : Symbol(x122, Decl(generatedContextualTyping.ts, 125, 54)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 126, 14)) +>x122 : Symbol(x122, Decl(generatedContextualTyping.ts, 126, 54)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 127, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x123(parm: () => Base[] = function named() { return [d1, d2] }) { } ->x123 : Symbol(x123, Decl(generatedContextualTyping.ts, 126, 70)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 127, 14)) +>x123 : Symbol(x123, Decl(generatedContextualTyping.ts, 127, 70)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 128, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 127, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 128, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x124(parm: { (): Base[]; } = () => [d1, d2]) { } ->x124 : Symbol(x124, Decl(generatedContextualTyping.ts, 127, 76)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 128, 14)) +>x124 : Symbol(x124, Decl(generatedContextualTyping.ts, 128, 76)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 129, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x125(parm: { (): Base[]; } = function() { return [d1, d2] }) { } ->x125 : Symbol(x125, Decl(generatedContextualTyping.ts, 128, 57)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 129, 14)) +>x125 : Symbol(x125, Decl(generatedContextualTyping.ts, 129, 57)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 130, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x126(parm: { (): Base[]; } = function named() { return [d1, d2] }) { } ->x126 : Symbol(x126, Decl(generatedContextualTyping.ts, 129, 73)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 130, 14)) +>x126 : Symbol(x126, Decl(generatedContextualTyping.ts, 130, 73)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 131, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 130, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 131, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x127(parm: Base[] = [d1, d2]) { } ->x127 : Symbol(x127, Decl(generatedContextualTyping.ts, 130, 79)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 131, 14)) +>x127 : Symbol(x127, Decl(generatedContextualTyping.ts, 131, 79)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 132, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x128(parm: Array = [d1, d2]) { } ->x128 : Symbol(x128, Decl(generatedContextualTyping.ts, 131, 42)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 132, 14)) +>x128 : Symbol(x128, Decl(generatedContextualTyping.ts, 132, 42)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 133, 14)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x129(parm: { [n: number]: Base; } = [d1, d2]) { } ->x129 : Symbol(x129, Decl(generatedContextualTyping.ts, 132, 47)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 133, 14)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 133, 23)) +>x129 : Symbol(x129, Decl(generatedContextualTyping.ts, 133, 47)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 134, 14)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 23)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x130(parm: {n: Base[]; } = { n: [d1, d2] }) { } ->x130 : Symbol(x130, Decl(generatedContextualTyping.ts, 133, 58)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 134, 14)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 21)) +>x130 : Symbol(x130, Decl(generatedContextualTyping.ts, 134, 58)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 135, 14)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 21)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 134, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x131(parm: (s: Base[]) => any = n => { var n: Base[]; return null; }) { } ->x131 : Symbol(x131, Decl(generatedContextualTyping.ts, 134, 57)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 135, 14)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 135, 21)) +>x131 : Symbol(x131, Decl(generatedContextualTyping.ts, 135, 57)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 136, 14)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 136, 21)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 40), Decl(generatedContextualTyping.ts, 135, 51)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 135, 40), Decl(generatedContextualTyping.ts, 135, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 40), Decl(generatedContextualTyping.ts, 136, 51)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 40), Decl(generatedContextualTyping.ts, 136, 51)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) function x132(parm: Genric = { func: n => { return [d1, d2]; } }) { } ->x132 : Symbol(x132, Decl(generatedContextualTyping.ts, 135, 82)) ->parm : Symbol(parm, Decl(generatedContextualTyping.ts, 136, 14)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x132 : Symbol(x132, Decl(generatedContextualTyping.ts, 136, 82)) +>parm : Symbol(parm, Decl(generatedContextualTyping.ts, 137, 14)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 136, 36)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 136, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 137, 36)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 137, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x133(): () => Base[] { return () => [d1, d2]; } ->x133 : Symbol(x133, Decl(generatedContextualTyping.ts, 136, 75)) +>x133 : Symbol(x133, Decl(generatedContextualTyping.ts, 137, 75)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x134(): () => Base[] { return function() { return [d1, d2] }; } ->x134 : Symbol(x134, Decl(generatedContextualTyping.ts, 137, 56)) +>x134 : Symbol(x134, Decl(generatedContextualTyping.ts, 138, 56)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x135(): () => Base[] { return function named() { return [d1, d2] }; } ->x135 : Symbol(x135, Decl(generatedContextualTyping.ts, 138, 72)) +>x135 : Symbol(x135, Decl(generatedContextualTyping.ts, 139, 72)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 139, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 140, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x136(): { (): Base[]; } { return () => [d1, d2]; } ->x136 : Symbol(x136, Decl(generatedContextualTyping.ts, 139, 78)) +>x136 : Symbol(x136, Decl(generatedContextualTyping.ts, 140, 78)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x137(): { (): Base[]; } { return function() { return [d1, d2] }; } ->x137 : Symbol(x137, Decl(generatedContextualTyping.ts, 140, 59)) +>x137 : Symbol(x137, Decl(generatedContextualTyping.ts, 141, 59)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x138(): { (): Base[]; } { return function named() { return [d1, d2] }; } ->x138 : Symbol(x138, Decl(generatedContextualTyping.ts, 141, 75)) +>x138 : Symbol(x138, Decl(generatedContextualTyping.ts, 142, 75)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 142, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 143, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x139(): Base[] { return [d1, d2]; } ->x139 : Symbol(x139, Decl(generatedContextualTyping.ts, 142, 81)) +>x139 : Symbol(x139, Decl(generatedContextualTyping.ts, 143, 81)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x140(): Array { return [d1, d2]; } ->x140 : Symbol(x140, Decl(generatedContextualTyping.ts, 143, 44)) +>x140 : Symbol(x140, Decl(generatedContextualTyping.ts, 144, 44)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x141(): { [n: number]: Base; } { return [d1, d2]; } ->x141 : Symbol(x141, Decl(generatedContextualTyping.ts, 144, 49)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 145, 20)) +>x141 : Symbol(x141, Decl(generatedContextualTyping.ts, 145, 49)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x142(): {n: Base[]; } { return { n: [d1, d2] }; } ->x142 : Symbol(x142, Decl(generatedContextualTyping.ts, 145, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 18)) +>x142 : Symbol(x142, Decl(generatedContextualTyping.ts, 146, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 146, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x143(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; } ->x143 : Symbol(x143, Decl(generatedContextualTyping.ts, 146, 59)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 147, 18)) +>x143 : Symbol(x143, Decl(generatedContextualTyping.ts, 147, 59)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 148, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 44), Decl(generatedContextualTyping.ts, 147, 55)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 147, 44), Decl(generatedContextualTyping.ts, 147, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 44), Decl(generatedContextualTyping.ts, 148, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 44), Decl(generatedContextualTyping.ts, 148, 55)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) function x144(): Genric { return { func: n => { return [d1, d2]; } }; } ->x144 : Symbol(x144, Decl(generatedContextualTyping.ts, 147, 84)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x144 : Symbol(x144, Decl(generatedContextualTyping.ts, 148, 84)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 148, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 148, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 149, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 149, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x145(): () => Base[] { return () => [d1, d2]; return () => [d1, d2]; } ->x145 : Symbol(x145, Decl(generatedContextualTyping.ts, 148, 77)) +>x145 : Symbol(x145, Decl(generatedContextualTyping.ts, 149, 77)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x146(): () => Base[] { return function() { return [d1, d2] }; return function() { return [d1, d2] }; } ->x146 : Symbol(x146, Decl(generatedContextualTyping.ts, 149, 79)) +>x146 : Symbol(x146, Decl(generatedContextualTyping.ts, 150, 79)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x147(): () => Base[] { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; } ->x147 : Symbol(x147, Decl(generatedContextualTyping.ts, 150, 111)) +>x147 : Symbol(x147, Decl(generatedContextualTyping.ts, 151, 111)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 151, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 151, 83)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 152, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 152, 83)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x148(): { (): Base[]; } { return () => [d1, d2]; return () => [d1, d2]; } ->x148 : Symbol(x148, Decl(generatedContextualTyping.ts, 151, 123)) +>x148 : Symbol(x148, Decl(generatedContextualTyping.ts, 152, 123)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x149(): { (): Base[]; } { return function() { return [d1, d2] }; return function() { return [d1, d2] }; } ->x149 : Symbol(x149, Decl(generatedContextualTyping.ts, 152, 82)) +>x149 : Symbol(x149, Decl(generatedContextualTyping.ts, 153, 82)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x150(): { (): Base[]; } { return function named() { return [d1, d2] }; return function named() { return [d1, d2] }; } ->x150 : Symbol(x150, Decl(generatedContextualTyping.ts, 153, 114)) +>x150 : Symbol(x150, Decl(generatedContextualTyping.ts, 154, 114)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 154, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 154, 86)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 155, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 155, 86)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x151(): Base[] { return [d1, d2]; return [d1, d2]; } ->x151 : Symbol(x151, Decl(generatedContextualTyping.ts, 154, 126)) +>x151 : Symbol(x151, Decl(generatedContextualTyping.ts, 155, 126)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x152(): Array { return [d1, d2]; return [d1, d2]; } ->x152 : Symbol(x152, Decl(generatedContextualTyping.ts, 155, 61)) +>x152 : Symbol(x152, Decl(generatedContextualTyping.ts, 156, 61)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x153(): { [n: number]: Base; } { return [d1, d2]; return [d1, d2]; } ->x153 : Symbol(x153, Decl(generatedContextualTyping.ts, 156, 66)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 157, 20)) +>x153 : Symbol(x153, Decl(generatedContextualTyping.ts, 157, 66)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x154(): {n: Base[]; } { return { n: [d1, d2] }; return { n: [d1, d2] }; } ->x154 : Symbol(x154, Decl(generatedContextualTyping.ts, 157, 77)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 18)) +>x154 : Symbol(x154, Decl(generatedContextualTyping.ts, 158, 77)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 158, 66)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 66)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x155(): (s: Base[]) => any { return n => { var n: Base[]; return null; }; return n => { var n: Base[]; return null; }; } ->x155 : Symbol(x155, Decl(generatedContextualTyping.ts, 158, 83)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 159, 18)) +>x155 : Symbol(x155, Decl(generatedContextualTyping.ts, 159, 83)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 160, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 44), Decl(generatedContextualTyping.ts, 159, 55)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 44), Decl(generatedContextualTyping.ts, 159, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 44), Decl(generatedContextualTyping.ts, 160, 55)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 44), Decl(generatedContextualTyping.ts, 160, 55)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 89), Decl(generatedContextualTyping.ts, 159, 100)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 159, 89), Decl(generatedContextualTyping.ts, 159, 100)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 89), Decl(generatedContextualTyping.ts, 160, 100)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 89), Decl(generatedContextualTyping.ts, 160, 100)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) function x156(): Genric { return { func: n => { return [d1, d2]; } }; return { func: n => { return [d1, d2]; } }; } ->x156 : Symbol(x156, Decl(generatedContextualTyping.ts, 159, 129)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 160, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 160, 84)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 160, 90)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x156 : Symbol(x156, Decl(generatedContextualTyping.ts, 160, 129)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 161, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 161, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 161, 84)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 161, 90)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x157: () => () => Base[] = () => { return () => [d1, d2]; }; ->x157 : Symbol(x157, Decl(generatedContextualTyping.ts, 161, 3)) +>x157 : Symbol(x157, Decl(generatedContextualTyping.ts, 162, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x158: () => () => Base[] = () => { return function() { return [d1, d2] }; }; ->x158 : Symbol(x158, Decl(generatedContextualTyping.ts, 162, 3)) +>x158 : Symbol(x158, Decl(generatedContextualTyping.ts, 163, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x159: () => () => Base[] = () => { return function named() { return [d1, d2] }; }; ->x159 : Symbol(x159, Decl(generatedContextualTyping.ts, 163, 3)) +>x159 : Symbol(x159, Decl(generatedContextualTyping.ts, 164, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 163, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 164, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x160: () => { (): Base[]; } = () => { return () => [d1, d2]; }; ->x160 : Symbol(x160, Decl(generatedContextualTyping.ts, 164, 3)) +>x160 : Symbol(x160, Decl(generatedContextualTyping.ts, 165, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x161: () => { (): Base[]; } = () => { return function() { return [d1, d2] }; }; ->x161 : Symbol(x161, Decl(generatedContextualTyping.ts, 165, 3)) +>x161 : Symbol(x161, Decl(generatedContextualTyping.ts, 166, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x162: () => { (): Base[]; } = () => { return function named() { return [d1, d2] }; }; ->x162 : Symbol(x162, Decl(generatedContextualTyping.ts, 166, 3)) +>x162 : Symbol(x162, Decl(generatedContextualTyping.ts, 167, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 166, 48)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 167, 48)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x163: () => Base[] = () => { return [d1, d2]; }; ->x163 : Symbol(x163, Decl(generatedContextualTyping.ts, 167, 3)) +>x163 : Symbol(x163, Decl(generatedContextualTyping.ts, 168, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x164: () => Array = () => { return [d1, d2]; }; ->x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 168, 3)) +>x164 : Symbol(x164, Decl(generatedContextualTyping.ts, 169, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x165: () => { [n: number]: Base; } = () => { return [d1, d2]; }; ->x165 : Symbol(x165, Decl(generatedContextualTyping.ts, 169, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 169, 19)) +>x165 : Symbol(x165, Decl(generatedContextualTyping.ts, 170, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 19)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x166: () => {n: Base[]; } = () => { return { n: [d1, d2] }; }; ->x166 : Symbol(x166, Decl(generatedContextualTyping.ts, 170, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 17)) +>x166 : Symbol(x166, Decl(generatedContextualTyping.ts, 171, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 170, 49)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 49)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x167: () => (s: Base[]) => any = () => { return n => { var n: Base[]; return null; }; }; ->x167 : Symbol(x167, Decl(generatedContextualTyping.ts, 171, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 171, 17)) +>x167 : Symbol(x167, Decl(generatedContextualTyping.ts, 172, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 172, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 51), Decl(generatedContextualTyping.ts, 171, 62)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 171, 51), Decl(generatedContextualTyping.ts, 171, 62)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 51), Decl(generatedContextualTyping.ts, 172, 62)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 51), Decl(generatedContextualTyping.ts, 172, 62)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x168: () => Genric = () => { return { func: n => { return [d1, d2]; } }; }; ->x168 : Symbol(x168, Decl(generatedContextualTyping.ts, 172, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x168 : Symbol(x168, Decl(generatedContextualTyping.ts, 173, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 172, 47)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 172, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 173, 47)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 173, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x169: () => () => Base[] = function() { return () => [d1, d2]; }; ->x169 : Symbol(x169, Decl(generatedContextualTyping.ts, 173, 3)) +>x169 : Symbol(x169, Decl(generatedContextualTyping.ts, 174, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x170: () => () => Base[] = function() { return function() { return [d1, d2] }; }; ->x170 : Symbol(x170, Decl(generatedContextualTyping.ts, 174, 3)) +>x170 : Symbol(x170, Decl(generatedContextualTyping.ts, 175, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x171: () => () => Base[] = function() { return function named() { return [d1, d2] }; }; ->x171 : Symbol(x171, Decl(generatedContextualTyping.ts, 175, 3)) +>x171 : Symbol(x171, Decl(generatedContextualTyping.ts, 176, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 175, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 176, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x172: () => { (): Base[]; } = function() { return () => [d1, d2]; }; ->x172 : Symbol(x172, Decl(generatedContextualTyping.ts, 176, 3)) +>x172 : Symbol(x172, Decl(generatedContextualTyping.ts, 177, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x173: () => { (): Base[]; } = function() { return function() { return [d1, d2] }; }; ->x173 : Symbol(x173, Decl(generatedContextualTyping.ts, 177, 3)) +>x173 : Symbol(x173, Decl(generatedContextualTyping.ts, 178, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x174: () => { (): Base[]; } = function() { return function named() { return [d1, d2] }; }; ->x174 : Symbol(x174, Decl(generatedContextualTyping.ts, 178, 3)) +>x174 : Symbol(x174, Decl(generatedContextualTyping.ts, 179, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 178, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 179, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x175: () => Base[] = function() { return [d1, d2]; }; ->x175 : Symbol(x175, Decl(generatedContextualTyping.ts, 179, 3)) +>x175 : Symbol(x175, Decl(generatedContextualTyping.ts, 180, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x176: () => Array = function() { return [d1, d2]; }; ->x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 180, 3)) +>x176 : Symbol(x176, Decl(generatedContextualTyping.ts, 181, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x177: () => { [n: number]: Base; } = function() { return [d1, d2]; }; ->x177 : Symbol(x177, Decl(generatedContextualTyping.ts, 181, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 181, 19)) +>x177 : Symbol(x177, Decl(generatedContextualTyping.ts, 182, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 19)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x178: () => {n: Base[]; } = function() { return { n: [d1, d2] }; }; ->x178 : Symbol(x178, Decl(generatedContextualTyping.ts, 182, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 17)) +>x178 : Symbol(x178, Decl(generatedContextualTyping.ts, 183, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 182, 54)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 54)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x179: () => (s: Base[]) => any = function() { return n => { var n: Base[]; return null; }; }; ->x179 : Symbol(x179, Decl(generatedContextualTyping.ts, 183, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 183, 17)) +>x179 : Symbol(x179, Decl(generatedContextualTyping.ts, 184, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 184, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 56), Decl(generatedContextualTyping.ts, 183, 67)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 183, 56), Decl(generatedContextualTyping.ts, 183, 67)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 56), Decl(generatedContextualTyping.ts, 184, 67)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 56), Decl(generatedContextualTyping.ts, 184, 67)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x180: () => Genric = function() { return { func: n => { return [d1, d2]; } }; }; ->x180 : Symbol(x180, Decl(generatedContextualTyping.ts, 184, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x180 : Symbol(x180, Decl(generatedContextualTyping.ts, 185, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 184, 52)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 184, 58)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 185, 52)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 185, 58)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x181 { var t: () => Base[] = () => [d1, d2]; } ->x181 : Symbol(x181, Decl(generatedContextualTyping.ts, 184, 90)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 185, 17)) +>x181 : Symbol(x181, Decl(generatedContextualTyping.ts, 185, 90)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 186, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x182 { var t: () => Base[] = function() { return [d1, d2] }; } ->x182 : Symbol(x182, Decl(generatedContextualTyping.ts, 185, 53)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 186, 17)) +>x182 : Symbol(x182, Decl(generatedContextualTyping.ts, 186, 53)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 187, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x183 { var t: () => Base[] = function named() { return [d1, d2] }; } ->x183 : Symbol(x183, Decl(generatedContextualTyping.ts, 186, 69)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 187, 17)) +>x183 : Symbol(x183, Decl(generatedContextualTyping.ts, 187, 69)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 188, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 187, 35)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 188, 35)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x184 { var t: { (): Base[]; } = () => [d1, d2]; } ->x184 : Symbol(x184, Decl(generatedContextualTyping.ts, 187, 75)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 188, 17)) +>x184 : Symbol(x184, Decl(generatedContextualTyping.ts, 188, 75)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 189, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x185 { var t: { (): Base[]; } = function() { return [d1, d2] }; } ->x185 : Symbol(x185, Decl(generatedContextualTyping.ts, 188, 56)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 189, 17)) +>x185 : Symbol(x185, Decl(generatedContextualTyping.ts, 189, 56)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 190, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x186 { var t: { (): Base[]; } = function named() { return [d1, d2] }; } ->x186 : Symbol(x186, Decl(generatedContextualTyping.ts, 189, 72)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 190, 17)) +>x186 : Symbol(x186, Decl(generatedContextualTyping.ts, 190, 72)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 191, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 190, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 191, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x187 { var t: Base[] = [d1, d2]; } ->x187 : Symbol(x187, Decl(generatedContextualTyping.ts, 190, 78)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 191, 17)) +>x187 : Symbol(x187, Decl(generatedContextualTyping.ts, 191, 78)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 192, 17)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x188 { var t: Array = [d1, d2]; } ->x188 : Symbol(x188, Decl(generatedContextualTyping.ts, 191, 41)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 192, 17)) +>x188 : Symbol(x188, Decl(generatedContextualTyping.ts, 192, 41)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 193, 17)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x189 { var t: { [n: number]: Base; } = [d1, d2]; } ->x189 : Symbol(x189, Decl(generatedContextualTyping.ts, 192, 46)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 193, 17)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 193, 24)) +>x189 : Symbol(x189, Decl(generatedContextualTyping.ts, 193, 46)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 194, 17)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x190 { var t: {n: Base[]; } = { n: [d1, d2] }; } ->x190 : Symbol(x190, Decl(generatedContextualTyping.ts, 193, 57)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 194, 17)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 22)) +>x190 : Symbol(x190, Decl(generatedContextualTyping.ts, 194, 57)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 195, 17)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 22)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 194, 39)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 39)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x191 { var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; } ->x191 : Symbol(x191, Decl(generatedContextualTyping.ts, 194, 56)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 195, 17)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 195, 22)) +>x191 : Symbol(x191, Decl(generatedContextualTyping.ts, 195, 56)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 196, 17)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 196, 22)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 41), Decl(generatedContextualTyping.ts, 195, 52)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 195, 41), Decl(generatedContextualTyping.ts, 195, 52)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 41), Decl(generatedContextualTyping.ts, 196, 52)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 41), Decl(generatedContextualTyping.ts, 196, 52)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) module x192 { var t: Genric = { func: n => { return [d1, d2]; } }; } ->x192 : Symbol(x192, Decl(generatedContextualTyping.ts, 195, 81)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 196, 17)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x192 : Symbol(x192, Decl(generatedContextualTyping.ts, 196, 81)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 197, 17)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 196, 37)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 196, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 197, 37)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 197, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x193 { export var t: () => Base[] = () => [d1, d2]; } ->x193 : Symbol(x193, Decl(generatedContextualTyping.ts, 196, 74)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 197, 24)) +>x193 : Symbol(x193, Decl(generatedContextualTyping.ts, 197, 74)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 198, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x194 { export var t: () => Base[] = function() { return [d1, d2] }; } ->x194 : Symbol(x194, Decl(generatedContextualTyping.ts, 197, 60)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 198, 24)) +>x194 : Symbol(x194, Decl(generatedContextualTyping.ts, 198, 60)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 199, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x195 { export var t: () => Base[] = function named() { return [d1, d2] }; } ->x195 : Symbol(x195, Decl(generatedContextualTyping.ts, 198, 76)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 199, 24)) +>x195 : Symbol(x195, Decl(generatedContextualTyping.ts, 199, 76)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 200, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 199, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 200, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x196 { export var t: { (): Base[]; } = () => [d1, d2]; } ->x196 : Symbol(x196, Decl(generatedContextualTyping.ts, 199, 82)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 200, 24)) +>x196 : Symbol(x196, Decl(generatedContextualTyping.ts, 200, 82)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 201, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x197 { export var t: { (): Base[]; } = function() { return [d1, d2] }; } ->x197 : Symbol(x197, Decl(generatedContextualTyping.ts, 200, 63)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 201, 24)) +>x197 : Symbol(x197, Decl(generatedContextualTyping.ts, 201, 63)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 202, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x198 { export var t: { (): Base[]; } = function named() { return [d1, d2] }; } ->x198 : Symbol(x198, Decl(generatedContextualTyping.ts, 201, 79)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 202, 24)) +>x198 : Symbol(x198, Decl(generatedContextualTyping.ts, 202, 79)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 203, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 202, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 203, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x199 { export var t: Base[] = [d1, d2]; } ->x199 : Symbol(x199, Decl(generatedContextualTyping.ts, 202, 85)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 203, 24)) +>x199 : Symbol(x199, Decl(generatedContextualTyping.ts, 203, 85)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 204, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x200 { export var t: Array = [d1, d2]; } ->x200 : Symbol(x200, Decl(generatedContextualTyping.ts, 203, 48)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 204, 24)) +>x200 : Symbol(x200, Decl(generatedContextualTyping.ts, 204, 48)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 205, 24)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x201 { export var t: { [n: number]: Base; } = [d1, d2]; } ->x201 : Symbol(x201, Decl(generatedContextualTyping.ts, 204, 53)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 205, 24)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 205, 31)) +>x201 : Symbol(x201, Decl(generatedContextualTyping.ts, 205, 53)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 206, 24)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 31)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x202 { export var t: {n: Base[]; } = { n: [d1, d2] }; } ->x202 : Symbol(x202, Decl(generatedContextualTyping.ts, 205, 64)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 206, 24)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 29)) +>x202 : Symbol(x202, Decl(generatedContextualTyping.ts, 206, 64)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 207, 24)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 29)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 206, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) module x203 { export var t: (s: Base[]) => any = n => { var n: Base[]; return null; }; } ->x203 : Symbol(x203, Decl(generatedContextualTyping.ts, 206, 63)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 207, 24)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 207, 29)) +>x203 : Symbol(x203, Decl(generatedContextualTyping.ts, 207, 63)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 208, 24)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 208, 29)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 48), Decl(generatedContextualTyping.ts, 207, 59)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 207, 48), Decl(generatedContextualTyping.ts, 207, 59)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 48), Decl(generatedContextualTyping.ts, 208, 59)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 48), Decl(generatedContextualTyping.ts, 208, 59)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) module x204 { export var t: Genric = { func: n => { return [d1, d2]; } }; } ->x204 : Symbol(x204, Decl(generatedContextualTyping.ts, 207, 88)) ->t : Symbol(t, Decl(generatedContextualTyping.ts, 208, 24)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x204 : Symbol(x204, Decl(generatedContextualTyping.ts, 208, 88)) +>t : Symbol(t, Decl(generatedContextualTyping.ts, 209, 24)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 208, 44)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 208, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 209, 44)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 209, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x206 = <() => Base[]>function() { return [d1, d2] }; ->x206 : Symbol(x206, Decl(generatedContextualTyping.ts, 209, 3)) +>x206 : Symbol(x206, Decl(generatedContextualTyping.ts, 210, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x207 = <() => Base[]>function named() { return [d1, d2] }; ->x207 : Symbol(x207, Decl(generatedContextualTyping.ts, 210, 3)) +>x207 : Symbol(x207, Decl(generatedContextualTyping.ts, 211, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 210, 25)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 211, 25)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x209 = <{ (): Base[]; }>function() { return [d1, d2] }; ->x209 : Symbol(x209, Decl(generatedContextualTyping.ts, 211, 3)) +>x209 : Symbol(x209, Decl(generatedContextualTyping.ts, 212, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x210 = <{ (): Base[]; }>function named() { return [d1, d2] }; ->x210 : Symbol(x210, Decl(generatedContextualTyping.ts, 212, 3)) +>x210 : Symbol(x210, Decl(generatedContextualTyping.ts, 213, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 212, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 213, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x211 = [d1, d2]; ->x211 : Symbol(x211, Decl(generatedContextualTyping.ts, 213, 3)) +>x211 : Symbol(x211, Decl(generatedContextualTyping.ts, 214, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x212 = >[d1, d2]; ->x212 : Symbol(x212, Decl(generatedContextualTyping.ts, 214, 3)) +>x212 : Symbol(x212, Decl(generatedContextualTyping.ts, 215, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x213 = <{ [n: number]: Base; }>[d1, d2]; ->x213 : Symbol(x213, Decl(generatedContextualTyping.ts, 215, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 215, 15)) +>x213 : Symbol(x213, Decl(generatedContextualTyping.ts, 216, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 15)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x214 = <{n: Base[]; } >{ n: [d1, d2] }; ->x214 : Symbol(x214, Decl(generatedContextualTyping.ts, 216, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 13)) +>x214 : Symbol(x214, Decl(generatedContextualTyping.ts, 217, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 216, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x216 = >{ func: n => { return [d1, d2]; } }; ->x216 : Symbol(x216, Decl(generatedContextualTyping.ts, 217, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x216 : Symbol(x216, Decl(generatedContextualTyping.ts, 218, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 217, 26)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 217, 32)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 218, 26)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 218, 32)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x217 = (<() => Base[]>undefined) || function() { return [d1, d2] }; ->x217 : Symbol(x217, Decl(generatedContextualTyping.ts, 218, 3)) +>x217 : Symbol(x217, Decl(generatedContextualTyping.ts, 219, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x218 = (<() => Base[]>undefined) || function named() { return [d1, d2] }; ->x218 : Symbol(x218, Decl(generatedContextualTyping.ts, 219, 3)) +>x218 : Symbol(x218, Decl(generatedContextualTyping.ts, 220, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 219, 39)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 220, 39)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x219 = (<{ (): Base[]; }>undefined) || function() { return [d1, d2] }; ->x219 : Symbol(x219, Decl(generatedContextualTyping.ts, 220, 3)) +>x219 : Symbol(x219, Decl(generatedContextualTyping.ts, 221, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x220 = (<{ (): Base[]; }>undefined) || function named() { return [d1, d2] }; ->x220 : Symbol(x220, Decl(generatedContextualTyping.ts, 221, 3)) +>x220 : Symbol(x220, Decl(generatedContextualTyping.ts, 222, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 221, 42)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 222, 42)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x221 = (undefined) || [d1, d2]; ->x221 : Symbol(x221, Decl(generatedContextualTyping.ts, 222, 3)) +>x221 : Symbol(x221, Decl(generatedContextualTyping.ts, 223, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x222 = (>undefined) || [d1, d2]; ->x222 : Symbol(x222, Decl(generatedContextualTyping.ts, 223, 3)) +>x222 : Symbol(x222, Decl(generatedContextualTyping.ts, 224, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x223 = (<{ [n: number]: Base; }>undefined) || [d1, d2]; ->x223 : Symbol(x223, Decl(generatedContextualTyping.ts, 224, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 224, 16)) +>x223 : Symbol(x223, Decl(generatedContextualTyping.ts, 225, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x224 = (<{n: Base[]; } >undefined) || { n: [d1, d2] }; ->x224 : Symbol(x224, Decl(generatedContextualTyping.ts, 225, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 14)) +>x224 : Symbol(x224, Decl(generatedContextualTyping.ts, 226, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 226, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 225, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 226, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x225: () => Base[]; x225 = () => [d1, d2]; ->x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 226, 3)) +>x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 227, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 226, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x225 : Symbol(x225, Decl(generatedContextualTyping.ts, 227, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x226: () => Base[]; x226 = function() { return [d1, d2] }; ->x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 227, 3)) +>x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 228, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 227, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x226 : Symbol(x226, Decl(generatedContextualTyping.ts, 228, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x227: () => Base[]; x227 = function named() { return [d1, d2] }; ->x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 228, 3)) +>x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 229, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 228, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 228, 30)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x227 : Symbol(x227, Decl(generatedContextualTyping.ts, 229, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 229, 30)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x228: { (): Base[]; }; x228 = () => [d1, d2]; ->x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 229, 3)) +>x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 230, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 229, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x228 : Symbol(x228, Decl(generatedContextualTyping.ts, 230, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x229: { (): Base[]; }; x229 = function() { return [d1, d2] }; ->x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 230, 3)) +>x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 231, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 230, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x229 : Symbol(x229, Decl(generatedContextualTyping.ts, 231, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x230: { (): Base[]; }; x230 = function named() { return [d1, d2] }; ->x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 231, 3)) +>x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 232, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 231, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 231, 33)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x230 : Symbol(x230, Decl(generatedContextualTyping.ts, 232, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 232, 33)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x231: Base[]; x231 = [d1, d2]; ->x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 232, 3)) +>x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 233, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 232, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x231 : Symbol(x231, Decl(generatedContextualTyping.ts, 233, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x232: Array; x232 = [d1, d2]; ->x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 233, 3)) +>x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 234, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 233, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x232 : Symbol(x232, Decl(generatedContextualTyping.ts, 234, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x233: { [n: number]: Base; }; x233 = [d1, d2]; ->x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 234, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 234, 13)) +>x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 235, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 234, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x233 : Symbol(x233, Decl(generatedContextualTyping.ts, 235, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x234: {n: Base[]; } ; x234 = { n: [d1, d2] }; ->x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 235, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 11)) +>x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 236, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 235, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 235, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x234 : Symbol(x234, Decl(generatedContextualTyping.ts, 236, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x235: (s: Base[]) => any; x235 = n => { var n: Base[]; return null; }; ->x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 236, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 236, 11)) +>x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 237, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 237, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 236, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 36), Decl(generatedContextualTyping.ts, 236, 47)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 236, 36), Decl(generatedContextualTyping.ts, 236, 47)) +>x235 : Symbol(x235, Decl(generatedContextualTyping.ts, 237, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 36), Decl(generatedContextualTyping.ts, 237, 47)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 36), Decl(generatedContextualTyping.ts, 237, 47)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x236: Genric; x236 = { func: n => { return [d1, d2]; } }; ->x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 237, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 238, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 237, 3)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 237, 32)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 237, 38)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x236 : Symbol(x236, Decl(generatedContextualTyping.ts, 238, 3)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 238, 32)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 38)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x237: { n: () => Base[]; } = { n: () => [d1, d2] }; ->x237 : Symbol(x237, Decl(generatedContextualTyping.ts, 238, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 11)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 238, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) - -var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } }; ->x238 : Symbol(x238, Decl(generatedContextualTyping.ts, 239, 3)) +>x237 : Symbol(x237, Decl(generatedContextualTyping.ts, 239, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 239, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } }; ->x239 : Symbol(x239, Decl(generatedContextualTyping.ts, 240, 3)) +var x238: { n: () => Base[]; } = { n: function() { return [d1, d2] } }; +>x238 : Symbol(x238, Decl(generatedContextualTyping.ts, 240, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 240, 34)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 240, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] }; ->x240 : Symbol(x240, Decl(generatedContextualTyping.ts, 241, 3)) +var x239: { n: () => Base[]; } = { n: function named() { return [d1, d2] } }; +>x239 : Symbol(x239, Decl(generatedContextualTyping.ts, 241, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 241, 34)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 241, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } }; ->x241 : Symbol(x241, Decl(generatedContextualTyping.ts, 242, 3)) +var x240: { n: { (): Base[]; }; } = { n: () => [d1, d2] }; +>x240 : Symbol(x240, Decl(generatedContextualTyping.ts, 242, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 242, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } }; ->x242 : Symbol(x242, Decl(generatedContextualTyping.ts, 243, 3)) +var x241: { n: { (): Base[]; }; } = { n: function() { return [d1, d2] } }; +>x241 : Symbol(x241, Decl(generatedContextualTyping.ts, 243, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 243, 37)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 243, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x243: { n: Base[]; } = { n: [d1, d2] }; ->x243 : Symbol(x243, Decl(generatedContextualTyping.ts, 244, 3)) +var x242: { n: { (): Base[]; }; } = { n: function named() { return [d1, d2] } }; +>x242 : Symbol(x242, Decl(generatedContextualTyping.ts, 244, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 244, 37)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 244, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x244: { n: Array; } = { n: [d1, d2] }; ->x244 : Symbol(x244, Decl(generatedContextualTyping.ts, 245, 3)) +var x243: { n: Base[]; } = { n: [d1, d2] }; +>x243 : Symbol(x243, Decl(generatedContextualTyping.ts, 245, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 11)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 245, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) + +var x244: { n: Array; } = { n: [d1, d2] }; +>x244 : Symbol(x244, Decl(generatedContextualTyping.ts, 246, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 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)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 33)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x245: { n: { [n: number]: Base; }; } = { n: [d1, d2] }; ->x245 : Symbol(x245, Decl(generatedContextualTyping.ts, 246, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 18)) +>x245 : Symbol(x245, Decl(generatedContextualTyping.ts, 247, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 246, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x246: { n: {n: Base[]; } ; } = { n: { n: [d1, d2] } }; ->x246 : Symbol(x246, Decl(generatedContextualTyping.ts, 247, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 11)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 16)) +>x246 : Symbol(x246, Decl(generatedContextualTyping.ts, 248, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 11)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 36)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 247, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 36)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x247: { n: (s: Base[]) => any; } = { n: n => { var n: Base[]; return null; } }; ->x247 : Symbol(x247, Decl(generatedContextualTyping.ts, 248, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 11)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 248, 16)) +>x247 : Symbol(x247, Decl(generatedContextualTyping.ts, 249, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 11)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 249, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 43), Decl(generatedContextualTyping.ts, 248, 54)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 248, 43), Decl(generatedContextualTyping.ts, 248, 54)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 43), Decl(generatedContextualTyping.ts, 249, 54)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 43), Decl(generatedContextualTyping.ts, 249, 54)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x248: { n: Genric; } = { n: { func: n => { return [d1, d2]; } } }; ->x248 : Symbol(x248, Decl(generatedContextualTyping.ts, 249, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 11)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x248 : Symbol(x248, Decl(generatedContextualTyping.ts, 250, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 11)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 34)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 249, 39)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 249, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 34)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 250, 39)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 250, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x252: { (): Base[]; }[] = [() => [d1, d2]]; ->x252 : Symbol(x252, Decl(generatedContextualTyping.ts, 250, 3)) +>x252 : Symbol(x252, Decl(generatedContextualTyping.ts, 251, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x253: { (): Base[]; }[] = [function() { return [d1, d2] }]; ->x253 : Symbol(x253, Decl(generatedContextualTyping.ts, 251, 3)) +>x253 : Symbol(x253, Decl(generatedContextualTyping.ts, 252, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x254: { (): Base[]; }[] = [function named() { return [d1, d2] }]; ->x254 : Symbol(x254, Decl(generatedContextualTyping.ts, 252, 3)) +>x254 : Symbol(x254, Decl(generatedContextualTyping.ts, 253, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 252, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 253, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x255: Base[][] = [[d1, d2]]; ->x255 : Symbol(x255, Decl(generatedContextualTyping.ts, 253, 3)) +>x255 : Symbol(x255, Decl(generatedContextualTyping.ts, 254, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x256: Array[] = [[d1, d2]]; ->x256 : Symbol(x256, Decl(generatedContextualTyping.ts, 254, 3)) +>x256 : Symbol(x256, Decl(generatedContextualTyping.ts, 255, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x257: { [n: number]: Base; }[] = [[d1, d2]]; ->x257 : Symbol(x257, Decl(generatedContextualTyping.ts, 255, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 255, 13)) +>x257 : Symbol(x257, Decl(generatedContextualTyping.ts, 256, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x258: {n: Base[]; } [] = [{ n: [d1, d2] }]; ->x258 : Symbol(x258, Decl(generatedContextualTyping.ts, 256, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 11)) +>x258 : Symbol(x258, Decl(generatedContextualTyping.ts, 257, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 256, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x260: Genric[] = [{ func: n => { return [d1, d2]; } }]; ->x260 : Symbol(x260, Decl(generatedContextualTyping.ts, 257, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x260 : Symbol(x260, Decl(generatedContextualTyping.ts, 258, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 257, 29)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 257, 35)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 258, 29)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 258, 35)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x261: () => Base[] = function() { return [d1, d2] } || undefined; ->x261 : Symbol(x261, Decl(generatedContextualTyping.ts, 258, 3)) +>x261 : Symbol(x261, Decl(generatedContextualTyping.ts, 259, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x262: () => Base[] = function named() { return [d1, d2] } || undefined; ->x262 : Symbol(x262, Decl(generatedContextualTyping.ts, 259, 3)) +>x262 : Symbol(x262, Decl(generatedContextualTyping.ts, 260, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 259, 24)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 260, 24)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x263: { (): Base[]; } = function() { return [d1, d2] } || undefined; ->x263 : Symbol(x263, Decl(generatedContextualTyping.ts, 260, 3)) +>x263 : Symbol(x263, Decl(generatedContextualTyping.ts, 261, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x264: { (): Base[]; } = function named() { return [d1, d2] } || undefined; ->x264 : Symbol(x264, Decl(generatedContextualTyping.ts, 261, 3)) +>x264 : Symbol(x264, Decl(generatedContextualTyping.ts, 262, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 261, 27)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 262, 27)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x265: Base[] = [d1, d2] || undefined; ->x265 : Symbol(x265, Decl(generatedContextualTyping.ts, 262, 3)) +>x265 : Symbol(x265, Decl(generatedContextualTyping.ts, 263, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x266: Array = [d1, d2] || undefined; ->x266 : Symbol(x266, Decl(generatedContextualTyping.ts, 263, 3)) +>x266 : Symbol(x266, Decl(generatedContextualTyping.ts, 264, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x267: { [n: number]: Base; } = [d1, d2] || undefined; ->x267 : Symbol(x267, Decl(generatedContextualTyping.ts, 264, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 264, 13)) +>x267 : Symbol(x267, Decl(generatedContextualTyping.ts, 265, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x268: {n: Base[]; } = { n: [d1, d2] } || undefined; ->x268 : Symbol(x268, Decl(generatedContextualTyping.ts, 265, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 11)) +>x268 : Symbol(x268, Decl(generatedContextualTyping.ts, 266, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 266, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 265, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 266, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x269: () => Base[] = undefined || function() { return [d1, d2] }; ->x269 : Symbol(x269, Decl(generatedContextualTyping.ts, 266, 3)) +>x269 : Symbol(x269, Decl(generatedContextualTyping.ts, 267, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x270: () => Base[] = undefined || function named() { return [d1, d2] }; ->x270 : Symbol(x270, Decl(generatedContextualTyping.ts, 267, 3)) +>x270 : Symbol(x270, Decl(generatedContextualTyping.ts, 268, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 267, 37)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 268, 37)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x271: { (): Base[]; } = undefined || function() { return [d1, d2] }; ->x271 : Symbol(x271, Decl(generatedContextualTyping.ts, 268, 3)) +>x271 : Symbol(x271, Decl(generatedContextualTyping.ts, 269, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x272: { (): Base[]; } = undefined || function named() { return [d1, d2] }; ->x272 : Symbol(x272, Decl(generatedContextualTyping.ts, 269, 3)) +>x272 : Symbol(x272, Decl(generatedContextualTyping.ts, 270, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 269, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 270, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x273: Base[] = undefined || [d1, d2]; ->x273 : Symbol(x273, Decl(generatedContextualTyping.ts, 270, 3)) +>x273 : Symbol(x273, Decl(generatedContextualTyping.ts, 271, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x274: Array = undefined || [d1, d2]; ->x274 : Symbol(x274, Decl(generatedContextualTyping.ts, 271, 3)) +>x274 : Symbol(x274, Decl(generatedContextualTyping.ts, 272, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x275: { [n: number]: Base; } = undefined || [d1, d2]; ->x275 : Symbol(x275, Decl(generatedContextualTyping.ts, 272, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 272, 13)) +>x275 : Symbol(x275, Decl(generatedContextualTyping.ts, 273, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x276: {n: Base[]; } = undefined || { n: [d1, d2] }; ->x276 : Symbol(x276, Decl(generatedContextualTyping.ts, 273, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 11)) +>x276 : Symbol(x276, Decl(generatedContextualTyping.ts, 274, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 274, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 273, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 274, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x277: () => Base[] = function() { return [d1, d2] } || function() { return [d1, d2] }; ->x277 : Symbol(x277, Decl(generatedContextualTyping.ts, 274, 3)) +>x277 : Symbol(x277, Decl(generatedContextualTyping.ts, 275, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x278: () => Base[] = function named() { return [d1, d2] } || function named() { return [d1, d2] }; ->x278 : Symbol(x278, Decl(generatedContextualTyping.ts, 275, 3)) +>x278 : Symbol(x278, Decl(generatedContextualTyping.ts, 276, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 275, 24)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 275, 64)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 276, 24)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 276, 64)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x279: { (): Base[]; } = function() { return [d1, d2] } || function() { return [d1, d2] }; ->x279 : Symbol(x279, Decl(generatedContextualTyping.ts, 276, 3)) +>x279 : Symbol(x279, Decl(generatedContextualTyping.ts, 277, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x280: { (): Base[]; } = function named() { return [d1, d2] } || function named() { return [d1, d2] }; ->x280 : Symbol(x280, Decl(generatedContextualTyping.ts, 277, 3)) +>x280 : Symbol(x280, Decl(generatedContextualTyping.ts, 278, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 277, 27)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 277, 67)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 278, 27)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 278, 67)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x281: Base[] = [d1, d2] || [d1, d2]; ->x281 : Symbol(x281, Decl(generatedContextualTyping.ts, 278, 3)) +>x281 : Symbol(x281, Decl(generatedContextualTyping.ts, 279, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x282: Array = [d1, d2] || [d1, d2]; ->x282 : Symbol(x282, Decl(generatedContextualTyping.ts, 279, 3)) +>x282 : Symbol(x282, Decl(generatedContextualTyping.ts, 280, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x283: { [n: number]: Base; } = [d1, d2] || [d1, d2]; ->x283 : Symbol(x283, Decl(generatedContextualTyping.ts, 280, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 280, 13)) +>x283 : Symbol(x283, Decl(generatedContextualTyping.ts, 281, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x284: {n: Base[]; } = { n: [d1, d2] } || { n: [d1, d2] }; ->x284 : Symbol(x284, Decl(generatedContextualTyping.ts, 281, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 11)) +>x284 : Symbol(x284, Decl(generatedContextualTyping.ts, 282, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 28)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 281, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 28)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 282, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x285: () => Base[] = true ? () => [d1, d2] : () => [d1, d2]; ->x285 : Symbol(x285, Decl(generatedContextualTyping.ts, 282, 3)) +>x285 : Symbol(x285, Decl(generatedContextualTyping.ts, 283, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x286: () => Base[] = true ? function() { return [d1, d2] } : function() { return [d1, d2] }; ->x286 : Symbol(x286, Decl(generatedContextualTyping.ts, 283, 3)) +>x286 : Symbol(x286, Decl(generatedContextualTyping.ts, 284, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x287: () => Base[] = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] }; ->x287 : Symbol(x287, Decl(generatedContextualTyping.ts, 284, 3)) +>x287 : Symbol(x287, Decl(generatedContextualTyping.ts, 285, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 284, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 284, 70)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 285, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 285, 70)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x288: { (): Base[]; } = true ? () => [d1, d2] : () => [d1, d2]; ->x288 : Symbol(x288, Decl(generatedContextualTyping.ts, 285, 3)) +>x288 : Symbol(x288, Decl(generatedContextualTyping.ts, 286, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x289: { (): Base[]; } = true ? function() { return [d1, d2] } : function() { return [d1, d2] }; ->x289 : Symbol(x289, Decl(generatedContextualTyping.ts, 286, 3)) +>x289 : Symbol(x289, Decl(generatedContextualTyping.ts, 287, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x290: { (): Base[]; } = true ? function named() { return [d1, d2] } : function named() { return [d1, d2] }; ->x290 : Symbol(x290, Decl(generatedContextualTyping.ts, 287, 3)) +>x290 : Symbol(x290, Decl(generatedContextualTyping.ts, 288, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 287, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 287, 73)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 288, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 288, 73)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x291: Base[] = true ? [d1, d2] : [d1, d2]; ->x291 : Symbol(x291, Decl(generatedContextualTyping.ts, 288, 3)) +>x291 : Symbol(x291, Decl(generatedContextualTyping.ts, 289, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x292: Array = true ? [d1, d2] : [d1, d2]; ->x292 : Symbol(x292, Decl(generatedContextualTyping.ts, 289, 3)) +>x292 : Symbol(x292, Decl(generatedContextualTyping.ts, 290, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x293: { [n: number]: Base; } = true ? [d1, d2] : [d1, d2]; ->x293 : Symbol(x293, Decl(generatedContextualTyping.ts, 290, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 290, 13)) +>x293 : Symbol(x293, Decl(generatedContextualTyping.ts, 291, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x294: {n: Base[]; } = true ? { n: [d1, d2] } : { n: [d1, d2] }; ->x294 : Symbol(x294, Decl(generatedContextualTyping.ts, 291, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 11)) +>x294 : Symbol(x294, Decl(generatedContextualTyping.ts, 292, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 35)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 291, 53)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 35)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 53)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x295: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : n => { var n: Base[]; return null; }; ->x295 : Symbol(x295, Decl(generatedContextualTyping.ts, 292, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 292, 11)) +>x295 : Symbol(x295, Decl(generatedContextualTyping.ts, 293, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 293, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 37), Decl(generatedContextualTyping.ts, 292, 48)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 37), Decl(generatedContextualTyping.ts, 292, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 37), Decl(generatedContextualTyping.ts, 293, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 37), Decl(generatedContextualTyping.ts, 293, 48)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 76), Decl(generatedContextualTyping.ts, 292, 87)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 292, 76), Decl(generatedContextualTyping.ts, 292, 87)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 76), Decl(generatedContextualTyping.ts, 293, 87)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 76), Decl(generatedContextualTyping.ts, 293, 87)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x296: Genric = true ? { func: n => { return [d1, d2]; } } : { func: n => { return [d1, d2]; } }; ->x296 : Symbol(x296, Decl(generatedContextualTyping.ts, 293, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 293, 33)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 39)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 293, 71)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 293, 77)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x296 : Symbol(x296, Decl(generatedContextualTyping.ts, 294, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 294, 33)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 294, 39)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 294, 71)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 294, 77)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x297: () => Base[] = true ? undefined : () => [d1, d2]; ->x297 : Symbol(x297, Decl(generatedContextualTyping.ts, 294, 3)) +>x297 : Symbol(x297, Decl(generatedContextualTyping.ts, 295, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x298: () => Base[] = true ? undefined : function() { return [d1, d2] }; ->x298 : Symbol(x298, Decl(generatedContextualTyping.ts, 295, 3)) +>x298 : Symbol(x298, Decl(generatedContextualTyping.ts, 296, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x299: () => Base[] = true ? undefined : function named() { return [d1, d2] }; ->x299 : Symbol(x299, Decl(generatedContextualTyping.ts, 296, 3)) +>x299 : Symbol(x299, Decl(generatedContextualTyping.ts, 297, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 296, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 297, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x300: { (): Base[]; } = true ? undefined : () => [d1, d2]; ->x300 : Symbol(x300, Decl(generatedContextualTyping.ts, 297, 3)) +>x300 : Symbol(x300, Decl(generatedContextualTyping.ts, 298, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x301: { (): Base[]; } = true ? undefined : function() { return [d1, d2] }; ->x301 : Symbol(x301, Decl(generatedContextualTyping.ts, 298, 3)) +>x301 : Symbol(x301, Decl(generatedContextualTyping.ts, 299, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x302: { (): Base[]; } = true ? undefined : function named() { return [d1, d2] }; ->x302 : Symbol(x302, Decl(generatedContextualTyping.ts, 299, 3)) +>x302 : Symbol(x302, Decl(generatedContextualTyping.ts, 300, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 299, 46)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 300, 46)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x303: Base[] = true ? undefined : [d1, d2]; ->x303 : Symbol(x303, Decl(generatedContextualTyping.ts, 300, 3)) +>x303 : Symbol(x303, Decl(generatedContextualTyping.ts, 301, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x304: Array = true ? undefined : [d1, d2]; ->x304 : Symbol(x304, Decl(generatedContextualTyping.ts, 301, 3)) +>x304 : Symbol(x304, Decl(generatedContextualTyping.ts, 302, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x305: { [n: number]: Base; } = true ? undefined : [d1, d2]; ->x305 : Symbol(x305, Decl(generatedContextualTyping.ts, 302, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 302, 13)) +>x305 : Symbol(x305, Decl(generatedContextualTyping.ts, 303, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x306: {n: Base[]; } = true ? undefined : { n: [d1, d2] }; ->x306 : Symbol(x306, Decl(generatedContextualTyping.ts, 303, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 11)) +>x306 : Symbol(x306, Decl(generatedContextualTyping.ts, 304, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 303, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x307: (s: Base[]) => any = true ? undefined : n => { var n: Base[]; return null; }; ->x307 : Symbol(x307, Decl(generatedContextualTyping.ts, 304, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 304, 11)) +>x307 : Symbol(x307, Decl(generatedContextualTyping.ts, 305, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 305, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 49), Decl(generatedContextualTyping.ts, 304, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 304, 49), Decl(generatedContextualTyping.ts, 304, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 49), Decl(generatedContextualTyping.ts, 305, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 49), Decl(generatedContextualTyping.ts, 305, 60)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x308: Genric = true ? undefined : { func: n => { return [d1, d2]; } }; ->x308 : Symbol(x308, Decl(generatedContextualTyping.ts, 305, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x308 : Symbol(x308, Decl(generatedContextualTyping.ts, 306, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 305, 45)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 305, 51)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 306, 45)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 306, 51)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x309: () => Base[] = true ? () => [d1, d2] : undefined; ->x309 : Symbol(x309, Decl(generatedContextualTyping.ts, 306, 3)) +>x309 : Symbol(x309, Decl(generatedContextualTyping.ts, 307, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x310: () => Base[] = true ? function() { return [d1, d2] } : undefined; ->x310 : Symbol(x310, Decl(generatedContextualTyping.ts, 307, 3)) +>x310 : Symbol(x310, Decl(generatedContextualTyping.ts, 308, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x311: () => Base[] = true ? function named() { return [d1, d2] } : undefined; ->x311 : Symbol(x311, Decl(generatedContextualTyping.ts, 308, 3)) +>x311 : Symbol(x311, Decl(generatedContextualTyping.ts, 309, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 308, 31)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 309, 31)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x312: { (): Base[]; } = true ? () => [d1, d2] : undefined; ->x312 : Symbol(x312, Decl(generatedContextualTyping.ts, 309, 3)) +>x312 : Symbol(x312, Decl(generatedContextualTyping.ts, 310, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x313: { (): Base[]; } = true ? function() { return [d1, d2] } : undefined; ->x313 : Symbol(x313, Decl(generatedContextualTyping.ts, 310, 3)) +>x313 : Symbol(x313, Decl(generatedContextualTyping.ts, 311, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x314: { (): Base[]; } = true ? function named() { return [d1, d2] } : undefined; ->x314 : Symbol(x314, Decl(generatedContextualTyping.ts, 311, 3)) +>x314 : Symbol(x314, Decl(generatedContextualTyping.ts, 312, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 311, 34)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 312, 34)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x315: Base[] = true ? [d1, d2] : undefined; ->x315 : Symbol(x315, Decl(generatedContextualTyping.ts, 312, 3)) +>x315 : Symbol(x315, Decl(generatedContextualTyping.ts, 313, 3)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x316: Array = true ? [d1, d2] : undefined; ->x316 : Symbol(x316, Decl(generatedContextualTyping.ts, 313, 3)) +>x316 : Symbol(x316, Decl(generatedContextualTyping.ts, 314, 3)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x317: { [n: number]: Base; } = true ? [d1, d2] : undefined; ->x317 : Symbol(x317, Decl(generatedContextualTyping.ts, 314, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 314, 13)) +>x317 : Symbol(x317, Decl(generatedContextualTyping.ts, 315, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 13)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x318: {n: Base[]; } = true ? { n: [d1, d2] } : undefined; ->x318 : Symbol(x318, Decl(generatedContextualTyping.ts, 315, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 11)) +>x318 : Symbol(x318, Decl(generatedContextualTyping.ts, 316, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 315, 35)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 35)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) var x319: (s: Base[]) => any = true ? n => { var n: Base[]; return null; } : undefined; ->x319 : Symbol(x319, Decl(generatedContextualTyping.ts, 316, 3)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 316, 11)) +>x319 : Symbol(x319, Decl(generatedContextualTyping.ts, 317, 3)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 317, 11)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 37), Decl(generatedContextualTyping.ts, 316, 48)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 316, 37), Decl(generatedContextualTyping.ts, 316, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 37), Decl(generatedContextualTyping.ts, 317, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 37), Decl(generatedContextualTyping.ts, 317, 48)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >undefined : Symbol(undefined) var x320: Genric = true ? { func: n => { return [d1, d2]; } } : undefined; ->x320 : Symbol(x320, Decl(generatedContextualTyping.ts, 317, 3)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x320 : Symbol(x320, Decl(generatedContextualTyping.ts, 318, 3)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 317, 33)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 317, 39)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 318, 33)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 318, 39)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) >undefined : Symbol(undefined) function x321(n: () => Base[]) { }; x321(() => [d1, d2]); ->x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 317, 80)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 318, 14)) +>x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 318, 80)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 319, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 317, 80)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x321 : Symbol(x321, Decl(generatedContextualTyping.ts, 318, 80)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x322(n: () => Base[]) { }; x322(function() { return [d1, d2] }); ->x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 318, 57)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 319, 14)) +>x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 319, 57)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 320, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 318, 57)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x322 : Symbol(x322, Decl(generatedContextualTyping.ts, 319, 57)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x323(n: () => Base[]) { }; x323(function named() { return [d1, d2] }); ->x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 319, 73)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 320, 14)) +>x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 320, 73)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 321, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 319, 73)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 320, 41)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x323 : Symbol(x323, Decl(generatedContextualTyping.ts, 320, 73)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 321, 41)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x324(n: { (): Base[]; }) { }; x324(() => [d1, d2]); ->x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 320, 79)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 321, 14)) +>x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 321, 79)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 322, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 320, 79)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x324 : Symbol(x324, Decl(generatedContextualTyping.ts, 321, 79)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x325(n: { (): Base[]; }) { }; x325(function() { return [d1, d2] }); ->x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 321, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 322, 14)) +>x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 322, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 323, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 321, 60)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x325 : Symbol(x325, Decl(generatedContextualTyping.ts, 322, 60)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x326(n: { (): Base[]; }) { }; x326(function named() { return [d1, d2] }); ->x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 322, 76)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 323, 14)) +>x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 323, 76)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 324, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 322, 76)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 323, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x326 : Symbol(x326, Decl(generatedContextualTyping.ts, 323, 76)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 324, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x327(n: Base[]) { }; x327([d1, d2]); ->x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 323, 82)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 324, 14)) +>x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 324, 82)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 325, 14)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 323, 82)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x327 : Symbol(x327, Decl(generatedContextualTyping.ts, 324, 82)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x328(n: Array) { }; x328([d1, d2]); ->x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 324, 45)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 325, 14)) +>x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 325, 45)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 14)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 324, 45)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x328 : Symbol(x328, Decl(generatedContextualTyping.ts, 325, 45)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x329(n: { [n: number]: Base; }) { }; x329([d1, d2]); ->x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 325, 50)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 14)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 326, 20)) +>x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 326, 50)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 14)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 325, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x329 : Symbol(x329, Decl(generatedContextualTyping.ts, 326, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x330(n: {n: Base[]; } ) { }; x330({ n: [d1, d2] }); ->x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 326, 61)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 14)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 18)) +>x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 327, 61)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 14)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 326, 61)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 327, 44)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x330 : Symbol(x330, Decl(generatedContextualTyping.ts, 327, 61)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 44)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) function x331(n: (s: Base[]) => any) { }; x331(n => { var n: Base[]; return null; }); ->x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 327, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 14)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 328, 18)) +>x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 328, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 14)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 329, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 327, 60)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 47), Decl(generatedContextualTyping.ts, 328, 57)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 328, 47), Decl(generatedContextualTyping.ts, 328, 57)) +>x331 : Symbol(x331, Decl(generatedContextualTyping.ts, 328, 60)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 47), Decl(generatedContextualTyping.ts, 329, 57)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 47), Decl(generatedContextualTyping.ts, 329, 57)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) function x332(n: Genric) { }; x332({ func: n => { return [d1, d2]; } }); ->x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 328, 85)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 14)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 329, 85)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 14)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 328, 85)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 329, 42)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 329, 48)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x332 : Symbol(x332, Decl(generatedContextualTyping.ts, 329, 85)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 330, 42)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 48)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x333 = (n: () => Base[]) => n; x333(() => [d1, d2]); ->x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 330, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 12)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 330, 12)) ->x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 330, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) - -var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] }); ->x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 331, 3)) +>x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 331, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 331, 12)) ->x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 331, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x333 : Symbol(x333, Decl(generatedContextualTyping.ts, 331, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] }); ->x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 332, 3)) +var x334 = (n: () => Base[]) => n; x334(function() { return [d1, d2] }); +>x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 332, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 332, 12)) ->x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 332, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 332, 40)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x334 : Symbol(x334, Decl(generatedContextualTyping.ts, 332, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]); ->x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 333, 3)) +var x335 = (n: () => Base[]) => n; x335(function named() { return [d1, d2] }); +>x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 333, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 333, 12)) ->x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 333, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x335 : Symbol(x335, Decl(generatedContextualTyping.ts, 333, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 333, 40)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] }); ->x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 334, 3)) +var x336 = (n: { (): Base[]; }) => n; x336(() => [d1, d2]); +>x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 334, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 334, 12)) ->x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 334, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x336 : Symbol(x336, Decl(generatedContextualTyping.ts, 334, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] }); ->x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 335, 3)) +var x337 = (n: { (): Base[]; }) => n; x337(function() { return [d1, d2] }); +>x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 335, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 335, 12)) ->x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 335, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 335, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x337 : Symbol(x337, Decl(generatedContextualTyping.ts, 335, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x339 = (n: Base[]) => n; x339([d1, d2]); ->x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 336, 3)) +var x338 = (n: { (): Base[]; }) => n; x338(function named() { return [d1, d2] }); +>x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 336, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 336, 12)) ->x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 336, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x338 : Symbol(x338, Decl(generatedContextualTyping.ts, 336, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 336, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x340 = (n: Array) => n; x340([d1, d2]); ->x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3)) +var x339 = (n: Base[]) => n; x339([d1, d2]); +>x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 337, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12)) ->Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 337, 12)) ->x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 337, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x339 : Symbol(x339, Decl(generatedContextualTyping.ts, 337, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]); ->x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 338, 3)) +var x340 = (n: Array) => n; x340([d1, d2]); +>x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 338, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 12)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 338, 18)) +>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, 338, 12)) ->x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 338, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x340 : Symbol(x340, Decl(generatedContextualTyping.ts, 338, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] }); ->x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 339, 3)) +var x341 = (n: { [n: number]: Base; }) => n; x341([d1, d2]); +>x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 339, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 16)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 18)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 12)) ->x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 339, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 339, 43)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x341 : Symbol(x341, Decl(generatedContextualTyping.ts, 339, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x343 = (n: (s: Base[]) => any) => n; x343(n => { var n: Base[]; return null; }); ->x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 340, 3)) +var x342 = (n: {n: Base[]; } ) => n; x342({ n: [d1, d2] }); +>x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 340, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 340, 16)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 12)) ->x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 340, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 46), Decl(generatedContextualTyping.ts, 340, 56)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 46), Decl(generatedContextualTyping.ts, 340, 56)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>x342 : Symbol(x342, Decl(generatedContextualTyping.ts, 340, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 340, 43)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) -var x344 = (n: Genric) => n; x344({ func: n => { return [d1, d2]; } }); ->x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 341, 3)) +var x343 = (n: (s: Base[]) => any) => n; x343(n => { var n: Base[]; return null; }); +>x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 341, 3)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 341, 16)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) >n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 12)) ->x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 341, 3)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 341, 41)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x343 : Symbol(x343, Decl(generatedContextualTyping.ts, 341, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 46), Decl(generatedContextualTyping.ts, 341, 56)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 341, 46), Decl(generatedContextualTyping.ts, 341, 56)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) + +var x344 = (n: Genric) => n; x344({ func: n => { return [d1, d2]; } }); +>x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 342, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 12)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 12)) +>x344 : Symbol(x344, Decl(generatedContextualTyping.ts, 342, 3)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 342, 41)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x345 = function(n: () => Base[]) { }; x345(() => [d1, d2]); ->x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 342, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 342, 20)) +>x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 343, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 343, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 342, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x345 : Symbol(x345, Decl(generatedContextualTyping.ts, 343, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x346 = function(n: () => Base[]) { }; x346(function() { return [d1, d2] }); ->x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 343, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 343, 20)) +>x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 344, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 344, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 343, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x346 : Symbol(x346, Decl(generatedContextualTyping.ts, 344, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x347 = function(n: () => Base[]) { }; x347(function named() { return [d1, d2] }); ->x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 344, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 344, 20)) +>x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 345, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 345, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 344, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 344, 47)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x347 : Symbol(x347, Decl(generatedContextualTyping.ts, 345, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 345, 47)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x348 = function(n: { (): Base[]; }) { }; x348(() => [d1, d2]); ->x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 345, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 345, 20)) +>x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 346, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 346, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 345, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x348 : Symbol(x348, Decl(generatedContextualTyping.ts, 346, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x349 = function(n: { (): Base[]; }) { }; x349(function() { return [d1, d2] }); ->x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 346, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 346, 20)) +>x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 347, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 347, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 346, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x349 : Symbol(x349, Decl(generatedContextualTyping.ts, 347, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x350 = function(n: { (): Base[]; }) { }; x350(function named() { return [d1, d2] }); ->x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 347, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 347, 20)) +>x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 348, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 348, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 347, 3)) ->named : Symbol(named, Decl(generatedContextualTyping.ts, 347, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x350 : Symbol(x350, Decl(generatedContextualTyping.ts, 348, 3)) +>named : Symbol(named, Decl(generatedContextualTyping.ts, 348, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x351 = function(n: Base[]) { }; x351([d1, d2]); ->x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 348, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 348, 20)) +>x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 349, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 348, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x351 : Symbol(x351, Decl(generatedContextualTyping.ts, 349, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x352 = function(n: Array) { }; x352([d1, d2]); ->x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 349, 20)) +>x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 350, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 20)) >Array : Symbol(Array, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 349, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x352 : Symbol(x352, Decl(generatedContextualTyping.ts, 350, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x353 = function(n: { [n: number]: Base; }) { }; x353([d1, d2]); ->x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 350, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 20)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 350, 26)) +>x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 351, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 20)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 26)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 350, 3)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x353 : Symbol(x353, Decl(generatedContextualTyping.ts, 351, 3)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x354 = function(n: {n: Base[]; } ) { }; x354({ n: [d1, d2] }); ->x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 351, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 20)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 24)) +>x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 352, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 20)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 351, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 351, 50)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x354 : Symbol(x354, Decl(generatedContextualTyping.ts, 352, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 50)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) var x355 = function(n: (s: Base[]) => any) { }; x355(n => { var n: Base[]; return null; }); ->x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 352, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 20)) ->s : Symbol(s, Decl(generatedContextualTyping.ts, 352, 24)) +>x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 353, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 20)) +>s : Symbol(s, Decl(generatedContextualTyping.ts, 353, 24)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 352, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 53), Decl(generatedContextualTyping.ts, 352, 63)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 352, 53), Decl(generatedContextualTyping.ts, 352, 63)) +>x355 : Symbol(x355, Decl(generatedContextualTyping.ts, 353, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 53), Decl(generatedContextualTyping.ts, 353, 63)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 53), Decl(generatedContextualTyping.ts, 353, 63)) >Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) var x356 = function(n: Genric) { }; x356({ func: n => { return [d1, d2]; } }); ->x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 353, 3)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 20)) ->Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 2, 42)) ->Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) ->x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 353, 3)) ->func : Symbol(func, Decl(generatedContextualTyping.ts, 353, 48)) ->n : Symbol(n, Decl(generatedContextualTyping.ts, 353, 54)) ->d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 4, 19)) ->d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 4, 40)) +>x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 354, 3)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 354, 20)) +>Genric : Symbol(Genric, Decl(generatedContextualTyping.ts, 3, 42)) +>Base : Symbol(Base, Decl(generatedContextualTyping.ts, 0, 0)) +>x356 : Symbol(x356, Decl(generatedContextualTyping.ts, 354, 3)) +>func : Symbol(func, Decl(generatedContextualTyping.ts, 354, 48)) +>n : Symbol(n, Decl(generatedContextualTyping.ts, 354, 54)) +>d1 : Symbol(d1, Decl(generatedContextualTyping.ts, 5, 19)) +>d2 : Symbol(d2, Decl(generatedContextualTyping.ts, 5, 40)) diff --git a/tests/baselines/reference/generatedContextualTyping.types b/tests/baselines/reference/generatedContextualTyping.types index e8f434d31a88c..2e9625cdb8bd1 100644 --- a/tests/baselines/reference/generatedContextualTyping.types +++ b/tests/baselines/reference/generatedContextualTyping.types @@ -1,4 +1,5 @@ === tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts === + class Base { private p; } >Base : Base >p : any diff --git a/tests/baselines/reference/getterMissingReturnError.errors.txt b/tests/baselines/reference/getterMissingReturnError.errors.txt index 8900cc5e78f6a..e504de07ef423 100644 --- a/tests/baselines/reference/getterMissingReturnError.errors.txt +++ b/tests/baselines/reference/getterMissingReturnError.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/getterMissingReturnError.ts(2,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/getterMissingReturnError.ts(2,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/compiler/getterMissingReturnError.ts(2,16): error TS2378: A 'get' accessor must return a value. ==== tests/cases/compiler/getterMissingReturnError.ts (2 errors) ==== @@ -8,7 +8,7 @@ tests/cases/compiler/getterMissingReturnError.ts(2,16): error TS2378: A 'get' ac ~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } } diff --git a/tests/baselines/reference/ifDoWhileStatements.js b/tests/baselines/reference/ifDoWhileStatements.js index 020d3f053d140..a2553c674b090 100644 --- a/tests/baselines/reference/ifDoWhileStatements.js +++ b/tests/baselines/reference/ifDoWhileStatements.js @@ -1,4 +1,5 @@ //// [ifDoWhileStatements.ts] + interface I { id: number; } diff --git a/tests/baselines/reference/ifDoWhileStatements.symbols b/tests/baselines/reference/ifDoWhileStatements.symbols index e2b375cb54bf7..80c8fc7f1d884 100644 --- a/tests/baselines/reference/ifDoWhileStatements.symbols +++ b/tests/baselines/reference/ifDoWhileStatements.symbols @@ -1,92 +1,93 @@ === tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts === + interface I { >I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0)) id: number; ->id : Symbol(id, Decl(ifDoWhileStatements.ts, 0, 13)) +>id : Symbol(id, Decl(ifDoWhileStatements.ts, 1, 13)) } class C implements I { ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) >I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0)) id: number; ->id : Symbol(id, Decl(ifDoWhileStatements.ts, 4, 22)) +>id : Symbol(id, Decl(ifDoWhileStatements.ts, 5, 22)) name: string; ->name : Symbol(name, Decl(ifDoWhileStatements.ts, 5, 15)) +>name : Symbol(name, Decl(ifDoWhileStatements.ts, 6, 15)) } class C2 extends C { ->C2 : Symbol(C2, Decl(ifDoWhileStatements.ts, 7, 1)) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) +>C2 : Symbol(C2, Decl(ifDoWhileStatements.ts, 8, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) valid: boolean; ->valid : Symbol(valid, Decl(ifDoWhileStatements.ts, 9, 20)) +>valid : Symbol(valid, Decl(ifDoWhileStatements.ts, 10, 20)) } class D{ ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) ->T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) +>T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8)) source: T; ->source : Symbol(source, Decl(ifDoWhileStatements.ts, 13, 11)) ->T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8)) +>source : Symbol(source, Decl(ifDoWhileStatements.ts, 14, 11)) +>T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8)) recurse: D; ->recurse : Symbol(recurse, Decl(ifDoWhileStatements.ts, 14, 14)) ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) ->T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8)) +>recurse : Symbol(recurse, Decl(ifDoWhileStatements.ts, 15, 14)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) +>T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8)) wrapped: D> ->wrapped : Symbol(wrapped, Decl(ifDoWhileStatements.ts, 15, 18)) ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) ->T : Symbol(T, Decl(ifDoWhileStatements.ts, 13, 8)) +>wrapped : Symbol(wrapped, Decl(ifDoWhileStatements.ts, 16, 18)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) +>T : Symbol(T, Decl(ifDoWhileStatements.ts, 14, 8)) } function F(x: string): number { return 42; } ->F : Symbol(F, Decl(ifDoWhileStatements.ts, 17, 1)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 19, 11)) +>F : Symbol(F, Decl(ifDoWhileStatements.ts, 18, 1)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 11)) function F2(x: number): boolean { return x < 42; } ->F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 19, 44)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 12)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 20, 12)) +>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 20, 44)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 21, 12)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 21, 12)) module M { ->M : Symbol(M, Decl(ifDoWhileStatements.ts, 20, 50)) +>M : Symbol(M, Decl(ifDoWhileStatements.ts, 21, 50)) export class A { ->A : Symbol(A, Decl(ifDoWhileStatements.ts, 22, 10)) +>A : Symbol(A, Decl(ifDoWhileStatements.ts, 23, 10)) name: string; ->name : Symbol(name, Decl(ifDoWhileStatements.ts, 23, 20)) +>name : Symbol(name, Decl(ifDoWhileStatements.ts, 24, 20)) } 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)) +>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 26, 5)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 28, 23)) >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 27, 23)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 28, 23)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } module N { ->N : Symbol(N, Decl(ifDoWhileStatements.ts, 28, 1)) +>N : Symbol(N, Decl(ifDoWhileStatements.ts, 29, 1)) export class A { ->A : Symbol(A, Decl(ifDoWhileStatements.ts, 30, 10)) +>A : Symbol(A, Decl(ifDoWhileStatements.ts, 31, 10)) id: number; ->id : Symbol(id, Decl(ifDoWhileStatements.ts, 31, 20)) +>id : Symbol(id, Decl(ifDoWhileStatements.ts, 32, 20)) } 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)) +>F2 : Symbol(F2, Decl(ifDoWhileStatements.ts, 34, 5)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 36, 23)) >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 35, 23)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 36, 23)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } @@ -137,200 +138,200 @@ while ({}) { } do { }while({}) if ({ x: 1, y: 'a' }) { } ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 79, 5)) ->y : Symbol(y, Decl(ifDoWhileStatements.ts, 79, 11)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 80, 5)) +>y : Symbol(y, Decl(ifDoWhileStatements.ts, 80, 11)) while ({ x: 1, y: 'a' }) { } ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 80, 8)) ->y : Symbol(y, Decl(ifDoWhileStatements.ts, 80, 14)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 81, 8)) +>y : Symbol(y, Decl(ifDoWhileStatements.ts, 81, 14)) do { }while({ x: 1, y: 'a' }) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 81, 13)) ->y : Symbol(y, Decl(ifDoWhileStatements.ts, 81, 19)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 82, 13)) +>y : Symbol(y, Decl(ifDoWhileStatements.ts, 82, 19)) if (() => 43) { } while (() => 43) { } do { }while(() => 43) if (new C()) { } ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) while (new C()) { } ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) do { }while(new C()) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) if (new D()) { } ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) while (new D()) { } ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) do { }while(new D()) ->D : Symbol(D, Decl(ifDoWhileStatements.ts, 11, 1)) ->C : Symbol(C, Decl(ifDoWhileStatements.ts, 2, 1)) +>D : Symbol(D, Decl(ifDoWhileStatements.ts, 12, 1)) +>C : Symbol(C, Decl(ifDoWhileStatements.ts, 3, 1)) // references var a = true; ->a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3)) +>a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3)) if (a) { } ->a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3)) +>a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3)) while (a) { } ->a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3)) +>a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3)) do { }while(a) ->a : Symbol(a, Decl(ifDoWhileStatements.ts, 96, 3)) +>a : Symbol(a, Decl(ifDoWhileStatements.ts, 97, 3)) var b = null; ->b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3)) +>b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3)) if (b) { } ->b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3)) +>b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3)) while (b) { } ->b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3)) +>b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3)) do { }while(b) ->b : Symbol(b, Decl(ifDoWhileStatements.ts, 101, 3)) +>b : Symbol(b, Decl(ifDoWhileStatements.ts, 102, 3)) var c = undefined; ->c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3)) +>c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3)) >undefined : Symbol(undefined) if (c) { } ->c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3)) +>c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3)) while (c) { } ->c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3)) +>c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3)) do { }while(c) ->c : Symbol(c, Decl(ifDoWhileStatements.ts, 106, 3)) +>c : Symbol(c, Decl(ifDoWhileStatements.ts, 107, 3)) var d = 0.0; ->d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3)) +>d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3)) if (d) { } ->d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3)) +>d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3)) while (d) { } ->d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3)) +>d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3)) do { }while(d) ->d : Symbol(d, Decl(ifDoWhileStatements.ts, 111, 3)) +>d : Symbol(d, Decl(ifDoWhileStatements.ts, 112, 3)) var e = 'a string'; ->e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3)) +>e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3)) if (e) { } ->e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3)) +>e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3)) while (e) { } ->e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3)) +>e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3)) do { }while(e) ->e : Symbol(e, Decl(ifDoWhileStatements.ts, 116, 3)) +>e : Symbol(e, Decl(ifDoWhileStatements.ts, 117, 3)) var f = ''; ->f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3)) +>f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3)) if (f) { } ->f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3)) +>f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3)) while (f) { } ->f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3)) +>f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3)) do { }while(f) ->f : Symbol(f, Decl(ifDoWhileStatements.ts, 121, 3)) +>f : Symbol(f, Decl(ifDoWhileStatements.ts, 122, 3)) var g = /[a-z]/ ->g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3)) +>g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3)) if (g) { } ->g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3)) +>g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3)) while (g) { } ->g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3)) +>g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3)) do { }while(g) ->g : Symbol(g, Decl(ifDoWhileStatements.ts, 126, 3)) +>g : Symbol(g, Decl(ifDoWhileStatements.ts, 127, 3)) var h = []; ->h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3)) +>h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3)) if (h) { } ->h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3)) +>h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3)) while (h) { } ->h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3)) +>h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3)) do { }while(h) ->h : Symbol(h, Decl(ifDoWhileStatements.ts, 131, 3)) +>h : Symbol(h, Decl(ifDoWhileStatements.ts, 132, 3)) var i = [1, 2]; ->i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3)) +>i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3)) if (i) { } ->i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3)) +>i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3)) while (i) { } ->i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3)) +>i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3)) do { }while(i) ->i : Symbol(i, Decl(ifDoWhileStatements.ts, 136, 3)) +>i : Symbol(i, Decl(ifDoWhileStatements.ts, 137, 3)) var j = {}; ->j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3)) +>j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3)) if (j) { } ->j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3)) +>j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3)) while (j) { } ->j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3)) +>j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3)) do { }while(j) ->j : Symbol(j, Decl(ifDoWhileStatements.ts, 141, 3)) +>j : Symbol(j, Decl(ifDoWhileStatements.ts, 142, 3)) var k = { x: 1, y: 'a' }; ->k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 146, 9)) ->y : Symbol(y, Decl(ifDoWhileStatements.ts, 146, 15)) +>k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 147, 9)) +>y : Symbol(y, Decl(ifDoWhileStatements.ts, 147, 15)) if (k) { } ->k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3)) +>k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3)) while (k) { } ->k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3)) +>k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3)) do { }while(k) ->k : Symbol(k, Decl(ifDoWhileStatements.ts, 146, 3)) +>k : Symbol(k, Decl(ifDoWhileStatements.ts, 147, 3)) function fn(x?: string): I { return null; } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) ->x : Symbol(x, Decl(ifDoWhileStatements.ts, 151, 12)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) +>x : Symbol(x, Decl(ifDoWhileStatements.ts, 152, 12)) >I : Symbol(I, Decl(ifDoWhileStatements.ts, 0, 0)) if (fn()) { } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) while (fn()) { } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) do { }while(fn()) ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) if (fn) { } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) while (fn) { } ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) do { }while(fn) ->fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 149, 14)) +>fn : Symbol(fn, Decl(ifDoWhileStatements.ts, 150, 14)) diff --git a/tests/baselines/reference/ifDoWhileStatements.types b/tests/baselines/reference/ifDoWhileStatements.types index 92a9df6a4dd7f..660eaa4fb634b 100644 --- a/tests/baselines/reference/ifDoWhileStatements.types +++ b/tests/baselines/reference/ifDoWhileStatements.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts === + interface I { >I : I diff --git a/tests/baselines/reference/ifElseWithStatements1.errors.txt b/tests/baselines/reference/ifElseWithStatements1.errors.txt index 186cff5924139..5dc4d9b0db585 100644 --- a/tests/baselines/reference/ifElseWithStatements1.errors.txt +++ b/tests/baselines/reference/ifElseWithStatements1.errors.txt @@ -1,8 +1,9 @@ -tests/cases/compiler/ifElseWithStatements1.ts(2,5): error TS2304: Cannot find name 'f'. -tests/cases/compiler/ifElseWithStatements1.ts(4,5): error TS2304: Cannot find name 'f'. +tests/cases/compiler/ifElseWithStatements1.ts(3,5): error TS2304: Cannot find name 'f'. +tests/cases/compiler/ifElseWithStatements1.ts(5,5): error TS2304: Cannot find name 'f'. ==== tests/cases/compiler/ifElseWithStatements1.ts (2 errors) ==== + if (true) f(); ~ diff --git a/tests/baselines/reference/ifElseWithStatements1.js b/tests/baselines/reference/ifElseWithStatements1.js index 506e7e6a33071..47df08d46baa5 100644 --- a/tests/baselines/reference/ifElseWithStatements1.js +++ b/tests/baselines/reference/ifElseWithStatements1.js @@ -1,4 +1,5 @@ //// [ifElseWithStatements1.ts] + if (true) f(); else diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.errors.txt b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.errors.txt index 99819ecad2c96..bab58d0e4cf5f 100644 --- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.errors.txt +++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.errors.txt @@ -1,7 +1,8 @@ -tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts(1,10): error TS2354: No best common type exists among return expressions. +tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts(2,10): error TS2354: No best common type exists among return expressions. ==== tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts (1 errors) ==== + function foo() { ~~~ !!! error TS2354: No best common type exists among return expressions. diff --git a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js index ba528d4c133eb..2993a331fee3f 100644 --- a/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js +++ b/tests/baselines/reference/inferredFunctionReturnTypeIsEmptyType.js @@ -1,4 +1,5 @@ //// [inferredFunctionReturnTypeIsEmptyType.ts] + function foo() { if (true) { return 42; diff --git a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt index 08aab5b1158c5..787b95f22976d 100644 --- a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt +++ b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.errors.txt @@ -1,8 +1,9 @@ -tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(2,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(5,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(3,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. +tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts(6,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ==== tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts (2 errors) ==== + class a { static get x(): () => string { ~ diff --git a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js index b81b6cd1d789d..fa9c6e2a8b531 100644 --- a/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js +++ b/tests/baselines/reference/inheritanceStaticPropertyOverridingAccessor.js @@ -1,4 +1,5 @@ //// [inheritanceStaticPropertyOverridingAccessor.ts] + class a { static get x(): () => string { return null;; diff --git a/tests/baselines/reference/interfaceExtendingClass2.errors.txt b/tests/baselines/reference/interfaceExtendingClass2.errors.txt index 3b394d4922ab7..859cb65410eef 100644 --- a/tests/baselines/reference/interfaceExtendingClass2.errors.txt +++ b/tests/baselines/reference/interfaceExtendingClass2.errors.txt @@ -1,10 +1,11 @@ -tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(11,5): error TS2411: Property 'a' of type '{ toString: () => {}; }' is not assignable to string index type 'Object'. -tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(13,13): error TS1131: Property or signature expected. -tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(14,9): error TS1128: Declaration or statement expected. -tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(15,5): error TS1128: Declaration or statement expected. +tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(12,5): error TS2411: Property 'a' of type '{ toString: () => {}; }' is not assignable to string index type 'Object'. +tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(14,13): error TS1131: Property or signature expected. +tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(15,9): error TS1128: Declaration or statement expected. +tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts(16,5): error TS1128: Declaration or statement expected. ==== tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts (4 errors) ==== + class Foo { x: string; y() { } diff --git a/tests/baselines/reference/interfaceExtendingClass2.js b/tests/baselines/reference/interfaceExtendingClass2.js index 6e6605e245956..c4143659125c7 100644 --- a/tests/baselines/reference/interfaceExtendingClass2.js +++ b/tests/baselines/reference/interfaceExtendingClass2.js @@ -1,4 +1,5 @@ //// [interfaceExtendingClass2.ts] + class Foo { x: string; y() { } diff --git a/tests/baselines/reference/interfaceWithPrivateMember.errors.txt b/tests/baselines/reference/interfaceWithPrivateMember.errors.txt index 7f2542b45a11c..dc1cfeabed5e3 100644 --- a/tests/baselines/reference/interfaceWithPrivateMember.errors.txt +++ b/tests/baselines/reference/interfaceWithPrivateMember.errors.txt @@ -1,11 +1,12 @@ -tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(4,5): error TS1131: Property or signature expected. -tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(8,5): error TS1131: Property or signature expected. -tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(12,5): error TS1131: Property or signature expected. -tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(12,16): error TS2304: Cannot find name 'string'. -tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(13,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(5,5): error TS1131: Property or signature expected. +tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(9,5): error TS1131: Property or signature expected. +tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(13,5): error TS1131: Property or signature expected. +tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(13,16): error TS2304: Cannot find name 'string'. +tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts(14,1): error TS1128: Declaration or statement expected. ==== tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts (5 errors) ==== + // interfaces do not permit private members, these are errors interface I { diff --git a/tests/baselines/reference/interfaceWithPrivateMember.js b/tests/baselines/reference/interfaceWithPrivateMember.js index 24c2cf9ecf55c..ceb388b1eae26 100644 --- a/tests/baselines/reference/interfaceWithPrivateMember.js +++ b/tests/baselines/reference/interfaceWithPrivateMember.js @@ -1,4 +1,5 @@ //// [interfaceWithPrivateMember.ts] + // interfaces do not permit private members, these are errors interface I { diff --git a/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt b/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt index 65fd55b763baa..15983bd1fc40f 100644 --- a/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt +++ b/tests/baselines/reference/invalidDoWhileBreakStatements.errors.txt @@ -1,12 +1,13 @@ -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(8,4): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(9,4): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts(38,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. ==== tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts (6 errors) ==== + // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidDoWhileBreakStatements.js b/tests/baselines/reference/invalidDoWhileBreakStatements.js index 807d58a8fea44..4f48a890aa658 100644 --- a/tests/baselines/reference/invalidDoWhileBreakStatements.js +++ b/tests/baselines/reference/invalidDoWhileBreakStatements.js @@ -1,4 +1,5 @@ //// [invalidDoWhileBreakStatements.ts] + // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt b/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt index e9643394d1215..3a520209293e5 100644 --- a/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt +++ b/tests/baselines/reference/invalidDoWhileContinueStatements.errors.txt @@ -1,12 +1,13 @@ -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(8,4): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(9,4): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. ==== tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts (6 errors) ==== + // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidDoWhileContinueStatements.js b/tests/baselines/reference/invalidDoWhileContinueStatements.js index 21a10a3451bb5..b77259159a9dc 100644 --- a/tests/baselines/reference/invalidDoWhileContinueStatements.js +++ b/tests/baselines/reference/invalidDoWhileContinueStatements.js @@ -1,4 +1,5 @@ //// [invalidDoWhileContinueStatements.ts] + // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidForBreakStatements.errors.txt b/tests/baselines/reference/invalidForBreakStatements.errors.txt index 50e4013c0eac4..57ae1d32c8e50 100644 --- a/tests/baselines/reference/invalidForBreakStatements.errors.txt +++ b/tests/baselines/reference/invalidForBreakStatements.errors.txt @@ -1,12 +1,13 @@ -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(8,9): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(36,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(9,9): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. ==== tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts (6 errors) ==== + // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidForBreakStatements.js b/tests/baselines/reference/invalidForBreakStatements.js index 5e3430ecb417d..50096e1672029 100644 --- a/tests/baselines/reference/invalidForBreakStatements.js +++ b/tests/baselines/reference/invalidForBreakStatements.js @@ -1,4 +1,5 @@ //// [invalidForBreakStatements.ts] + // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidForContinueStatements.errors.txt b/tests/baselines/reference/invalidForContinueStatements.errors.txt index 3af47370df156..9ebfae57e9f70 100644 --- a/tests/baselines/reference/invalidForContinueStatements.errors.txt +++ b/tests/baselines/reference/invalidForContinueStatements.errors.txt @@ -1,12 +1,13 @@ -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(8,9): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(36,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(9,9): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. ==== tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts (6 errors) ==== + // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidForContinueStatements.js b/tests/baselines/reference/invalidForContinueStatements.js index 2db1ce69ede00..7a3513bb2a394 100644 --- a/tests/baselines/reference/invalidForContinueStatements.js +++ b/tests/baselines/reference/invalidForContinueStatements.js @@ -1,4 +1,5 @@ //// [invalidForContinueStatements.ts] + // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidForInBreakStatements.errors.txt b/tests/baselines/reference/invalidForInBreakStatements.errors.txt index d83304ab1c674..b1f5d64f973e9 100644 --- a/tests/baselines/reference/invalidForInBreakStatements.errors.txt +++ b/tests/baselines/reference/invalidForInBreakStatements.errors.txt @@ -1,12 +1,13 @@ -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(8,19): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(5,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(9,19): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(28,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts(38,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. ==== tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts (6 errors) ==== + // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidForInBreakStatements.js b/tests/baselines/reference/invalidForInBreakStatements.js index 1784b9a57a61d..11517f2a02027 100644 --- a/tests/baselines/reference/invalidForInBreakStatements.js +++ b/tests/baselines/reference/invalidForInBreakStatements.js @@ -1,4 +1,5 @@ //// [invalidForInBreakStatements.ts] + // All errors // naked break not allowed diff --git a/tests/baselines/reference/invalidForInContinueStatements.errors.txt b/tests/baselines/reference/invalidForInContinueStatements.errors.txt index 7353a22d9cd8a..f20d9c6e81c6b 100644 --- a/tests/baselines/reference/invalidForInContinueStatements.errors.txt +++ b/tests/baselines/reference/invalidForInContinueStatements.errors.txt @@ -1,12 +1,13 @@ -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(8,19): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(9,19): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. ==== tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts (6 errors) ==== + // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidForInContinueStatements.js b/tests/baselines/reference/invalidForInContinueStatements.js index 94020d00f2b50..5eb0e10bf5361 100644 --- a/tests/baselines/reference/invalidForInContinueStatements.js +++ b/tests/baselines/reference/invalidForInContinueStatements.js @@ -1,4 +1,5 @@ //// [invalidForInContinueStatements.ts] + // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidReturnStatements.errors.txt b/tests/baselines/reference/invalidReturnStatements.errors.txt index 780166e07c24b..6fbe961cd54ef 100644 --- a/tests/baselines/reference/invalidReturnStatements.errors.txt +++ b/tests/baselines/reference/invalidReturnStatements.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(2,17): 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/conformance/statements/returnStatements/invalidReturnStatements.ts(3,17): 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/conformance/statements/returnStatements/invalidReturnStatements.ts(4,17): 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/conformance/statements/returnStatements/invalidReturnStatements.ts(5,17): 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/conformance/statements/returnStatements/invalidReturnStatements.ts(2,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(3,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(4,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(5,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(16,29): error TS2322: Type '{ id: number; }' is not assignable to type 'D'. Property 'name' is missing in type '{ id: number; }'. tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(18,29): error TS2322: Type 'C' is not assignable to type 'D'. @@ -12,16 +12,16 @@ tests/cases/conformance/statements/returnStatements/invalidReturnStatements.ts(1 // all the following should be error function fn1(): number { } ~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. function fn2(): string { } ~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. function fn3(): boolean { } ~~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. function fn4(): Date { } ~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. function fn7(): any { } // should be valid: any includes void interface I { id: number } diff --git a/tests/baselines/reference/invalidThrowStatement.errors.txt b/tests/baselines/reference/invalidThrowStatement.errors.txt index b30549a217c27..3002bce2f1f34 100644 --- a/tests/baselines/reference/invalidThrowStatement.errors.txt +++ b/tests/baselines/reference/invalidThrowStatement.errors.txt @@ -1,8 +1,9 @@ -tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(1,6): error TS1109: Expression expected. -tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(3,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(2,6): error TS1109: Expression expected. +tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts(4,1): error TS1128: Declaration or statement expected. ==== tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts (2 errors) ==== + throw; ~ !!! error TS1109: Expression expected. diff --git a/tests/baselines/reference/invalidThrowStatement.js b/tests/baselines/reference/invalidThrowStatement.js index 4b794ab3d517a..674dacf5c17fc 100644 --- a/tests/baselines/reference/invalidThrowStatement.js +++ b/tests/baselines/reference/invalidThrowStatement.js @@ -1,4 +1,5 @@ //// [invalidThrowStatement.ts] + throw; export throw null; diff --git a/tests/baselines/reference/invalidWhileBreakStatements.errors.txt b/tests/baselines/reference/invalidWhileBreakStatements.errors.txt index 54adc2856d7ef..7d4f86b3e9d15 100644 --- a/tests/baselines/reference/invalidWhileBreakStatements.errors.txt +++ b/tests/baselines/reference/invalidWhileBreakStatements.errors.txt @@ -1,12 +1,14 @@ tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(4,1): error TS1105: A 'break' statement can only be used within an enclosing iteration or switch statement. +tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(7,1): error TS7028: Unused label. tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(8,14): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. +tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(11,1): error TS7027: Unreachable code detected. tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(27,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts(37,5): error TS1116: A 'break' statement can only jump to a label of an enclosing statement. -==== tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts (6 errors) ==== +==== tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.ts (8 errors) ==== // All errors // naked break not allowed @@ -16,12 +18,16 @@ tests/cases/conformance/statements/breakStatements/invalidWhileBreakStatements.t // non-existent label ONE: + ~~~ +!!! error TS7028: Unused label. while (true) break TWO; ~~~~~~~~~~ !!! error TS1116: A 'break' statement can only jump to a label of an enclosing statement. // break from inside function TWO: + ~~~ +!!! error TS7027: Unreachable code detected. while (true){ var x = () => { break TWO; diff --git a/tests/baselines/reference/invalidWhileContinueStatements.errors.txt b/tests/baselines/reference/invalidWhileContinueStatements.errors.txt index 462b244efd43a..e7a9ed13c4033 100644 --- a/tests/baselines/reference/invalidWhileContinueStatements.errors.txt +++ b/tests/baselines/reference/invalidWhileContinueStatements.errors.txt @@ -1,12 +1,13 @@ -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(4,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(8,14): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(14,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(21,9): error TS1107: Jump target cannot cross function boundary. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(27,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. -tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(37,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(5,1): error TS1104: A 'continue' statement can only be used within an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(9,14): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(15,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(22,9): error TS1107: Jump target cannot cross function boundary. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(28,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. +tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts(38,5): error TS1115: A 'continue' statement can only jump to a label of an enclosing iteration statement. ==== tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts (6 errors) ==== + // All errors // naked continue not allowed diff --git a/tests/baselines/reference/invalidWhileContinueStatements.js b/tests/baselines/reference/invalidWhileContinueStatements.js index b8234bf96045c..16350e9b561f0 100644 --- a/tests/baselines/reference/invalidWhileContinueStatements.js +++ b/tests/baselines/reference/invalidWhileContinueStatements.js @@ -1,4 +1,5 @@ //// [invalidWhileContinueStatements.ts] + // All errors // naked continue not allowed diff --git a/tests/baselines/reference/letAndVarRedeclaration.errors.txt b/tests/baselines/reference/letAndVarRedeclaration.errors.txt index 48704f61040d4..50a916e8d9003 100644 --- a/tests/baselines/reference/letAndVarRedeclaration.errors.txt +++ b/tests/baselines/reference/letAndVarRedeclaration.errors.txt @@ -1,28 +1,29 @@ -tests/cases/compiler/letAndVarRedeclaration.ts(2,5): error TS2451: Cannot redeclare block-scoped variable 'e0'. tests/cases/compiler/letAndVarRedeclaration.ts(3,5): error TS2451: Cannot redeclare block-scoped variable 'e0'. -tests/cases/compiler/letAndVarRedeclaration.ts(4,10): error TS2451: Cannot redeclare block-scoped variable 'e0'. -tests/cases/compiler/letAndVarRedeclaration.ts(7,9): error TS2451: Cannot redeclare block-scoped variable 'x1'. +tests/cases/compiler/letAndVarRedeclaration.ts(4,5): error TS2451: Cannot redeclare block-scoped variable 'e0'. +tests/cases/compiler/letAndVarRedeclaration.ts(5,10): error TS2451: Cannot redeclare block-scoped variable 'e0'. tests/cases/compiler/letAndVarRedeclaration.ts(8,9): error TS2451: Cannot redeclare block-scoped variable 'x1'. -tests/cases/compiler/letAndVarRedeclaration.ts(9,14): error TS2451: Cannot redeclare block-scoped variable 'x1'. -tests/cases/compiler/letAndVarRedeclaration.ts(13,9): error TS2451: Cannot redeclare block-scoped variable 'x'. -tests/cases/compiler/letAndVarRedeclaration.ts(15,13): error TS2451: Cannot redeclare block-scoped variable 'x'. -tests/cases/compiler/letAndVarRedeclaration.ts(18,18): error TS2451: Cannot redeclare block-scoped variable 'x'. -tests/cases/compiler/letAndVarRedeclaration.ts(23,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(9,9): error TS2451: Cannot redeclare block-scoped variable 'x1'. +tests/cases/compiler/letAndVarRedeclaration.ts(10,14): error TS2451: Cannot redeclare block-scoped variable 'x1'. +tests/cases/compiler/letAndVarRedeclaration.ts(14,9): error TS2451: Cannot redeclare block-scoped variable 'x'. +tests/cases/compiler/letAndVarRedeclaration.ts(16,13): error TS2451: Cannot redeclare block-scoped variable 'x'. +tests/cases/compiler/letAndVarRedeclaration.ts(19,18): error TS2451: Cannot redeclare block-scoped variable 'x'. tests/cases/compiler/letAndVarRedeclaration.ts(24,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(25,14): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(29,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(31,13): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(34,18): error TS2451: Cannot redeclare block-scoped variable 'x2'. -tests/cases/compiler/letAndVarRedeclaration.ts(38,5): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(39,10): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(43,9): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(44,14): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(49,9): error TS2451: Cannot redeclare block-scoped variable 'x11'. -tests/cases/compiler/letAndVarRedeclaration.ts(50,14): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(25,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(26,14): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(30,9): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(32,13): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(35,18): error TS2451: Cannot redeclare block-scoped variable 'x2'. +tests/cases/compiler/letAndVarRedeclaration.ts(39,5): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(40,10): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(44,9): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(45,14): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(50,9): error TS2451: Cannot redeclare block-scoped variable 'x11'. +tests/cases/compiler/letAndVarRedeclaration.ts(51,14): error TS2451: Cannot redeclare block-scoped variable 'x11'. ==== tests/cases/compiler/letAndVarRedeclaration.ts (21 errors) ==== + let e0 ~~ !!! error TS2451: Cannot redeclare block-scoped variable 'e0'. diff --git a/tests/baselines/reference/letAndVarRedeclaration.js b/tests/baselines/reference/letAndVarRedeclaration.js index fd4bfe67cacd6..eb4dfc9c0e831 100644 --- a/tests/baselines/reference/letAndVarRedeclaration.js +++ b/tests/baselines/reference/letAndVarRedeclaration.js @@ -1,5 +1,6 @@ //// [letAndVarRedeclaration.ts] + let e0 var e0; function e0() { } diff --git a/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt b/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt index 1ece1f31433cd..e46554ec0e636 100644 --- a/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt +++ b/tests/baselines/reference/letDeclarations-invalidContexts.errors.txt @@ -1,16 +1,17 @@ -tests/cases/compiler/letDeclarations-invalidContexts.ts(4,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(6,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(9,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(12,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(16,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'. -tests/cases/compiler/letDeclarations-invalidContexts.ts(20,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(23,5): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(26,12): error TS1157: 'let' declarations can only be declared inside a block. -tests/cases/compiler/letDeclarations-invalidContexts.ts(29,29): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(5,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(7,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(10,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(13,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(17,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'. +tests/cases/compiler/letDeclarations-invalidContexts.ts(21,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(24,5): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(27,12): error TS1157: 'let' declarations can only be declared inside a block. +tests/cases/compiler/letDeclarations-invalidContexts.ts(30,29): error TS1157: 'let' declarations can only be declared inside a block. ==== tests/cases/compiler/letDeclarations-invalidContexts.ts (9 errors) ==== + // Errors, let must be defined inside a block if (true) let l1 = 0; diff --git a/tests/baselines/reference/letDeclarations-invalidContexts.js b/tests/baselines/reference/letDeclarations-invalidContexts.js index f8c3bb04bdb20..4c3be1faed80c 100644 --- a/tests/baselines/reference/letDeclarations-invalidContexts.js +++ b/tests/baselines/reference/letDeclarations-invalidContexts.js @@ -1,5 +1,6 @@ //// [letDeclarations-invalidContexts.ts] + // Errors, let must be defined inside a block if (true) let l1 = 0; diff --git a/tests/baselines/reference/letDeclarations-scopes.errors.txt b/tests/baselines/reference/letDeclarations-scopes.errors.txt index 5c89ea98049a6..1b10903af7c6f 100644 --- a/tests/baselines/reference/letDeclarations-scopes.errors.txt +++ b/tests/baselines/reference/letDeclarations-scopes.errors.txt @@ -1,8 +1,9 @@ -tests/cases/compiler/letDeclarations-scopes.ts(28,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'. +tests/cases/compiler/letDeclarations-scopes.ts(29,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'. ==== tests/cases/compiler/letDeclarations-scopes.ts (1 errors) ==== + // global let l = "string"; diff --git a/tests/baselines/reference/letDeclarations-scopes.js b/tests/baselines/reference/letDeclarations-scopes.js index d0489820d0b90..3fc5976b4b700 100644 --- a/tests/baselines/reference/letDeclarations-scopes.js +++ b/tests/baselines/reference/letDeclarations-scopes.js @@ -1,5 +1,6 @@ //// [letDeclarations-scopes.ts] + // global let l = "string"; diff --git a/tests/baselines/reference/letDeclarations-validContexts.errors.txt b/tests/baselines/reference/letDeclarations-validContexts.errors.txt index 3f3b7a2634f09..acec026daf06f 100644 --- a/tests/baselines/reference/letDeclarations-validContexts.errors.txt +++ b/tests/baselines/reference/letDeclarations-validContexts.errors.txt @@ -1,9 +1,10 @@ -tests/cases/compiler/letDeclarations-validContexts.ts(20,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'. +tests/cases/compiler/letDeclarations-validContexts.ts(21,7): error TS2410: All symbols within a 'with' block will be resolved to 'any'. ==== tests/cases/compiler/letDeclarations-validContexts.ts (1 errors) ==== + // Control flow statements with blocks if (true) { let l1 = 0; diff --git a/tests/baselines/reference/letDeclarations-validContexts.js b/tests/baselines/reference/letDeclarations-validContexts.js index b11a19223836d..1859a0215bb21 100644 --- a/tests/baselines/reference/letDeclarations-validContexts.js +++ b/tests/baselines/reference/letDeclarations-validContexts.js @@ -1,6 +1,7 @@ //// [letDeclarations-validContexts.ts] + // Control flow statements with blocks if (true) { let l1 = 0; diff --git a/tests/baselines/reference/localTypes4.errors.txt b/tests/baselines/reference/localTypes4.errors.txt index cad9d30c933b0..4d08644ea89c8 100644 --- a/tests/baselines/reference/localTypes4.errors.txt +++ b/tests/baselines/reference/localTypes4.errors.txt @@ -1,10 +1,11 @@ -tests/cases/conformance/types/localTypes/localTypes4.ts(10,19): error TS2304: Cannot find name 'T'. -tests/cases/conformance/types/localTypes/localTypes4.ts(10,23): error TS2304: Cannot find name 'T'. -tests/cases/conformance/types/localTypes/localTypes4.ts(18,16): error TS2300: Duplicate identifier 'T'. -tests/cases/conformance/types/localTypes/localTypes4.ts(19,19): error TS2300: Duplicate identifier 'T'. +tests/cases/conformance/types/localTypes/localTypes4.ts(11,19): error TS2304: Cannot find name 'T'. +tests/cases/conformance/types/localTypes/localTypes4.ts(11,23): error TS2304: Cannot find name 'T'. +tests/cases/conformance/types/localTypes/localTypes4.ts(19,16): error TS2300: Duplicate identifier 'T'. +tests/cases/conformance/types/localTypes/localTypes4.ts(20,19): error TS2300: Duplicate identifier 'T'. ==== tests/cases/conformance/types/localTypes/localTypes4.ts (4 errors) ==== + function f1() { // Type parameters are in scope in parameters and return types function f(x: T): T { diff --git a/tests/baselines/reference/localTypes4.js b/tests/baselines/reference/localTypes4.js index 8f51761a65af6..3b81175d2b620 100644 --- a/tests/baselines/reference/localTypes4.js +++ b/tests/baselines/reference/localTypes4.js @@ -1,4 +1,5 @@ //// [localTypes4.ts] + function f1() { // Type parameters are in scope in parameters and return types function f(x: T): T { diff --git a/tests/baselines/reference/methodInAmbientClass1.errors.txt b/tests/baselines/reference/methodInAmbientClass1.errors.txt index 2badd839270b7..c931cc0101c81 100644 --- a/tests/baselines/reference/methodInAmbientClass1.errors.txt +++ b/tests/baselines/reference/methodInAmbientClass1.errors.txt @@ -1,4 +1,4 @@ -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,12): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. tests/cases/compiler/methodInAmbientClass1.ts(2,20): error TS1183: An implementation cannot be declared in ambient contexts. @@ -6,7 +6,7 @@ tests/cases/compiler/methodInAmbientClass1.ts(2,20): error TS1183: An implementa declare class Foo { fn(): boolean { ~~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. ~ !!! error TS1183: An implementation cannot be declared in ambient contexts. } diff --git a/tests/baselines/reference/missingReturnStatement.errors.txt b/tests/baselines/reference/missingReturnStatement.errors.txt index c7cedd793de79..8926d22be3d42 100644 --- a/tests/baselines/reference/missingReturnStatement.errors.txt +++ b/tests/baselines/reference/missingReturnStatement.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/missingReturnStatement.ts(3,22): 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/missingReturnStatement.ts(3,22): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. ==== tests/cases/compiler/missingReturnStatement.ts (1 errors) ==== @@ -6,7 +6,7 @@ tests/cases/compiler/missingReturnStatement.ts(3,22): error TS2355: A function w export class Bug { public foo():string { ~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. } } } diff --git a/tests/baselines/reference/missingReturnStatement1.errors.txt b/tests/baselines/reference/missingReturnStatement1.errors.txt index de471f90ac4db..9d3cf78411edf 100644 --- a/tests/baselines/reference/missingReturnStatement1.errors.txt +++ b/tests/baselines/reference/missingReturnStatement1.errors.txt @@ -1,11 +1,11 @@ -tests/cases/compiler/missingReturnStatement1.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/missingReturnStatement1.ts(2,12): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. ==== tests/cases/compiler/missingReturnStatement1.ts (1 errors) ==== class Foo { foo(): number { ~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. //return 4; } } diff --git a/tests/baselines/reference/multiLineErrors.errors.txt b/tests/baselines/reference/multiLineErrors.errors.txt index 23a6278b4fbbf..70366aeabedcd 100644 --- a/tests/baselines/reference/multiLineErrors.errors.txt +++ b/tests/baselines/reference/multiLineErrors.errors.txt @@ -1,4 +1,4 @@ -tests/cases/compiler/multiLineErrors.ts(3,22): 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/multiLineErrors.ts(3,22): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. tests/cases/compiler/multiLineErrors.ts(21,1): error TS2322: Type 'A2' is not assignable to type 'A1'. Types of property 'x' are incompatible. Type '{ y: string; }' is not assignable to type '{ y: number; }'. @@ -17,7 +17,7 @@ tests/cases/compiler/multiLineErrors.ts(21,1): error TS2322: Type 'A2' is not as ~~~~~~~~~~~~~~ } ~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. { var x = 4; var y = 10; diff --git a/tests/baselines/reference/null.js b/tests/baselines/reference/null.js index 499d6901847b4..ee897643fb172 100644 --- a/tests/baselines/reference/null.js +++ b/tests/baselines/reference/null.js @@ -1,4 +1,5 @@ //// [null.ts] + var x=null; var y=3+x; var z=3+null; diff --git a/tests/baselines/reference/null.symbols b/tests/baselines/reference/null.symbols index 148cd1586b275..bd3d835995b57 100644 --- a/tests/baselines/reference/null.symbols +++ b/tests/baselines/reference/null.symbols @@ -1,44 +1,45 @@ === tests/cases/compiler/null.ts === + var x=null; ->x : Symbol(x, Decl(null.ts, 0, 3)) +>x : Symbol(x, Decl(null.ts, 1, 3)) var y=3+x; ->y : Symbol(y, Decl(null.ts, 1, 3)) ->x : Symbol(x, Decl(null.ts, 0, 3)) +>y : Symbol(y, Decl(null.ts, 2, 3)) +>x : Symbol(x, Decl(null.ts, 1, 3)) var z=3+null; ->z : Symbol(z, Decl(null.ts, 2, 3)) +>z : Symbol(z, Decl(null.ts, 3, 3)) class C { ->C : Symbol(C, Decl(null.ts, 2, 13)) +>C : Symbol(C, Decl(null.ts, 3, 13)) } function f() { ->f : Symbol(f, Decl(null.ts, 4, 1)) +>f : Symbol(f, Decl(null.ts, 5, 1)) return null; return new C(); ->C : Symbol(C, Decl(null.ts, 2, 13)) +>C : Symbol(C, Decl(null.ts, 3, 13)) } function g() { ->g : Symbol(g, Decl(null.ts, 8, 1)) +>g : Symbol(g, Decl(null.ts, 9, 1)) return null; return 3; } interface I { ->I : Symbol(I, Decl(null.ts, 12, 1)) +>I : Symbol(I, Decl(null.ts, 13, 1)) x:any; ->x : Symbol(x, Decl(null.ts, 13, 13)) +>x : Symbol(x, Decl(null.ts, 14, 13)) y:number; ->y : Symbol(y, Decl(null.ts, 14, 10)) +>y : Symbol(y, Decl(null.ts, 15, 10)) } var w:I={x:null,y:3}; ->w : Symbol(w, Decl(null.ts, 17, 3)) ->I : Symbol(I, Decl(null.ts, 12, 1)) ->x : Symbol(x, Decl(null.ts, 17, 9)) ->y : Symbol(y, Decl(null.ts, 17, 16)) +>w : Symbol(w, Decl(null.ts, 18, 3)) +>I : Symbol(I, Decl(null.ts, 13, 1)) +>x : Symbol(x, Decl(null.ts, 18, 9)) +>y : Symbol(y, Decl(null.ts, 18, 16)) diff --git a/tests/baselines/reference/null.types b/tests/baselines/reference/null.types index 7df551b1bde23..6fd8b423f1381 100644 --- a/tests/baselines/reference/null.types +++ b/tests/baselines/reference/null.types @@ -1,4 +1,5 @@ === tests/cases/compiler/null.ts === + var x=null; >x : any >null : null diff --git a/tests/baselines/reference/objectLiteralMemberWithModifiers2.errors.txt b/tests/baselines/reference/objectLiteralMemberWithModifiers2.errors.txt index e939725ea6e46..be2bea5e24130 100644 --- a/tests/baselines/reference/objectLiteralMemberWithModifiers2.errors.txt +++ b/tests/baselines/reference/objectLiteralMemberWithModifiers2.errors.txt @@ -1,5 +1,5 @@ tests/cases/compiler/objectLiteralMemberWithModifiers2.ts(1,22): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/compiler/objectLiteralMemberWithModifiers2.ts(1,22): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/compiler/objectLiteralMemberWithModifiers2.ts(1,22): error TS2378: A 'get' accessor must return a value. ==== tests/cases/compiler/objectLiteralMemberWithModifiers2.ts (2 errors) ==== @@ -7,4 +7,4 @@ tests/cases/compiler/objectLiteralMemberWithModifiers2.ts(1,22): error TS2378: A ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. \ No newline at end of file +!!! error TS2378: A 'get' accessor must return a value. \ No newline at end of file diff --git a/tests/baselines/reference/objectLiteralWithSemicolons5.errors.txt b/tests/baselines/reference/objectLiteralWithSemicolons5.errors.txt index 7373c3d535de2..5a24f29252cee 100644 --- a/tests/baselines/reference/objectLiteralWithSemicolons5.errors.txt +++ b/tests/baselines/reference/objectLiteralWithSemicolons5.errors.txt @@ -1,7 +1,7 @@ tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,20): error TS1005: ',' expected. tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,25): error TS2304: Cannot find name 'b'. tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,26): error TS1005: ',' expected. -tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,32): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,32): error TS2378: A 'get' accessor must return a value. tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,41): error TS1005: ',' expected. @@ -14,6 +14,6 @@ tests/cases/compiler/objectLiteralWithSemicolons5.ts(1,41): error TS1005: ',' ex ~ !!! error TS1005: ',' expected. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. ~ !!! error TS1005: ',' expected. \ No newline at end of file diff --git a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.errors.txt b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.errors.txt index 079951880ab75..a78e0c8abcfaf 100644 --- a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.errors.txt +++ b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.errors.txt @@ -1,8 +1,9 @@ -tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(1,8): error TS2382: Specialized overload signature is not assignable to any non-specialized signature. -tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(1,37): error TS1005: ';' expected. +tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(2,8): error TS2382: Specialized overload signature is not assignable to any non-specialized signature. +tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts(2,37): error TS1005: ';' expected. ==== tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts (2 errors) ==== + var f: (x: 'hi') => number = ('hi') => { return 1; }; ~~~~~~~~~~~~~~~~~~~ !!! error TS2382: Specialized overload signature is not assignable to any non-specialized signature. diff --git a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js index 48e52ba096764..aa5c8701f2881 100644 --- a/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js +++ b/tests/baselines/reference/overloadOnConstAsTypeAnnotation.js @@ -1,4 +1,5 @@ //// [overloadOnConstAsTypeAnnotation.ts] + var f: (x: 'hi') => number = ('hi') => { return 1; }; //// [overloadOnConstAsTypeAnnotation.js] diff --git a/tests/baselines/reference/parser10.1.1-8gs.errors.txt b/tests/baselines/reference/parser10.1.1-8gs.errors.txt index 185665d23daac..3426ccab8da0c 100644 --- a/tests/baselines/reference/parser10.1.1-8gs.errors.txt +++ b/tests/baselines/reference/parser10.1.1-8gs.errors.txt @@ -1,8 +1,9 @@ -tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(16,7): error TS2304: Cannot find name 'NotEarlyError'. -tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(17,5): error TS1212: Identifier expected. 'public' is a reserved word in strict mode +tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(17,7): error TS2304: Cannot find name 'NotEarlyError'. +tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts(18,5): error TS1212: Identifier expected. 'public' is a reserved word in strict mode ==== tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts (2 errors) ==== + /// Copyright (c) 2012 Ecma International. All rights reserved. /// Ecma International makes this code available under the terms and conditions set /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the diff --git a/tests/baselines/reference/parser10.1.1-8gs.js b/tests/baselines/reference/parser10.1.1-8gs.js index e7d342cf1f105..fb3b96f6baffb 100644 --- a/tests/baselines/reference/parser10.1.1-8gs.js +++ b/tests/baselines/reference/parser10.1.1-8gs.js @@ -1,4 +1,5 @@ //// [parser10.1.1-8gs.ts] + /// Copyright (c) 2012 Ecma International. All rights reserved. /// Ecma International makes this code available under the terms and conditions set /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the diff --git a/tests/baselines/reference/parser768531.js b/tests/baselines/reference/parser768531.js index 26e22117717b1..462db3742b30a 100644 --- a/tests/baselines/reference/parser768531.js +++ b/tests/baselines/reference/parser768531.js @@ -1,4 +1,5 @@ //// [parser768531.ts] + {a: 3} /x/ diff --git a/tests/baselines/reference/parser768531.symbols b/tests/baselines/reference/parser768531.symbols index 2da2298c8e207..f180922c7e081 100644 --- a/tests/baselines/reference/parser768531.symbols +++ b/tests/baselines/reference/parser768531.symbols @@ -1,4 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts === -{a: 3} + +No type information for this code.{a: 3} No type information for this code./x/ No type information for this code. \ No newline at end of file diff --git a/tests/baselines/reference/parser768531.types b/tests/baselines/reference/parser768531.types index f1bcedefae9be..434535b5cc9e2 100644 --- a/tests/baselines/reference/parser768531.types +++ b/tests/baselines/reference/parser768531.types @@ -1,4 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts === + {a: 3} >a : any >3 : number diff --git a/tests/baselines/reference/parserAccessors1.errors.txt b/tests/baselines/reference/parserAccessors1.errors.txt index 8c5033da0c453..2ef8d4e37aba0 100644 --- a/tests/baselines/reference/parserAccessors1.errors.txt +++ b/tests/baselines/reference/parserAccessors1.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors1.ts(2,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors1.ts(2,9): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors1.ts (1 errors) ==== class C { get Foo() { } ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } \ No newline at end of file diff --git a/tests/baselines/reference/parserAccessors10.errors.txt b/tests/baselines/reference/parserAccessors10.errors.txt index a5228f4744337..d6a2b99eacaae 100644 --- a/tests/baselines/reference/parserAccessors10.errors.txt +++ b/tests/baselines/reference/parserAccessors10.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors10.ts(2,14): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors10.ts(2,14): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors10.ts (1 errors) ==== var v = { public get foo() { } ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. }; \ No newline at end of file diff --git a/tests/baselines/reference/parserAccessors3.errors.txt b/tests/baselines/reference/parserAccessors3.errors.txt index 2987b606451c6..5411cd544ebd2 100644 --- a/tests/baselines/reference/parserAccessors3.errors.txt +++ b/tests/baselines/reference/parserAccessors3.errors.txt @@ -1,7 +1,7 @@ -tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors3.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors3.ts(1,15): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors3.ts (1 errors) ==== var v = { get Foo() { } }; ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. \ No newline at end of file +!!! error TS2378: A 'get' accessor must return a value. \ No newline at end of file diff --git a/tests/baselines/reference/parserAccessors7.errors.txt b/tests/baselines/reference/parserAccessors7.errors.txt index 857833a7673e3..3938280e6d5f7 100644 --- a/tests/baselines/reference/parserAccessors7.errors.txt +++ b/tests/baselines/reference/parserAccessors7.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors7.ts(1,15): error TS1054: A 'get' accessor cannot have parameters. -tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors7.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors7.ts(1,15): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors7.ts (2 errors) ==== @@ -7,4 +7,4 @@ tests/cases/conformance/parser/ecmascript5/Accessors/parserAccessors7.ts(1,15): ~~~ !!! error TS1054: A 'get' accessor cannot have parameters. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. \ No newline at end of file +!!! error TS2378: A 'get' accessor must return a value. \ No newline at end of file diff --git a/tests/baselines/reference/parserComputedPropertyName4.errors.txt b/tests/baselines/reference/parserComputedPropertyName4.errors.txt index bfc78b162fd5a..3430e75b82f33 100644 --- a/tests/baselines/reference/parserComputedPropertyName4.errors.txt +++ b/tests/baselines/reference/parserComputedPropertyName4.errors.txt @@ -1,10 +1,10 @@ -tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName4.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName4.ts(1,15): error TS2378: A 'get' accessor must return a value. tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName4.ts(1,16): error TS2304: Cannot find name 'e'. ==== tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName4.ts (2 errors) ==== var v = { get [e]() { } }; ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. ~ !!! error TS2304: Cannot find name 'e'. \ No newline at end of file diff --git a/tests/baselines/reference/parserComputedPropertyName5.errors.txt b/tests/baselines/reference/parserComputedPropertyName5.errors.txt index 07cc6f3a9f000..09c38ecbef512 100644 --- a/tests/baselines/reference/parserComputedPropertyName5.errors.txt +++ b/tests/baselines/reference/parserComputedPropertyName5.errors.txt @@ -1,10 +1,10 @@ -tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName5.ts(1,22): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName5.ts(1,22): error TS2378: A 'get' accessor must return a value. tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName5.ts(1,23): error TS2304: Cannot find name 'e'. ==== tests/cases/conformance/parser/ecmascript6/ComputedPropertyNames/parserComputedPropertyName5.ts (2 errors) ==== var v = { public get [e]() { } }; ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. ~ !!! error TS2304: Cannot find name 'e'. \ No newline at end of file diff --git a/tests/baselines/reference/parserES3Accessors1.errors.txt b/tests/baselines/reference/parserES3Accessors1.errors.txt index 5e2ca9f97bca9..9c6dbf0e76f63 100644 --- a/tests/baselines/reference/parserES3Accessors1.errors.txt +++ b/tests/baselines/reference/parserES3Accessors1.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors1.ts(2,9): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors1.ts(2,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors1.ts(2,9): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors1.ts (2 errors) ==== @@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors1.ts(2,9) ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } \ No newline at end of file diff --git a/tests/baselines/reference/parserES3Accessors3.errors.txt b/tests/baselines/reference/parserES3Accessors3.errors.txt index 6d262e2a85580..70ab3f2072e08 100644 --- a/tests/baselines/reference/parserES3Accessors3.errors.txt +++ b/tests/baselines/reference/parserES3Accessors3.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors3.ts(1,15): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. -tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors3.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors3.ts(1,15): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors3.ts (2 errors) ==== @@ -7,4 +7,4 @@ tests/cases/conformance/parser/ecmascript3/Accessors/parserES3Accessors3.ts(1,15 ~~~ !!! error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. \ No newline at end of file +!!! error TS2378: A 'get' accessor must return a value. \ No newline at end of file diff --git a/tests/baselines/reference/parserES5ComputedPropertyName4.errors.txt b/tests/baselines/reference/parserES5ComputedPropertyName4.errors.txt index cfb12152c9476..854bb36484279 100644 --- a/tests/baselines/reference/parserES5ComputedPropertyName4.errors.txt +++ b/tests/baselines/reference/parserES5ComputedPropertyName4.errors.txt @@ -1,10 +1,10 @@ -tests/cases/conformance/parser/ecmascript5/ComputedPropertyNames/parserES5ComputedPropertyName4.ts(1,15): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/ComputedPropertyNames/parserES5ComputedPropertyName4.ts(1,15): error TS2378: A 'get' accessor must return a value. tests/cases/conformance/parser/ecmascript5/ComputedPropertyNames/parserES5ComputedPropertyName4.ts(1,16): error TS2304: Cannot find name 'e'. ==== tests/cases/conformance/parser/ecmascript5/ComputedPropertyNames/parserES5ComputedPropertyName4.ts (2 errors) ==== var v = { get [e]() { } }; ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. ~ !!! error TS2304: Cannot find name 'e'. \ No newline at end of file diff --git a/tests/baselines/reference/parserErrorRecovery_Block3.errors.txt b/tests/baselines/reference/parserErrorRecovery_Block3.errors.txt index 9d391e39007d9..e6033d05215d9 100644 --- a/tests/baselines/reference/parserErrorRecovery_Block3.errors.txt +++ b/tests/baselines/reference/parserErrorRecovery_Block3.errors.txt @@ -1,18 +1,18 @@ -tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block3.ts(2,18): 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/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block3.ts(2,18): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block3.ts(4,5): error TS1128: Declaration or statement expected. -tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block3.ts(4,18): 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/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block3.ts(4,18): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. ==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block3.ts (3 errors) ==== class C { private a(): boolean { ~~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. private b(): boolean { ~~~~~~~ !!! error TS1128: Declaration or statement expected. ~~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. } } \ No newline at end of file diff --git a/tests/baselines/reference/parserErrorRecovery_ModuleElement1.errors.txt b/tests/baselines/reference/parserErrorRecovery_ModuleElement1.errors.txt index 4b8be3e17ad6e..05b31b7af8e56 100644 --- a/tests/baselines/reference/parserErrorRecovery_ModuleElement1.errors.txt +++ b/tests/baselines/reference/parserErrorRecovery_ModuleElement1.errors.txt @@ -1,13 +1,16 @@ tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ModuleElements/parserErrorRecovery_ModuleElement1.ts(2,1): error TS1128: Declaration or statement expected. +tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ModuleElements/parserErrorRecovery_ModuleElement1.ts(3,1): error TS7027: Unreachable code detected. tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ModuleElements/parserErrorRecovery_ModuleElement1.ts(4,1): error TS1128: Declaration or statement expected. -==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ModuleElements/parserErrorRecovery_ModuleElement1.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ModuleElements/parserErrorRecovery_ModuleElement1.ts (3 errors) ==== return foo; } ~ !!! error TS1128: Declaration or statement expected. return bar; + ~~~~~~ +!!! error TS7027: Unreachable code detected. } ~ !!! error TS1128: Declaration or statement expected. \ No newline at end of file diff --git a/tests/baselines/reference/parserGetAccessorWithTypeParameters1.errors.txt b/tests/baselines/reference/parserGetAccessorWithTypeParameters1.errors.txt index 0cf731cb516f6..09502f6b888e0 100644 --- a/tests/baselines/reference/parserGetAccessorWithTypeParameters1.errors.txt +++ b/tests/baselines/reference/parserGetAccessorWithTypeParameters1.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/parser/ecmascript5/Accessors/parserGetAccessorWithTypeParameters1.ts(2,7): error TS1094: An accessor cannot have type parameters. -tests/cases/conformance/parser/ecmascript5/Accessors/parserGetAccessorWithTypeParameters1.ts(2,7): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/Accessors/parserGetAccessorWithTypeParameters1.ts(2,7): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/Accessors/parserGetAccessorWithTypeParameters1.ts (2 errors) ==== @@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/Accessors/parserGetAccessorWithTypePa ~~~ !!! error TS1094: An accessor cannot have type parameters. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } \ No newline at end of file diff --git a/tests/baselines/reference/parserLabeledStatement1.d.errors.txt b/tests/baselines/reference/parserLabeledStatement1.d.errors.txt index 11de61548a366..2ce51b0bb4c6f 100644 --- a/tests/baselines/reference/parserLabeledStatement1.d.errors.txt +++ b/tests/baselines/reference/parserLabeledStatement1.d.errors.txt @@ -1,11 +1,14 @@ tests/cases/conformance/parser/ecmascript5/Statements/parserLabeledStatement1.d.ts(1,1): error TS1036: Statements are not allowed in ambient contexts. +tests/cases/conformance/parser/ecmascript5/Statements/parserLabeledStatement1.d.ts(1,1): error TS7028: Unused label. tests/cases/conformance/parser/ecmascript5/Statements/parserLabeledStatement1.d.ts(2,3): error TS2304: Cannot find name 'bar'. -==== tests/cases/conformance/parser/ecmascript5/Statements/parserLabeledStatement1.d.ts (2 errors) ==== +==== tests/cases/conformance/parser/ecmascript5/Statements/parserLabeledStatement1.d.ts (3 errors) ==== foo: ~~~ !!! error TS1036: Statements are not allowed in ambient contexts. + ~~~ +!!! error TS7028: Unused label. bar(); ~~~ !!! error TS2304: Cannot find name 'bar'. \ No newline at end of file diff --git a/tests/baselines/reference/parserMemberAccessor1.errors.txt b/tests/baselines/reference/parserMemberAccessor1.errors.txt index aa7cdcdafa3c0..2a3fd7d70284d 100644 --- a/tests/baselines/reference/parserMemberAccessor1.errors.txt +++ b/tests/baselines/reference/parserMemberAccessor1.errors.txt @@ -1,10 +1,10 @@ -tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessor1.ts(2,7): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessor1.ts(2,7): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessor1.ts (1 errors) ==== class C { get foo() { } ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. set foo(a) { } } \ No newline at end of file diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration1.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration1.errors.txt index ac96e7d94b788..c2db31a53984e 100644 --- a/tests/baselines/reference/parserMemberAccessorDeclaration1.errors.txt +++ b/tests/baselines/reference/parserMemberAccessorDeclaration1.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration1.ts(2,7): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration1.ts(2,7): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration1.ts (1 errors) ==== class C { get a() { } ~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } \ No newline at end of file diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration10.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration10.errors.txt index 9a04674d6d7f9..ece110db165f3 100644 --- a/tests/baselines/reference/parserMemberAccessorDeclaration10.errors.txt +++ b/tests/baselines/reference/parserMemberAccessorDeclaration10.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration10.ts(2,5): error TS1031: 'export' modifier cannot appear on a class element. -tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration10.ts(2,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration10.ts(2,16): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration10.ts (2 errors) ==== @@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemb ~~~~~~ !!! error TS1031: 'export' modifier cannot appear on a class element. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } \ No newline at end of file diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration12.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration12.errors.txt index 0d14a2adab842..a4ea29518d101 100644 --- a/tests/baselines/reference/parserMemberAccessorDeclaration12.errors.txt +++ b/tests/baselines/reference/parserMemberAccessorDeclaration12.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration12.ts(2,8): error TS1054: A 'get' accessor cannot have parameters. -tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration12.ts(2,8): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration12.ts(2,8): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration12.ts (2 errors) ==== @@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemb ~~~ !!! error TS1054: A 'get' accessor cannot have parameters. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } \ No newline at end of file diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration2.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration2.errors.txt index 69e87dff6590b..7b66bee844f16 100644 --- a/tests/baselines/reference/parserMemberAccessorDeclaration2.errors.txt +++ b/tests/baselines/reference/parserMemberAccessorDeclaration2.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration2.ts(2,7): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration2.ts(2,7): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration2.ts (1 errors) ==== class C { get "b"() { } ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } \ No newline at end of file diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration3.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration3.errors.txt index 93a1a5d14e1fd..a37fe230f76b6 100644 --- a/tests/baselines/reference/parserMemberAccessorDeclaration3.errors.txt +++ b/tests/baselines/reference/parserMemberAccessorDeclaration3.errors.txt @@ -1,9 +1,9 @@ -tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration3.ts(2,7): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration3.ts(2,7): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration3.ts (1 errors) ==== class C { get 0() { } ~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } \ No newline at end of file diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration7.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration7.errors.txt index b7f67da49b7d1..2b0bd40a4f25d 100644 --- a/tests/baselines/reference/parserMemberAccessorDeclaration7.errors.txt +++ b/tests/baselines/reference/parserMemberAccessorDeclaration7.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration7.ts(2,12): error TS1028: Accessibility modifier already seen. -tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration7.ts(2,23): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration7.ts(2,23): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration7.ts (2 errors) ==== @@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemb ~~~~~~ !!! error TS1028: Accessibility modifier already seen. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } \ No newline at end of file diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration8.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration8.errors.txt index e5a39c149f604..67ba09b8c725e 100644 --- a/tests/baselines/reference/parserMemberAccessorDeclaration8.errors.txt +++ b/tests/baselines/reference/parserMemberAccessorDeclaration8.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration8.ts(2,12): error TS1030: 'static' modifier already seen. -tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration8.ts(2,23): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration8.ts(2,23): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration8.ts (2 errors) ==== @@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemb ~~~~~~ !!! error TS1030: 'static' modifier already seen. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } \ No newline at end of file diff --git a/tests/baselines/reference/parserMemberAccessorDeclaration9.errors.txt b/tests/baselines/reference/parserMemberAccessorDeclaration9.errors.txt index 2da32a5807bd2..31d001aeafc62 100644 --- a/tests/baselines/reference/parserMemberAccessorDeclaration9.errors.txt +++ b/tests/baselines/reference/parserMemberAccessorDeclaration9.errors.txt @@ -1,5 +1,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration9.ts(2,12): error TS1029: 'public' modifier must precede 'static' modifier. -tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration9.ts(2,23): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration9.ts(2,23): error TS2378: A 'get' accessor must return a value. ==== tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemberAccessorDeclaration9.ts (2 errors) ==== @@ -8,5 +8,5 @@ tests/cases/conformance/parser/ecmascript5/MemberAccessorDeclarations/parserMemb ~~~~~~ !!! error TS1029: 'public' modifier must precede 'static' modifier. ~~~ -!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement. +!!! error TS2378: A 'get' accessor must return a value. } \ No newline at end of file diff --git a/tests/baselines/reference/parserParameterList5.errors.txt b/tests/baselines/reference/parserParameterList5.errors.txt index 231a5bbb16232..5f0899fa1a2a6 100644 --- a/tests/baselines/reference/parserParameterList5.errors.txt +++ b/tests/baselines/reference/parserParameterList5.errors.txt @@ -1,4 +1,4 @@ -tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.ts(1,15): 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/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.ts(1,15): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.ts(1,16): error TS2369: A parameter property is only allowed in a constructor implementation. tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.ts(1,29): error TS2304: Cannot find name 'C'. @@ -6,7 +6,7 @@ tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.t ==== tests/cases/conformance/parser/ecmascript5/ParameterLists/parserParameterList5.ts (3 errors) ==== function A(): (public B) => C { ~~~~~~~~~~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. ~~~~~~~~ !!! error TS2369: A parameter property is only allowed in a constructor implementation. ~ diff --git a/tests/baselines/reference/parser_breakTarget3.js b/tests/baselines/reference/parser_breakTarget3.js index 0eceba87bf8d2..91ba9fb599369 100644 --- a/tests/baselines/reference/parser_breakTarget3.js +++ b/tests/baselines/reference/parser_breakTarget3.js @@ -1,4 +1,5 @@ //// [parser_breakTarget3.ts] + target1: target2: while (true) { diff --git a/tests/baselines/reference/parser_breakTarget3.symbols b/tests/baselines/reference/parser_breakTarget3.symbols index 99ec413987af8..35184471d4d31 100644 --- a/tests/baselines/reference/parser_breakTarget3.symbols +++ b/tests/baselines/reference/parser_breakTarget3.symbols @@ -1,5 +1,6 @@ === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts === -target1: + +No type information for this code.target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. break target1; diff --git a/tests/baselines/reference/parser_breakTarget3.types b/tests/baselines/reference/parser_breakTarget3.types index 7cdcb74d7da9d..b1ce9f8d94dda 100644 --- a/tests/baselines/reference/parser_breakTarget3.types +++ b/tests/baselines/reference/parser_breakTarget3.types @@ -1,4 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts === + target1: >target1 : any diff --git a/tests/baselines/reference/parser_breakTarget4.js b/tests/baselines/reference/parser_breakTarget4.js index c6cadb5efa1af..4516cf3e8f9b1 100644 --- a/tests/baselines/reference/parser_breakTarget4.js +++ b/tests/baselines/reference/parser_breakTarget4.js @@ -1,4 +1,5 @@ //// [parser_breakTarget4.ts] + target1: target2: while (true) { diff --git a/tests/baselines/reference/parser_breakTarget4.symbols b/tests/baselines/reference/parser_breakTarget4.symbols index 042df67d9b282..f4d4b2e4bffd1 100644 --- a/tests/baselines/reference/parser_breakTarget4.symbols +++ b/tests/baselines/reference/parser_breakTarget4.symbols @@ -1,5 +1,6 @@ === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts === -target1: + +No type information for this code.target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. break target2; diff --git a/tests/baselines/reference/parser_breakTarget4.types b/tests/baselines/reference/parser_breakTarget4.types index 7315175800e66..04bb129c9190c 100644 --- a/tests/baselines/reference/parser_breakTarget4.types +++ b/tests/baselines/reference/parser_breakTarget4.types @@ -1,4 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts === + target1: >target1 : any diff --git a/tests/baselines/reference/parser_breakTarget5.errors.txt b/tests/baselines/reference/parser_breakTarget5.errors.txt index 8221cbebb4c70..5943649c97b45 100644 --- a/tests/baselines/reference/parser_breakTarget5.errors.txt +++ b/tests/baselines/reference/parser_breakTarget5.errors.txt @@ -1,8 +1,11 @@ +tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget5.ts(1,1): error TS7028: Unused label. tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary. -==== tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget5.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget5.ts (2 errors) ==== target: + ~~~~~~ +!!! error TS7028: Unused label. while (true) { function f() { while (true) { diff --git a/tests/baselines/reference/parser_continueNotInIterationStatement4.errors.txt b/tests/baselines/reference/parser_continueNotInIterationStatement4.errors.txt index efade17a52a03..9439225956897 100644 --- a/tests/baselines/reference/parser_continueNotInIterationStatement4.errors.txt +++ b/tests/baselines/reference/parser_continueNotInIterationStatement4.errors.txt @@ -1,8 +1,11 @@ +tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueNotInIterationStatement4.ts(1,1): error TS7028: Unused label. tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueNotInIterationStatement4.ts(4,5): error TS1107: Jump target cannot cross function boundary. -==== tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueNotInIterationStatement4.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueNotInIterationStatement4.ts (2 errors) ==== TWO: + ~~~ +!!! error TS7028: Unused label. while (true){ var x = () => { continue TWO; diff --git a/tests/baselines/reference/parser_continueTarget3.js b/tests/baselines/reference/parser_continueTarget3.js index 76a98a0e20428..ea1559346dee2 100644 --- a/tests/baselines/reference/parser_continueTarget3.js +++ b/tests/baselines/reference/parser_continueTarget3.js @@ -1,4 +1,5 @@ //// [parser_continueTarget3.ts] + target1: target2: while (true) { diff --git a/tests/baselines/reference/parser_continueTarget3.symbols b/tests/baselines/reference/parser_continueTarget3.symbols index 2038671d215a6..c522444ca1aef 100644 --- a/tests/baselines/reference/parser_continueTarget3.symbols +++ b/tests/baselines/reference/parser_continueTarget3.symbols @@ -1,5 +1,6 @@ === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts === -target1: + +No type information for this code.target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. continue target1; diff --git a/tests/baselines/reference/parser_continueTarget3.types b/tests/baselines/reference/parser_continueTarget3.types index 33c931c79596a..fd8aedc357f74 100644 --- a/tests/baselines/reference/parser_continueTarget3.types +++ b/tests/baselines/reference/parser_continueTarget3.types @@ -1,4 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts === + target1: >target1 : any diff --git a/tests/baselines/reference/parser_continueTarget4.js b/tests/baselines/reference/parser_continueTarget4.js index 795cab2e2adaa..9ccaaac27e749 100644 --- a/tests/baselines/reference/parser_continueTarget4.js +++ b/tests/baselines/reference/parser_continueTarget4.js @@ -1,4 +1,5 @@ //// [parser_continueTarget4.ts] + target1: target2: while (true) { diff --git a/tests/baselines/reference/parser_continueTarget4.symbols b/tests/baselines/reference/parser_continueTarget4.symbols index 2b47099715ee1..b7e770f9bf9c7 100644 --- a/tests/baselines/reference/parser_continueTarget4.symbols +++ b/tests/baselines/reference/parser_continueTarget4.symbols @@ -1,5 +1,6 @@ === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts === -target1: + +No type information for this code.target1: No type information for this code.target2: No type information for this code.while (true) { No type information for this code. continue target2; diff --git a/tests/baselines/reference/parser_continueTarget4.types b/tests/baselines/reference/parser_continueTarget4.types index cb0367283ce8e..be1e5458f4bca 100644 --- a/tests/baselines/reference/parser_continueTarget4.types +++ b/tests/baselines/reference/parser_continueTarget4.types @@ -1,4 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts === + target1: >target1 : any diff --git a/tests/baselines/reference/parser_continueTarget5.errors.txt b/tests/baselines/reference/parser_continueTarget5.errors.txt index ffeee7a07b311..b9b1f2edb945d 100644 --- a/tests/baselines/reference/parser_continueTarget5.errors.txt +++ b/tests/baselines/reference/parser_continueTarget5.errors.txt @@ -1,8 +1,11 @@ +tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget5.ts(1,1): error TS7028: Unused label. tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget5.ts(5,7): error TS1107: Jump target cannot cross function boundary. -==== tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget5.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget5.ts (2 errors) ==== target: + ~~~~~~ +!!! error TS7028: Unused label. while (true) { function f() { while (true) { diff --git a/tests/baselines/reference/parser_duplicateLabel1.errors.txt b/tests/baselines/reference/parser_duplicateLabel1.errors.txt index 4733a240e3658..a4319aaa7b9e9 100644 --- a/tests/baselines/reference/parser_duplicateLabel1.errors.txt +++ b/tests/baselines/reference/parser_duplicateLabel1.errors.txt @@ -1,8 +1,11 @@ +tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel1.ts(1,1): error TS7028: Unused label. tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel1.ts(2,1): error TS1114: Duplicate label 'target' -==== tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel1.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel1.ts (2 errors) ==== target: + ~~~~~~ +!!! error TS7028: Unused label. target: ~~~~~~ !!! error TS1114: Duplicate label 'target' diff --git a/tests/baselines/reference/parser_duplicateLabel2.errors.txt b/tests/baselines/reference/parser_duplicateLabel2.errors.txt index 92078593e4702..123949fa5aab3 100644 --- a/tests/baselines/reference/parser_duplicateLabel2.errors.txt +++ b/tests/baselines/reference/parser_duplicateLabel2.errors.txt @@ -1,8 +1,11 @@ +tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel2.ts(1,1): error TS7028: Unused label. tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel2.ts(3,3): error TS1114: Duplicate label 'target' -==== tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel2.ts (1 errors) ==== +==== tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel2.ts (2 errors) ==== target: + ~~~~~~ +!!! error TS7028: Unused label. while (true) { target: ~~~~~~ diff --git a/tests/baselines/reference/parser_duplicateLabel3.js b/tests/baselines/reference/parser_duplicateLabel3.js index 9bd6c56356af9..c2ea2769f18fc 100644 --- a/tests/baselines/reference/parser_duplicateLabel3.js +++ b/tests/baselines/reference/parser_duplicateLabel3.js @@ -1,4 +1,5 @@ //// [parser_duplicateLabel3.ts] + target: while (true) { function f() { diff --git a/tests/baselines/reference/parser_duplicateLabel3.symbols b/tests/baselines/reference/parser_duplicateLabel3.symbols index 20627a0e2b8f8..7e238eb2916f9 100644 --- a/tests/baselines/reference/parser_duplicateLabel3.symbols +++ b/tests/baselines/reference/parser_duplicateLabel3.symbols @@ -1,8 +1,9 @@ === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts === + target: while (true) { function f() { ->f : Symbol(f, Decl(parser_duplicateLabel3.ts, 1, 14)) +>f : Symbol(f, Decl(parser_duplicateLabel3.ts, 2, 14)) target: while (true) { diff --git a/tests/baselines/reference/parser_duplicateLabel3.types b/tests/baselines/reference/parser_duplicateLabel3.types index 05cfe708161fe..88ea435bf3e21 100644 --- a/tests/baselines/reference/parser_duplicateLabel3.types +++ b/tests/baselines/reference/parser_duplicateLabel3.types @@ -1,4 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts === + target: >target : any diff --git a/tests/baselines/reference/parser_duplicateLabel4.js b/tests/baselines/reference/parser_duplicateLabel4.js index 569a9bcd1023b..a949131442630 100644 --- a/tests/baselines/reference/parser_duplicateLabel4.js +++ b/tests/baselines/reference/parser_duplicateLabel4.js @@ -1,4 +1,5 @@ //// [parser_duplicateLabel4.ts] + target: while (true) { } diff --git a/tests/baselines/reference/parser_duplicateLabel4.symbols b/tests/baselines/reference/parser_duplicateLabel4.symbols index 564531bf71bd8..e7123de16008e 100644 --- a/tests/baselines/reference/parser_duplicateLabel4.symbols +++ b/tests/baselines/reference/parser_duplicateLabel4.symbols @@ -1,5 +1,6 @@ === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts === -target: + +No type information for this code.target: No type information for this code.while (true) { No type information for this code.} No type information for this code. diff --git a/tests/baselines/reference/parser_duplicateLabel4.types b/tests/baselines/reference/parser_duplicateLabel4.types index d09529301ca3c..b70dd12c695bf 100644 --- a/tests/baselines/reference/parser_duplicateLabel4.types +++ b/tests/baselines/reference/parser_duplicateLabel4.types @@ -1,4 +1,5 @@ === tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts === + target: >target : any diff --git a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt index bc6229815f5a8..0f148b6a20e49 100644 --- a/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt +++ b/tests/baselines/reference/privacyFunctionCannotNameReturnTypeDeclFile.errors.txt @@ -1,7 +1,19 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(3,12): error TS4050: Return type of public static method from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(7,49): error TS7027: Unreachable code detected. tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(9,5): error TS4053: Return type of public method from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(10,49): error TS7027: Unreachable code detected. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(13,49): error TS7027: Unreachable code detected. tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(15,12): error TS4050: Return type of public static method from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(19,49): error TS7027: Unreachable code detected. tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(21,5): error TS4053: Return type of public method from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(22,49): error TS7027: Unreachable code detected. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(25,49): error TS7027: Unreachable code detected. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(34,49): error TS7027: Unreachable code detected. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(37,49): error TS7027: Unreachable code detected. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(40,49): error TS7027: Unreachable code detected. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(46,49): error TS7027: Unreachable code detected. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(49,49): error TS7027: Unreachable code detected. +tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(52,49): error TS7027: Unreachable code detected. tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(56,17): error TS4058: Return type of exported function has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named. tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(62,17): error TS4058: Return type of exported function has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named. tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(70,12): error TS4050: Return type of public static method from exported class has or is using name 'SpecializedWidget.Widget2' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named. @@ -12,7 +24,7 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(83,17): error tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error TS4058: Return type of exported function has or is using name 'SpecializedGlobalWidget.Widget4' from external module "GlobalWidgets" but cannot be named. -==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts (12 errors) ==== +==== tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts (24 errors) ==== import exporter = require("./privacyFunctionReturnTypeDeclFile_exporter"); export class publicClassWithWithPrivateParmeterTypes { static myPublicStaticMethod() { // Error @@ -22,14 +34,20 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error } private static myPrivateStaticMethod() { return exporter.createExportedWidget1();; + ~ +!!! error TS7027: Unreachable code detected. } myPublicMethod() { // Error ~~~~~~~~~~~~~~ !!! error TS4053: Return type of public method from exported class has or is using name 'Widget1' from external module "tests/cases/compiler/privacyFunctionReturnTypeDeclFile_Widgets" but cannot be named. return exporter.createExportedWidget1();; + ~ +!!! error TS7027: Unreachable code detected. } private myPrivateMethod() { return exporter.createExportedWidget1();; + ~ +!!! error TS7027: Unreachable code detected. } static myPublicStaticMethod1() { // Error ~~~~~~~~~~~~~~~~~~~~~ @@ -38,14 +56,20 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error } private static myPrivateStaticMethod1() { return exporter.createExportedWidget3();; + ~ +!!! error TS7027: Unreachable code detected. } myPublicMethod1() { // Error ~~~~~~~~~~~~~~~ !!! error TS4053: Return type of public method from exported class has or is using name 'Widget3' from external module "GlobalWidgets" but cannot be named. return exporter.createExportedWidget3();; + ~ +!!! error TS7027: Unreachable code detected. } private myPrivateMethod1() { return exporter.createExportedWidget3();; + ~ +!!! error TS7027: Unreachable code detected. } } @@ -55,24 +79,36 @@ tests/cases/compiler/privacyFunctionReturnTypeDeclFile_consumer.ts(86,17): error } private static myPrivateStaticMethod() { return exporter.createExportedWidget1();; + ~ +!!! error TS7027: Unreachable code detected. } myPublicMethod() { return exporter.createExportedWidget1();; + ~ +!!! error TS7027: Unreachable code detected. } private myPrivateMethod() { return exporter.createExportedWidget1();; + ~ +!!! error TS7027: Unreachable code detected. } static myPublicStaticMethod1() { return exporter.createExportedWidget3(); } private static myPrivateStaticMethod1() { return exporter.createExportedWidget3();; + ~ +!!! error TS7027: Unreachable code detected. } myPublicMethod1() { return exporter.createExportedWidget3();; + ~ +!!! error TS7027: Unreachable code detected. } private myPrivateMethod1() { return exporter.createExportedWidget3();; + ~ +!!! error TS7027: Unreachable code detected. } } diff --git a/tests/baselines/reference/reachabilityChecks1.errors.txt b/tests/baselines/reference/reachabilityChecks1.errors.txt new file mode 100644 index 0000000000000..18a453969a17f --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks1.errors.txt @@ -0,0 +1,99 @@ +tests/cases/compiler/reachabilityChecks1.ts(3,1): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(7,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(19,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(31,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(48,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(61,5): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks1.ts(70,5): error TS7027: Unreachable code detected. + + +==== tests/cases/compiler/reachabilityChecks1.ts (7 errors) ==== + + while (true); + var x = 1; + ~~~ +!!! error TS7027: Unreachable code detected. + + module A { + while (true); + let x; + ~~~ +!!! error TS7027: Unreachable code detected. + } + + module A1 { + do {} while(true); + module A { + interface F {} + } + } + + module A2 { + while (true); + module A { + ~~~~~~ +!!! error TS7027: Unreachable code detected. + var x = 1; + } + } + + module A3 { + while (true); + type T = string; + } + + module A4 { + while (true); + module A { + ~~~~~~ +!!! error TS7027: Unreachable code detected. + const enum E { X } + } + } + + function f1(x) { + if (x) { + return; + } + else { + throw new Error("123"); + } + var x; + } + + function f2() { + return; + class A { + ~~~~~ +!!! error TS7027: Unreachable code detected. + } + } + + module B { + for (; ;); + module C { + } + } + + function f3() { + do { + } while (true); + enum E { + ~~~~ +!!! error TS7027: Unreachable code detected. + X = 1 + } + } + + function f4() { + if (true) { + throw new Error(); + } + const enum E { + ~~~~~ +!!! error TS7027: Unreachable code detected. + X = 1 + } + } + + \ No newline at end of file diff --git a/tests/baselines/reference/reachabilityChecks1.js b/tests/baselines/reference/reachabilityChecks1.js new file mode 100644 index 0000000000000..dcbfbe89de41a --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks1.js @@ -0,0 +1,156 @@ +//// [reachabilityChecks1.ts] + +while (true); +var x = 1; + +module A { + while (true); + let x; +} + +module A1 { + do {} while(true); + module A { + interface F {} + } +} + +module A2 { + while (true); + module A { + var x = 1; + } +} + +module A3 { + while (true); + type T = string; +} + +module A4 { + while (true); + module A { + const enum E { X } + } +} + +function f1(x) { + if (x) { + return; + } + else { + throw new Error("123"); + } + var x; +} + +function f2() { + return; + class A { + } +} + +module B { + for (; ;); + module C { + } +} + +function f3() { + do { + } while (true); + enum E { + X = 1 + } +} + +function f4() { + if (true) { + throw new Error(); + } + const enum E { + X = 1 + } +} + + + +//// [reachabilityChecks1.js] +while (true) + ; +var x = 1; +var A; +(function (A) { + while (true) + ; + var x; +})(A || (A = {})); +var A1; +(function (A1) { + do { } while (true); +})(A1 || (A1 = {})); +var A2; +(function (A2) { + while (true) + ; + var A; + (function (A) { + var x = 1; + })(A || (A = {})); +})(A2 || (A2 = {})); +var A3; +(function (A3) { + while (true) + ; +})(A3 || (A3 = {})); +var A4; +(function (A4) { + while (true) + ; + var A; + (function (A) { + var E; + (function (E) { + E[E["X"] = 0] = "X"; + })(E || (E = {})); + })(A || (A = {})); +})(A4 || (A4 = {})); +function f1(x) { + if (x) { + return; + } + else { + throw new Error("123"); + } + var x; +} +function f2() { + return; + var A = (function () { + function A() { + } + return A; + })(); +} +var B; +(function (B) { + for (;;) + ; +})(B || (B = {})); +function f3() { + do { + } while (true); + var E; + (function (E) { + E[E["X"] = 1] = "X"; + })(E || (E = {})); +} +function f4() { + if (true) { + throw new Error(); + } + var E; + (function (E) { + E[E["X"] = 1] = "X"; + })(E || (E = {})); +} diff --git a/tests/baselines/reference/reachabilityChecks2.errors.txt b/tests/baselines/reference/reachabilityChecks2.errors.txt new file mode 100644 index 0000000000000..cd48f84f8e151 --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks2.errors.txt @@ -0,0 +1,18 @@ +tests/cases/compiler/reachabilityChecks2.ts(5,1): error TS7027: Unreachable code detected. + + +==== tests/cases/compiler/reachabilityChecks2.ts (1 errors) ==== + + while (true) { } + const enum E { X } + + module A4 { + ~~~~~~ +!!! error TS7027: Unreachable code detected. + while (true); + module A { + const enum E { X } + } + } + + \ No newline at end of file diff --git a/tests/baselines/reference/reachabilityChecks2.js b/tests/baselines/reference/reachabilityChecks2.js new file mode 100644 index 0000000000000..a17b51b4ca61e --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks2.js @@ -0,0 +1,21 @@ +//// [reachabilityChecks2.ts] + +while (true) { } +const enum E { X } + +module A4 { + while (true); + module A { + const enum E { X } + } +} + + + +//// [reachabilityChecks2.js] +while (true) { } +var A4; +(function (A4) { + while (true) + ; +})(A4 || (A4 = {})); diff --git a/tests/baselines/reference/reachabilityChecks3.errors.txt b/tests/baselines/reference/reachabilityChecks3.errors.txt new file mode 100644 index 0000000000000..1114f245f44c6 --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks3.errors.txt @@ -0,0 +1,27 @@ +tests/cases/compiler/reachabilityChecks3.ts(3,1): error TS7028: Unused label. +tests/cases/compiler/reachabilityChecks3.ts(12,5): error TS7028: Unused label. +tests/cases/compiler/reachabilityChecks3.ts(15,17): error TS7028: Unused label. + + +==== tests/cases/compiler/reachabilityChecks3.ts (3 errors) ==== + + let x = 1; + loop: while (true) { + ~~~~ +!!! error TS7028: Unused label. + if (x == 100) { + break; + } + else { + x++; + } + } + { + x: 100 + ~ +!!! error TS7028: Unused label. + } + + var y = () => { f: 1 } + ~ +!!! error TS7028: Unused label. \ No newline at end of file diff --git a/tests/baselines/reference/reachabilityChecks3.js b/tests/baselines/reference/reachabilityChecks3.js new file mode 100644 index 0000000000000..dd22453938d12 --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks3.js @@ -0,0 +1,31 @@ +//// [reachabilityChecks3.ts] + +let x = 1; +loop: while (true) { + if (x == 100) { + break; + } + else { + x++; + } +} +{ + x: 100 +} + +var y = () => { f: 1 } + +//// [reachabilityChecks3.js] +var x = 1; +loop: while (true) { + if (x == 100) { + break; + } + else { + x++; + } +} +{ + x: 100; +} +var y = function () { f: 1; }; diff --git a/tests/baselines/reference/reachabilityChecks4.errors.txt b/tests/baselines/reference/reachabilityChecks4.errors.txt new file mode 100644 index 0000000000000..ba9519462e7e8 --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks4.errors.txt @@ -0,0 +1,20 @@ +tests/cases/compiler/reachabilityChecks4.ts(7,9): error TS7029: Fallthrough case in switch. + + +==== tests/cases/compiler/reachabilityChecks4.ts (1 errors) ==== + + function foo(x, y) { + switch (x) { + case 1: + case 2: + return 1; + case 3: + ~~~~ +!!! error TS7029: Fallthrough case in switch. + if (y) { + return 2; + } + case 4: + return 3; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/reachabilityChecks4.js b/tests/baselines/reference/reachabilityChecks4.js new file mode 100644 index 0000000000000..588644c5a05ea --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks4.js @@ -0,0 +1,30 @@ +//// [reachabilityChecks4.ts] + +function foo(x, y) { + switch (x) { + case 1: + case 2: + return 1; + case 3: + if (y) { + return 2; + } + case 4: + return 3; + } +} + +//// [reachabilityChecks4.js] +function foo(x, y) { + switch (x) { + case 1: + case 2: + return 1; + case 3: + if (y) { + return 2; + } + case 4: + return 3; + } +} diff --git a/tests/baselines/reference/reachabilityChecks5.errors.txt b/tests/baselines/reference/reachabilityChecks5.errors.txt new file mode 100644 index 0000000000000..147dbe264a36c --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks5.errors.txt @@ -0,0 +1,162 @@ +tests/cases/compiler/reachabilityChecks5.ts(6,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(19,17): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/compiler/reachabilityChecks5.ts(31,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(41,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(52,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(80,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(86,13): error TS7027: Unreachable code detected. +tests/cases/compiler/reachabilityChecks5.ts(94,17): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(116,18): error TS7030: Not all code paths return a value. +tests/cases/compiler/reachabilityChecks5.ts(123,13): error TS7027: Unreachable code detected. + + +==== tests/cases/compiler/reachabilityChecks5.ts (10 errors) ==== + + function f0(x): number { + while (true); + } + + function f1(x): number { + ~~~~~~ +!!! error TS7030: Not all code paths return a value. + if (x) { + return 1 + } + } + + function f2(x): number { + while (x) { + throw new Error(); + } + return 1; + } + + function f3(x): number { + ~~~~~~ +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. + while (x) { + throw new Error(); + } + } + + function f3_1 (x): number { + while (x) { + } + throw new Error(); + } + + function f4(x): number { + ~~~~~~ +!!! error TS7030: Not all code paths return a value. + try { + if (x) { + return 1; + } + } + catch (e) { + } + } + + function f5(x): number { + ~~~~~~ +!!! error TS7030: Not all code paths return a value. + try { + if (x) { + return 1; + } + } + catch (e) { + return 2; + } + } + + function f6(x): number { + ~~~~~~ +!!! error TS7030: Not all code paths return a value. + try { + if (x) { + return 1; + } + else + { + throw new Error(); + } + } + catch (e) { + } + } + + function f7(x): number { + try { + if (x) { + return 1; + } + else { + throw new Error(); + } + } + catch (e) { + return 1; + } + } + + function f8(x): number { + ~~~~~~ +!!! error TS7030: Not all code paths return a value. + try { + if (true) { + x++; + } + else { + return 1; + ~~~~~~ +!!! error TS7027: Unreachable code detected. + } + } + catch (e) { + return 1; + } + } + + function f9(x): number { + ~~~~~~ +!!! error TS7030: Not all code paths return a value. + try { + while (false) { + return 1; + } + } + catch (e) { + return 1; + } + } + + function f10(x): number { + try { + do { + x++; + } while (true); + } + catch (e) { + return 1; + } + } + + function f11(x): number { + ~~~~~~ +!!! error TS7030: Not all code paths return a value. + test: + try { + do { + do { + break test; + } while (true); + x++; + ~ +!!! error TS7027: Unreachable code detected. + } while (true); + } + catch (e) { + return 1; + } + } \ No newline at end of file diff --git a/tests/baselines/reference/reachabilityChecks5.js b/tests/baselines/reference/reachabilityChecks5.js new file mode 100644 index 0000000000000..a6c507ac87b88 --- /dev/null +++ b/tests/baselines/reference/reachabilityChecks5.js @@ -0,0 +1,247 @@ +//// [reachabilityChecks5.ts] + +function f0(x): number { + while (true); +} + +function f1(x): number { + if (x) { + return 1 + } +} + +function f2(x): number { + while (x) { + throw new Error(); + } + return 1; +} + +function f3(x): number { + while (x) { + throw new Error(); + } +} + +function f3_1 (x): number { + while (x) { + } + throw new Error(); +} + +function f4(x): number { + try { + if (x) { + return 1; + } + } + catch (e) { + } +} + +function f5(x): number { + try { + if (x) { + return 1; + } + } + catch (e) { + return 2; + } +} + +function f6(x): number { + try { + if (x) { + return 1; + } + else + { + throw new Error(); + } + } + catch (e) { + } +} + +function f7(x): number { + try { + if (x) { + return 1; + } + else { + throw new Error(); + } + } + catch (e) { + return 1; + } +} + +function f8(x): number { + try { + if (true) { + x++; + } + else { + return 1; + } + } + catch (e) { + return 1; + } +} + +function f9(x): number { + try { + while (false) { + return 1; + } + } + catch (e) { + return 1; + } +} + +function f10(x): number { + try { + do { + x++; + } while (true); + } + catch (e) { + return 1; + } +} + +function f11(x): number { + test: + try { + do { + do { + break test; + } while (true); + x++; + } while (true); + } + catch (e) { + return 1; + } +} + +//// [reachabilityChecks5.js] +function f0(x) { + while (true) + ; +} +function f1(x) { + if (x) { + return 1; + } +} +function f2(x) { + while (x) { + throw new Error(); + } + return 1; +} +function f3(x) { + while (x) { + throw new Error(); + } +} +function f3_1(x) { + while (x) { + } + throw new Error(); +} +function f4(x) { + try { + if (x) { + return 1; + } + } + catch (e) { + } +} +function f5(x) { + try { + if (x) { + return 1; + } + } + catch (e) { + return 2; + } +} +function f6(x) { + try { + if (x) { + return 1; + } + else { + throw new Error(); + } + } + catch (e) { + } +} +function f7(x) { + try { + if (x) { + return 1; + } + else { + throw new Error(); + } + } + catch (e) { + return 1; + } +} +function f8(x) { + try { + if (true) { + x++; + } + else { + return 1; + } + } + catch (e) { + return 1; + } +} +function f9(x) { + try { + while (false) { + return 1; + } + } + catch (e) { + return 1; + } +} +function f10(x) { + try { + do { + x++; + } while (true); + } + catch (e) { + return 1; + } +} +function f11(x) { + test: try { + do { + do { + break test; + } while (true); + x++; + } while (true); + } + catch (e) { + return 1; + } +} diff --git a/tests/baselines/reference/recursiveFunctionTypes.errors.txt b/tests/baselines/reference/recursiveFunctionTypes.errors.txt index c69549403c49b..8d5303c066918 100644 --- a/tests/baselines/reference/recursiveFunctionTypes.errors.txt +++ b/tests/baselines/reference/recursiveFunctionTypes.errors.txt @@ -2,8 +2,8 @@ tests/cases/compiler/recursiveFunctionTypes.ts(1,35): error TS2322: Type 'number tests/cases/compiler/recursiveFunctionTypes.ts(3,5): error TS2322: Type '() => typeof fn' is not assignable to type 'number'. tests/cases/compiler/recursiveFunctionTypes.ts(4,5): error TS2322: Type '() => typeof fn' is not assignable to type '() => number'. Type '() => typeof fn' is not assignable to type 'number'. -tests/cases/compiler/recursiveFunctionTypes.ts(11,16): 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/recursiveFunctionTypes.ts(12,16): 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/recursiveFunctionTypes.ts(11,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. +tests/cases/compiler/recursiveFunctionTypes.ts(12,16): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. tests/cases/compiler/recursiveFunctionTypes.ts(17,5): error TS2322: Type '() => I' is not assignable to type 'number'. tests/cases/compiler/recursiveFunctionTypes.ts(22,5): error TS2345: Argument of type 'number' is not assignable to parameter of type '(t: typeof g) => void'. tests/cases/compiler/recursiveFunctionTypes.ts(25,1): error TS2322: Type 'number' is not assignable to type '() => any'. @@ -34,10 +34,10 @@ tests/cases/compiler/recursiveFunctionTypes.ts(43,4): error TS2345: Argument of function f2(): typeof g2 { } ~~~~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. function g2(): typeof f2 { } ~~~~~~~~~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. interface I { } function f3(): I { return f3; } diff --git a/tests/baselines/reference/recursiveLetConst.errors.txt b/tests/baselines/reference/recursiveLetConst.errors.txt index b02d0819a3f46..88ecb379e5ef8 100644 --- a/tests/baselines/reference/recursiveLetConst.errors.txt +++ b/tests/baselines/reference/recursiveLetConst.errors.txt @@ -3,6 +3,7 @@ tests/cases/compiler/recursiveLetConst.ts(3,12): error TS2448: Block-scoped vari tests/cases/compiler/recursiveLetConst.ts(4,11): error TS2448: Block-scoped variable 'y' used before its declaration. tests/cases/compiler/recursiveLetConst.ts(5,14): error TS2448: Block-scoped variable 'y1' used before its declaration. tests/cases/compiler/recursiveLetConst.ts(6,14): error TS2448: Block-scoped variable 'v' used before its declaration. +tests/cases/compiler/recursiveLetConst.ts(7,1): error TS7027: Unreachable code detected. tests/cases/compiler/recursiveLetConst.ts(7,16): error TS2448: Block-scoped variable 'v' used before its declaration. tests/cases/compiler/recursiveLetConst.ts(8,15): error TS2448: Block-scoped variable 'v' used before its declaration. tests/cases/compiler/recursiveLetConst.ts(9,15): error TS2448: Block-scoped variable 'v' used before its declaration. @@ -10,7 +11,7 @@ tests/cases/compiler/recursiveLetConst.ts(10,17): error TS2448: Block-scoped var tests/cases/compiler/recursiveLetConst.ts(11,11): error TS2448: Block-scoped variable 'x2' used before its declaration. -==== tests/cases/compiler/recursiveLetConst.ts (10 errors) ==== +==== tests/cases/compiler/recursiveLetConst.ts (11 errors) ==== 'use strict' let x = x + 1; ~ @@ -28,6 +29,8 @@ tests/cases/compiler/recursiveLetConst.ts(11,11): error TS2448: Block-scoped var ~ !!! error TS2448: Block-scoped variable 'v' used before its declaration. for (let [v] = v; ;) { } + ~~~ +!!! error TS7027: Unreachable code detected. ~ !!! error TS2448: Block-scoped variable 'v' used before its declaration. for (let v in v) { } diff --git a/tests/baselines/reference/recursiveMods.js b/tests/baselines/reference/recursiveMods.js index 36d2712e04005..f913ddec012be 100644 --- a/tests/baselines/reference/recursiveMods.js +++ b/tests/baselines/reference/recursiveMods.js @@ -1,4 +1,5 @@ //// [recursiveMods.ts] + export module Foo { export class C {} } diff --git a/tests/baselines/reference/recursiveMods.symbols b/tests/baselines/reference/recursiveMods.symbols index 1e7e8fa1c8418..5f6d6f87721eb 100644 --- a/tests/baselines/reference/recursiveMods.symbols +++ b/tests/baselines/reference/recursiveMods.symbols @@ -1,44 +1,45 @@ === tests/cases/compiler/recursiveMods.ts === + export module Foo { ->Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 2, 1)) +>Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 3, 1)) export class C {} ->C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) +>C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) } export module Foo { ->Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 2, 1)) +>Foo : Symbol(Foo, Decl(recursiveMods.ts, 0, 0), Decl(recursiveMods.ts, 3, 1)) function Bar() : C { ->Bar : Symbol(Bar, Decl(recursiveMods.ts, 4, 19)) ->C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) +>Bar : Symbol(Bar, Decl(recursiveMods.ts, 5, 19)) +>C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) if (true) { return Bar();} ->Bar : Symbol(Bar, Decl(recursiveMods.ts, 4, 19)) +>Bar : Symbol(Bar, Decl(recursiveMods.ts, 5, 19)) return new C(); ->C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) +>C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) } function Baz() : C { ->Baz : Symbol(Baz, Decl(recursiveMods.ts, 9, 2)) ->C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) +>Baz : Symbol(Baz, Decl(recursiveMods.ts, 10, 2)) +>C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) var c = Baz(); ->c : Symbol(c, Decl(recursiveMods.ts, 12, 5)) ->Baz : Symbol(Baz, Decl(recursiveMods.ts, 9, 2)) +>c : Symbol(c, Decl(recursiveMods.ts, 13, 5)) +>Baz : Symbol(Baz, Decl(recursiveMods.ts, 10, 2)) return Bar(); ->Bar : Symbol(Bar, Decl(recursiveMods.ts, 4, 19)) +>Bar : Symbol(Bar, Decl(recursiveMods.ts, 5, 19)) } function Gar() { ->Gar : Symbol(Gar, Decl(recursiveMods.ts, 14, 2)) +>Gar : Symbol(Gar, Decl(recursiveMods.ts, 15, 2)) var c : C = Baz(); ->c : Symbol(c, Decl(recursiveMods.ts, 17, 5)) ->C : Symbol(C, Decl(recursiveMods.ts, 0, 19)) ->Baz : Symbol(Baz, Decl(recursiveMods.ts, 9, 2)) +>c : Symbol(c, Decl(recursiveMods.ts, 18, 5)) +>C : Symbol(C, Decl(recursiveMods.ts, 1, 19)) +>Baz : Symbol(Baz, Decl(recursiveMods.ts, 10, 2)) return; } diff --git a/tests/baselines/reference/recursiveMods.types b/tests/baselines/reference/recursiveMods.types index d7f28f8497556..d4db816daf7c3 100644 --- a/tests/baselines/reference/recursiveMods.types +++ b/tests/baselines/reference/recursiveMods.types @@ -1,4 +1,5 @@ === tests/cases/compiler/recursiveMods.ts === + export module Foo { >Foo : typeof Foo diff --git a/tests/baselines/reference/recursiveNamedLambdaCall.errors.txt b/tests/baselines/reference/recursiveNamedLambdaCall.errors.txt index 7729d1e780fad..04ddc371ac710 100644 --- a/tests/baselines/reference/recursiveNamedLambdaCall.errors.txt +++ b/tests/baselines/reference/recursiveNamedLambdaCall.errors.txt @@ -1,11 +1,12 @@ tests/cases/compiler/recursiveNamedLambdaCall.ts(3,8): error TS2304: Cannot find name 'top'. tests/cases/compiler/recursiveNamedLambdaCall.ts(3,15): error TS2304: Cannot find name 'top'. +tests/cases/compiler/recursiveNamedLambdaCall.ts(7,6): error TS7027: Unreachable code detected. tests/cases/compiler/recursiveNamedLambdaCall.ts(8,7): error TS2304: Cannot find name 'top'. tests/cases/compiler/recursiveNamedLambdaCall.ts(10,14): error TS2304: Cannot find name 'setTimeout'. tests/cases/compiler/recursiveNamedLambdaCall.ts(14,6): error TS2304: Cannot find name 'detach'. -==== tests/cases/compiler/recursiveNamedLambdaCall.ts (5 errors) ==== +==== tests/cases/compiler/recursiveNamedLambdaCall.ts (6 errors) ==== var promise = function( obj ) { if ( top && top.doScroll ) { @@ -17,6 +18,8 @@ tests/cases/compiler/recursiveNamedLambdaCall.ts(14,6): error TS2304: Cannot fin if ( false ) { try { + ~~~ +!!! error TS7027: Unreachable code detected. top.doScroll("left"); ~~~ !!! error TS2304: Cannot find name 'top'. diff --git a/tests/baselines/reference/reservedWords2.errors.txt b/tests/baselines/reference/reservedWords2.errors.txt index 090b2d0d43eab..d6e2d04073d9d 100644 --- a/tests/baselines/reference/reservedWords2.errors.txt +++ b/tests/baselines/reference/reservedWords2.errors.txt @@ -14,6 +14,7 @@ tests/cases/compiler/reservedWords2.ts(5,9): error TS2300: Duplicate identifier tests/cases/compiler/reservedWords2.ts(5,10): error TS1003: Identifier expected. tests/cases/compiler/reservedWords2.ts(5,18): error TS1005: '=>' expected. tests/cases/compiler/reservedWords2.ts(6,1): error TS2304: Cannot find name 'module'. +tests/cases/compiler/reservedWords2.ts(6,1): error TS7027: Unreachable code detected. tests/cases/compiler/reservedWords2.ts(6,8): error TS1005: ';' expected. tests/cases/compiler/reservedWords2.ts(7,11): error TS2300: Duplicate identifier '(Missing)'. tests/cases/compiler/reservedWords2.ts(7,11): error TS1005: ':' expected. @@ -31,7 +32,7 @@ tests/cases/compiler/reservedWords2.ts(10,5): error TS2300: Duplicate identifier tests/cases/compiler/reservedWords2.ts(10,6): error TS1003: Identifier expected. -==== tests/cases/compiler/reservedWords2.ts (31 errors) ==== +==== tests/cases/compiler/reservedWords2.ts (32 errors) ==== import while = require("dfdf"); ~~~~~~ !!! error TS1148: Cannot compile modules unless the '--module' flag is provided. @@ -70,6 +71,8 @@ tests/cases/compiler/reservedWords2.ts(10,6): error TS1003: Identifier expected. module void {} ~~~~~~ !!! error TS2304: Cannot find name 'module'. + ~~~~~~ +!!! error TS7027: Unreachable code detected. ~~~~ !!! error TS1005: ';' expected. var {while, return} = { while: 1, return: 2 }; diff --git a/tests/baselines/reference/returnStatement1.js b/tests/baselines/reference/returnStatement1.js index c4ccc3caddec2..3f5c5561b2a01 100644 --- a/tests/baselines/reference/returnStatement1.js +++ b/tests/baselines/reference/returnStatement1.js @@ -1,4 +1,5 @@ //// [returnStatement1.ts] + function f() { return function (s) { var x = s; diff --git a/tests/baselines/reference/returnStatement1.symbols b/tests/baselines/reference/returnStatement1.symbols index acec9f7600374..6727cba0df5b0 100644 --- a/tests/baselines/reference/returnStatement1.symbols +++ b/tests/baselines/reference/returnStatement1.symbols @@ -1,13 +1,14 @@ === tests/cases/compiler/returnStatement1.ts === + function f() { >f : Symbol(f, Decl(returnStatement1.ts, 0, 0)) return function (s) { ->s : Symbol(s, Decl(returnStatement1.ts, 1, 21)) +>s : Symbol(s, Decl(returnStatement1.ts, 2, 21)) var x = s; ->x : Symbol(x, Decl(returnStatement1.ts, 2, 11)) ->s : Symbol(s, Decl(returnStatement1.ts, 1, 21)) +>x : Symbol(x, Decl(returnStatement1.ts, 3, 11)) +>s : Symbol(s, Decl(returnStatement1.ts, 2, 21)) }; ("harmless extra line"); diff --git a/tests/baselines/reference/returnStatement1.types b/tests/baselines/reference/returnStatement1.types index ff30148af5ae9..b7e166ffa75a9 100644 --- a/tests/baselines/reference/returnStatement1.types +++ b/tests/baselines/reference/returnStatement1.types @@ -1,4 +1,5 @@ === tests/cases/compiler/returnStatement1.ts === + function f() { >f : () => (s: any) => void diff --git a/tests/baselines/reference/returnTypeParameter.errors.txt b/tests/baselines/reference/returnTypeParameter.errors.txt index 11c0888f47cfa..1bd9f6a63f64a 100644 --- a/tests/baselines/reference/returnTypeParameter.errors.txt +++ b/tests/baselines/reference/returnTypeParameter.errors.txt @@ -1,11 +1,11 @@ -tests/cases/compiler/returnTypeParameter.ts(1,22): 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/returnTypeParameter.ts(1,22): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. tests/cases/compiler/returnTypeParameter.ts(2,34): error TS2304: Cannot find name 'T'. ==== tests/cases/compiler/returnTypeParameter.ts (2 errors) ==== function f(a: T): T { } // error, no return statement ~ -!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value or consist of a single 'throw' statement. +!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value. function f2(a: T): T { return T; } // bug was that this satisfied the return statement requirement ~ !!! error TS2304: Cannot find name 'T'. \ No newline at end of file diff --git a/tests/baselines/reference/scanner10.1.1-8gs.errors.txt b/tests/baselines/reference/scanner10.1.1-8gs.errors.txt index 54cd92dc0ca6b..23d89cdf7ff7c 100644 --- a/tests/baselines/reference/scanner10.1.1-8gs.errors.txt +++ b/tests/baselines/reference/scanner10.1.1-8gs.errors.txt @@ -1,8 +1,9 @@ tests/cases/conformance/scanner/ecmascript5/scanner10.1.1-8gs.ts(16,7): error TS2304: Cannot find name 'NotEarlyError'. +tests/cases/conformance/scanner/ecmascript5/scanner10.1.1-8gs.ts(17,1): error TS7027: Unreachable code detected. tests/cases/conformance/scanner/ecmascript5/scanner10.1.1-8gs.ts(17,5): error TS1212: Identifier expected. 'public' is a reserved word in strict mode -==== tests/cases/conformance/scanner/ecmascript5/scanner10.1.1-8gs.ts (2 errors) ==== +==== tests/cases/conformance/scanner/ecmascript5/scanner10.1.1-8gs.ts (3 errors) ==== /// Copyright (c) 2012 Ecma International. All rights reserved. /// Ecma International makes this code available under the terms and conditions set /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the @@ -22,6 +23,8 @@ tests/cases/conformance/scanner/ecmascript5/scanner10.1.1-8gs.ts(17,5): error TS ~~~~~~~~~~~~~ !!! error TS2304: Cannot find name 'NotEarlyError'. var public = 1; + ~~~ +!!! error TS7027: Unreachable code detected. ~~~~~~ !!! error TS1212: Identifier expected. 'public' is a reserved word in strict mode \ No newline at end of file diff --git a/tests/baselines/reference/setterWithReturn.errors.txt b/tests/baselines/reference/setterWithReturn.errors.txt index 481116327b88d..6aed49105b82b 100644 --- a/tests/baselines/reference/setterWithReturn.errors.txt +++ b/tests/baselines/reference/setterWithReturn.errors.txt @@ -1,9 +1,10 @@ tests/cases/compiler/setterWithReturn.ts(2,16): error TS1056: Accessors are only available when targeting ECMAScript 5 and higher. tests/cases/compiler/setterWithReturn.ts(4,20): error TS2408: Setters cannot return a value. +tests/cases/compiler/setterWithReturn.ts(7,13): error TS7027: Unreachable code detected. tests/cases/compiler/setterWithReturn.ts(7,20): error TS2408: Setters cannot return a value. -==== tests/cases/compiler/setterWithReturn.ts (3 errors) ==== +==== tests/cases/compiler/setterWithReturn.ts (4 errors) ==== class C234 { public set p1(arg1) { ~~ @@ -15,6 +16,8 @@ tests/cases/compiler/setterWithReturn.ts(7,20): error TS2408: Setters cannot ret } else { return 0; + ~~~~~~ +!!! error TS7027: Unreachable code detected. ~ !!! error TS2408: Setters cannot return a value. } diff --git a/tests/baselines/reference/sourceMapValidationFor.errors.txt b/tests/baselines/reference/sourceMapValidationFor.errors.txt index 7fe75d640d277..6949d7545ed2d 100644 --- a/tests/baselines/reference/sourceMapValidationFor.errors.txt +++ b/tests/baselines/reference/sourceMapValidationFor.errors.txt @@ -1,8 +1,9 @@ tests/cases/compiler/sourceMapValidationFor.ts(2,5): error TS2304: Cannot find name 'WScript'. tests/cases/compiler/sourceMapValidationFor.ts(6,5): error TS2304: Cannot find name 'WScript'. +tests/cases/compiler/sourceMapValidationFor.ts(20,1): error TS7027: Unreachable code detected. -==== tests/cases/compiler/sourceMapValidationFor.ts (2 errors) ==== +==== tests/cases/compiler/sourceMapValidationFor.ts (3 errors) ==== for (var i = 0; i < 10; i++) { WScript.Echo("i: " + i); ~~~~~~~ @@ -27,6 +28,8 @@ tests/cases/compiler/sourceMapValidationFor.ts(6,5): error TS2304: Cannot find n for (var k = 0;; k++) { } for (k = 0;; k++) + ~~~ +!!! error TS7027: Unreachable code detected. { } for (; k < 10; k++) { diff --git a/tests/baselines/reference/sourceMapValidationLabeled.js b/tests/baselines/reference/sourceMapValidationLabeled.js index 7aabc47ea4ea0..50669b870abb8 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.js +++ b/tests/baselines/reference/sourceMapValidationLabeled.js @@ -1,4 +1,5 @@ //// [sourceMapValidationLabeled.ts] + x: var b = 10; diff --git a/tests/baselines/reference/sourceMapValidationLabeled.js.map b/tests/baselines/reference/sourceMapValidationLabeled.js.map index d1219f9896ffb..206ac95b9512f 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.js.map +++ b/tests/baselines/reference/sourceMapValidationLabeled.js.map @@ -1,2 +1,2 @@ //// [sourceMapValidationLabeled.js.map] -{"version":3,"file":"sourceMapValidationLabeled.js","sourceRoot":"","sources":["sourceMapValidationLabeled.ts"],"names":[],"mappings":"AAAA,CAAC,EACD,IAAI,CAAC,GAAG,EAAE,CAAC"} \ No newline at end of file +{"version":3,"file":"sourceMapValidationLabeled.js","sourceRoot":"","sources":["sourceMapValidationLabeled.ts"],"names":[],"mappings":"AACA,CAAC,EACD,IAAI,CAAC,GAAG,EAAE,CAAC"} \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt b/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt index 007208c78f95c..7cf1bf896ca00 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt +++ b/tests/baselines/reference/sourceMapValidationLabeled.sourcemap.txt @@ -18,7 +18,8 @@ sourceFile:sourceMapValidationLabeled.ts 7 > ^^ 8 > ^ 9 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> -1 > +1 > + > 2 >x 3 > : > @@ -27,13 +28,13 @@ sourceFile:sourceMapValidationLabeled.ts 6 > = 7 > 10 8 > ; -1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) -2 >Emitted(1, 2) Source(1, 2) + SourceIndex(0) -3 >Emitted(1, 4) Source(2, 1) + SourceIndex(0) -4 >Emitted(1, 8) Source(2, 5) + SourceIndex(0) -5 >Emitted(1, 9) Source(2, 6) + SourceIndex(0) -6 >Emitted(1, 12) Source(2, 9) + SourceIndex(0) -7 >Emitted(1, 14) Source(2, 11) + SourceIndex(0) -8 >Emitted(1, 15) Source(2, 12) + SourceIndex(0) +1 >Emitted(1, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(1, 2) Source(2, 2) + SourceIndex(0) +3 >Emitted(1, 4) Source(3, 1) + SourceIndex(0) +4 >Emitted(1, 8) Source(3, 5) + SourceIndex(0) +5 >Emitted(1, 9) Source(3, 6) + SourceIndex(0) +6 >Emitted(1, 12) Source(3, 9) + SourceIndex(0) +7 >Emitted(1, 14) Source(3, 11) + SourceIndex(0) +8 >Emitted(1, 15) Source(3, 12) + SourceIndex(0) --- >>>//# sourceMappingURL=sourceMapValidationLabeled.js.map \ No newline at end of file diff --git a/tests/baselines/reference/sourceMapValidationLabeled.symbols b/tests/baselines/reference/sourceMapValidationLabeled.symbols index 2a3c4f5606c38..bf9abc593b34c 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.symbols +++ b/tests/baselines/reference/sourceMapValidationLabeled.symbols @@ -1,5 +1,6 @@ === tests/cases/compiler/sourceMapValidationLabeled.ts === + x: var b = 10; ->b : Symbol(b, Decl(sourceMapValidationLabeled.ts, 1, 3)) +>b : Symbol(b, Decl(sourceMapValidationLabeled.ts, 2, 3)) diff --git a/tests/baselines/reference/sourceMapValidationLabeled.types b/tests/baselines/reference/sourceMapValidationLabeled.types index 3058869cb0bbb..7af624ac93b00 100644 --- a/tests/baselines/reference/sourceMapValidationLabeled.types +++ b/tests/baselines/reference/sourceMapValidationLabeled.types @@ -1,4 +1,5 @@ === tests/cases/compiler/sourceMapValidationLabeled.ts === + x: >x : any diff --git a/tests/baselines/reference/switchBreakStatements.js b/tests/baselines/reference/switchBreakStatements.js index 534f025e2f5b8..d7fa279248c6d 100644 --- a/tests/baselines/reference/switchBreakStatements.js +++ b/tests/baselines/reference/switchBreakStatements.js @@ -1,4 +1,5 @@ //// [switchBreakStatements.ts] + switch ('') { case 'a': break; diff --git a/tests/baselines/reference/switchBreakStatements.symbols b/tests/baselines/reference/switchBreakStatements.symbols index 226262418818a..dde7ca028ccd3 100644 --- a/tests/baselines/reference/switchBreakStatements.symbols +++ b/tests/baselines/reference/switchBreakStatements.symbols @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts === + switch ('') { case 'a': break; @@ -48,7 +49,7 @@ switch ('') { switch ('') { case 'a': var fn = function () { } ->fn : Symbol(fn, Decl(switchBreakStatements.ts, 48, 35)) +>fn : Symbol(fn, Decl(switchBreakStatements.ts, 49, 35)) break EIGHT; } diff --git a/tests/baselines/reference/switchBreakStatements.types b/tests/baselines/reference/switchBreakStatements.types index c8847a5dc3476..0364d878d5ab4 100644 --- a/tests/baselines/reference/switchBreakStatements.types +++ b/tests/baselines/reference/switchBreakStatements.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts === + switch ('') { >'' : string diff --git a/tests/baselines/reference/throwInEnclosingStatements.js b/tests/baselines/reference/throwInEnclosingStatements.js index 0b072434f3365..4d9200776e7de 100644 --- a/tests/baselines/reference/throwInEnclosingStatements.js +++ b/tests/baselines/reference/throwInEnclosingStatements.js @@ -1,4 +1,5 @@ //// [throwInEnclosingStatements.ts] + function fn(x) { throw x; } diff --git a/tests/baselines/reference/throwInEnclosingStatements.symbols b/tests/baselines/reference/throwInEnclosingStatements.symbols index 007894047dee4..42053c60efa06 100644 --- a/tests/baselines/reference/throwInEnclosingStatements.symbols +++ b/tests/baselines/reference/throwInEnclosingStatements.symbols @@ -1,91 +1,92 @@ === tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts === + function fn(x) { >fn : Symbol(fn, Decl(throwInEnclosingStatements.ts, 0, 0)) ->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 0, 12)) +>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 1, 12)) throw x; ->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 0, 12)) +>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 1, 12)) } (x: T) => { throw x; } ->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 4, 1)) ->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 4, 4)) ->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 4, 1)) ->x : Symbol(x, Decl(throwInEnclosingStatements.ts, 4, 4)) +>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 5, 1)) +>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 5, 4)) +>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 5, 1)) +>x : Symbol(x, Decl(throwInEnclosingStatements.ts, 5, 4)) var y: string; ->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3)) +>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3)) switch (y) { ->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3)) +>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3)) case 'a': throw y; ->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3)) +>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3)) default: throw y; ->y : Symbol(y, Decl(throwInEnclosingStatements.ts, 6, 3)) +>y : Symbol(y, Decl(throwInEnclosingStatements.ts, 7, 3)) } var z = 0; ->z : Symbol(z, Decl(throwInEnclosingStatements.ts, 14, 3)) +>z : Symbol(z, Decl(throwInEnclosingStatements.ts, 15, 3)) while (z < 10) { ->z : Symbol(z, Decl(throwInEnclosingStatements.ts, 14, 3)) +>z : Symbol(z, Decl(throwInEnclosingStatements.ts, 15, 3)) throw z; ->z : Symbol(z, Decl(throwInEnclosingStatements.ts, 14, 3)) +>z : Symbol(z, Decl(throwInEnclosingStatements.ts, 15, 3)) } for (var i = 0; ;) { throw i; } ->i : Symbol(i, Decl(throwInEnclosingStatements.ts, 19, 8)) ->i : Symbol(i, Decl(throwInEnclosingStatements.ts, 19, 8)) +>i : Symbol(i, Decl(throwInEnclosingStatements.ts, 20, 8)) +>i : Symbol(i, Decl(throwInEnclosingStatements.ts, 20, 8)) for (var idx in {}) { throw idx; } ->idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 21, 8)) ->idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 21, 8)) +>idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 22, 8)) +>idx : Symbol(idx, Decl(throwInEnclosingStatements.ts, 22, 8)) do { throw null; }while(true) var j = 0; ->j : Symbol(j, Decl(throwInEnclosingStatements.ts, 25, 3)) +>j : Symbol(j, Decl(throwInEnclosingStatements.ts, 26, 3)) while (j < 0) { throw j; } ->j : Symbol(j, Decl(throwInEnclosingStatements.ts, 25, 3)) ->j : Symbol(j, Decl(throwInEnclosingStatements.ts, 25, 3)) +>j : Symbol(j, Decl(throwInEnclosingStatements.ts, 26, 3)) +>j : Symbol(j, Decl(throwInEnclosingStatements.ts, 26, 3)) class C { ->C : Symbol(C, Decl(throwInEnclosingStatements.ts, 26, 26)) ->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 28, 8)) +>C : Symbol(C, Decl(throwInEnclosingStatements.ts, 27, 26)) +>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 29, 8)) private value: T; ->value : Symbol(value, Decl(throwInEnclosingStatements.ts, 28, 12)) ->T : Symbol(T, Decl(throwInEnclosingStatements.ts, 28, 8)) +>value : Symbol(value, Decl(throwInEnclosingStatements.ts, 29, 12)) +>T : Symbol(T, Decl(throwInEnclosingStatements.ts, 29, 8)) biz() { ->biz : Symbol(biz, Decl(throwInEnclosingStatements.ts, 29, 21)) +>biz : Symbol(biz, Decl(throwInEnclosingStatements.ts, 30, 21)) throw this.value; ->this.value : Symbol(value, Decl(throwInEnclosingStatements.ts, 28, 12)) ->this : Symbol(C, Decl(throwInEnclosingStatements.ts, 26, 26)) ->value : Symbol(value, Decl(throwInEnclosingStatements.ts, 28, 12)) +>this.value : Symbol(value, Decl(throwInEnclosingStatements.ts, 29, 12)) +>this : Symbol(C, Decl(throwInEnclosingStatements.ts, 27, 26)) +>value : Symbol(value, Decl(throwInEnclosingStatements.ts, 29, 12)) } constructor() { throw this; ->this : Symbol(C, Decl(throwInEnclosingStatements.ts, 26, 26)) +>this : Symbol(C, Decl(throwInEnclosingStatements.ts, 27, 26)) } } var aa = { ->aa : Symbol(aa, Decl(throwInEnclosingStatements.ts, 39, 3)) +>aa : Symbol(aa, Decl(throwInEnclosingStatements.ts, 40, 3)) id:12, ->id : Symbol(id, Decl(throwInEnclosingStatements.ts, 39, 10)) +>id : Symbol(id, Decl(throwInEnclosingStatements.ts, 40, 10)) biz() { ->biz : Symbol(biz, Decl(throwInEnclosingStatements.ts, 40, 10)) +>biz : Symbol(biz, Decl(throwInEnclosingStatements.ts, 41, 10)) throw this; } diff --git a/tests/baselines/reference/throwInEnclosingStatements.types b/tests/baselines/reference/throwInEnclosingStatements.types index bcff8653d52f7..568fd800e353f 100644 --- a/tests/baselines/reference/throwInEnclosingStatements.types +++ b/tests/baselines/reference/throwInEnclosingStatements.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts === + function fn(x) { >fn : (x: any) => void >x : any diff --git a/tests/baselines/reference/throwStatements.js b/tests/baselines/reference/throwStatements.js index 83663d08cc481..556ebc55e37b4 100644 --- a/tests/baselines/reference/throwStatements.js +++ b/tests/baselines/reference/throwStatements.js @@ -1,4 +1,5 @@ //// [throwStatements.ts] + // all legal interface I { diff --git a/tests/baselines/reference/throwStatements.symbols b/tests/baselines/reference/throwStatements.symbols index 508bdcb9f3f6b..adf9cb461cf8c 100644 --- a/tests/baselines/reference/throwStatements.symbols +++ b/tests/baselines/reference/throwStatements.symbols @@ -1,184 +1,185 @@ === tests/cases/conformance/statements/throwStatements/throwStatements.ts === + // all legal interface I { >I : Symbol(I, Decl(throwStatements.ts, 0, 0)) id: number; ->id : Symbol(id, Decl(throwStatements.ts, 2, 13)) +>id : Symbol(id, Decl(throwStatements.ts, 3, 13)) } class C implements I { ->C : Symbol(C, Decl(throwStatements.ts, 4, 1)) +>C : Symbol(C, Decl(throwStatements.ts, 5, 1)) >I : Symbol(I, Decl(throwStatements.ts, 0, 0)) id: number; ->id : Symbol(id, Decl(throwStatements.ts, 6, 22)) +>id : Symbol(id, Decl(throwStatements.ts, 7, 22)) } class D{ ->D : Symbol(D, Decl(throwStatements.ts, 8, 1)) ->T : Symbol(T, Decl(throwStatements.ts, 10, 8)) +>D : Symbol(D, Decl(throwStatements.ts, 9, 1)) +>T : Symbol(T, Decl(throwStatements.ts, 11, 8)) source: T; ->source : Symbol(source, Decl(throwStatements.ts, 10, 11)) ->T : Symbol(T, Decl(throwStatements.ts, 10, 8)) +>source : Symbol(source, Decl(throwStatements.ts, 11, 11)) +>T : Symbol(T, Decl(throwStatements.ts, 11, 8)) recurse: D; ->recurse : Symbol(recurse, Decl(throwStatements.ts, 11, 14)) ->D : Symbol(D, Decl(throwStatements.ts, 8, 1)) ->T : Symbol(T, Decl(throwStatements.ts, 10, 8)) +>recurse : Symbol(recurse, Decl(throwStatements.ts, 12, 14)) +>D : Symbol(D, Decl(throwStatements.ts, 9, 1)) +>T : Symbol(T, Decl(throwStatements.ts, 11, 8)) wrapped: D> ->wrapped : Symbol(wrapped, Decl(throwStatements.ts, 12, 18)) ->D : Symbol(D, Decl(throwStatements.ts, 8, 1)) ->D : Symbol(D, Decl(throwStatements.ts, 8, 1)) ->T : Symbol(T, Decl(throwStatements.ts, 10, 8)) +>wrapped : Symbol(wrapped, Decl(throwStatements.ts, 13, 18)) +>D : Symbol(D, Decl(throwStatements.ts, 9, 1)) +>D : Symbol(D, Decl(throwStatements.ts, 9, 1)) +>T : Symbol(T, Decl(throwStatements.ts, 11, 8)) } function F(x: string): number { return 42; } ->F : Symbol(F, Decl(throwStatements.ts, 14, 1)) ->x : Symbol(x, Decl(throwStatements.ts, 16, 11)) +>F : Symbol(F, Decl(throwStatements.ts, 15, 1)) +>x : Symbol(x, Decl(throwStatements.ts, 17, 11)) module M { ->M : Symbol(M, Decl(throwStatements.ts, 16, 44)) +>M : Symbol(M, Decl(throwStatements.ts, 17, 44)) export class A { ->A : Symbol(A, Decl(throwStatements.ts, 18, 10)) +>A : Symbol(A, Decl(throwStatements.ts, 19, 10)) name: string; ->name : Symbol(name, Decl(throwStatements.ts, 19, 20)) +>name : Symbol(name, Decl(throwStatements.ts, 20, 20)) } 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)) +>F2 : Symbol(F2, Decl(throwStatements.ts, 22, 5)) +>x : Symbol(x, Decl(throwStatements.ts, 24, 23)) >x.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) ->x : Symbol(x, Decl(throwStatements.ts, 23, 23)) +>x : Symbol(x, Decl(throwStatements.ts, 24, 23)) >toString : Symbol(Number.toString, Decl(lib.d.ts, --, --)) } var aNumber = 9.9; ->aNumber : Symbol(aNumber, Decl(throwStatements.ts, 26, 3)) +>aNumber : Symbol(aNumber, Decl(throwStatements.ts, 27, 3)) throw aNumber; ->aNumber : Symbol(aNumber, Decl(throwStatements.ts, 26, 3)) +>aNumber : Symbol(aNumber, Decl(throwStatements.ts, 27, 3)) var aString = 'this is a string'; ->aString : Symbol(aString, Decl(throwStatements.ts, 28, 3)) +>aString : Symbol(aString, Decl(throwStatements.ts, 29, 3)) throw aString; ->aString : Symbol(aString, Decl(throwStatements.ts, 28, 3)) +>aString : Symbol(aString, Decl(throwStatements.ts, 29, 3)) var aDate = new Date(12); ->aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3)) +>aDate : Symbol(aDate, Decl(throwStatements.ts, 31, 3)) >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw aDate; ->aDate : Symbol(aDate, Decl(throwStatements.ts, 30, 3)) +>aDate : Symbol(aDate, Decl(throwStatements.ts, 31, 3)) var anObject = new Object(); ->anObject : Symbol(anObject, Decl(throwStatements.ts, 32, 3)) +>anObject : Symbol(anObject, Decl(throwStatements.ts, 33, 3)) >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw anObject; ->anObject : Symbol(anObject, Decl(throwStatements.ts, 32, 3)) +>anObject : Symbol(anObject, Decl(throwStatements.ts, 33, 3)) var anAny = null; ->anAny : Symbol(anAny, Decl(throwStatements.ts, 35, 3)) +>anAny : Symbol(anAny, Decl(throwStatements.ts, 36, 3)) throw anAny; ->anAny : Symbol(anAny, Decl(throwStatements.ts, 35, 3)) +>anAny : Symbol(anAny, Decl(throwStatements.ts, 36, 3)) var anOtherAny = new C(); ->anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 37, 3)) ->C : Symbol(C, Decl(throwStatements.ts, 4, 1)) +>anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 38, 3)) +>C : Symbol(C, Decl(throwStatements.ts, 5, 1)) throw anOtherAny; ->anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 37, 3)) +>anOtherAny : Symbol(anOtherAny, Decl(throwStatements.ts, 38, 3)) var anUndefined = undefined; ->anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 39, 3)) +>anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 40, 3)) >undefined : Symbol(undefined) throw anUndefined; ->anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 39, 3)) +>anUndefined : Symbol(anUndefined, Decl(throwStatements.ts, 40, 3)) var aClass = new C(); ->aClass : Symbol(aClass, Decl(throwStatements.ts, 42, 3)) ->C : Symbol(C, Decl(throwStatements.ts, 4, 1)) +>aClass : Symbol(aClass, Decl(throwStatements.ts, 43, 3)) +>C : Symbol(C, Decl(throwStatements.ts, 5, 1)) throw aClass; ->aClass : Symbol(aClass, Decl(throwStatements.ts, 42, 3)) +>aClass : Symbol(aClass, Decl(throwStatements.ts, 43, 3)) var aGenericClass = new D(); ->aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 44, 3)) ->D : Symbol(D, Decl(throwStatements.ts, 8, 1)) +>aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 45, 3)) +>D : Symbol(D, Decl(throwStatements.ts, 9, 1)) throw aGenericClass; ->aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 44, 3)) +>aGenericClass : Symbol(aGenericClass, Decl(throwStatements.ts, 45, 3)) var anObjectLiteral = { id: 12 }; ->anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 46, 3)) ->id : Symbol(id, Decl(throwStatements.ts, 46, 23)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 47, 3)) +>id : Symbol(id, Decl(throwStatements.ts, 47, 23)) throw anObjectLiteral; ->anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 46, 3)) +>anObjectLiteral : Symbol(anObjectLiteral, Decl(throwStatements.ts, 47, 3)) var aFunction = F; ->aFunction : Symbol(aFunction, Decl(throwStatements.ts, 49, 3)) ->F : Symbol(F, Decl(throwStatements.ts, 14, 1)) +>aFunction : Symbol(aFunction, Decl(throwStatements.ts, 50, 3)) +>F : Symbol(F, Decl(throwStatements.ts, 15, 1)) throw aFunction; ->aFunction : Symbol(aFunction, Decl(throwStatements.ts, 49, 3)) +>aFunction : Symbol(aFunction, Decl(throwStatements.ts, 50, 3)) throw aFunction(''); ->aFunction : Symbol(aFunction, Decl(throwStatements.ts, 49, 3)) +>aFunction : Symbol(aFunction, Decl(throwStatements.ts, 50, 3)) var aLambda = (x) => 2; ->aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3)) ->x : Symbol(x, Decl(throwStatements.ts, 52, 15)) +>aLambda : Symbol(aLambda, Decl(throwStatements.ts, 53, 3)) +>x : Symbol(x, Decl(throwStatements.ts, 53, 15)) throw aLambda; ->aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3)) +>aLambda : Symbol(aLambda, Decl(throwStatements.ts, 53, 3)) throw aLambda(1); ->aLambda : Symbol(aLambda, Decl(throwStatements.ts, 52, 3)) +>aLambda : Symbol(aLambda, Decl(throwStatements.ts, 53, 3)) var aModule = M; ->aModule : Symbol(aModule, Decl(throwStatements.ts, 56, 3)) ->M : Symbol(M, Decl(throwStatements.ts, 16, 44)) +>aModule : Symbol(aModule, Decl(throwStatements.ts, 57, 3)) +>M : Symbol(M, Decl(throwStatements.ts, 17, 44)) throw aModule; ->aModule : Symbol(aModule, Decl(throwStatements.ts, 56, 3)) +>aModule : Symbol(aModule, Decl(throwStatements.ts, 57, 3)) throw typeof M; ->M : Symbol(M, Decl(throwStatements.ts, 16, 44)) +>M : Symbol(M, Decl(throwStatements.ts, 17, 44)) var aClassInModule = new M.A(); ->aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 59, 3)) ->M.A : Symbol(M.A, Decl(throwStatements.ts, 18, 10)) ->M : Symbol(M, Decl(throwStatements.ts, 16, 44)) ->A : Symbol(M.A, Decl(throwStatements.ts, 18, 10)) +>aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 60, 3)) +>M.A : Symbol(M.A, Decl(throwStatements.ts, 19, 10)) +>M : Symbol(M, Decl(throwStatements.ts, 17, 44)) +>A : Symbol(M.A, Decl(throwStatements.ts, 19, 10)) throw aClassInModule; ->aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 59, 3)) +>aClassInModule : Symbol(aClassInModule, Decl(throwStatements.ts, 60, 3)) var aFunctionInModule = M.F2; ->aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 61, 3)) ->M.F2 : Symbol(M.F2, Decl(throwStatements.ts, 21, 5)) ->M : Symbol(M, Decl(throwStatements.ts, 16, 44)) ->F2 : Symbol(M.F2, Decl(throwStatements.ts, 21, 5)) +>aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 62, 3)) +>M.F2 : Symbol(M.F2, Decl(throwStatements.ts, 22, 5)) +>M : Symbol(M, Decl(throwStatements.ts, 17, 44)) +>F2 : Symbol(M.F2, Decl(throwStatements.ts, 22, 5)) throw aFunctionInModule; ->aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 61, 3)) +>aFunctionInModule : Symbol(aFunctionInModule, Decl(throwStatements.ts, 62, 3)) // no initializer or annotation, so this is an 'any' var x; ->x : Symbol(x, Decl(throwStatements.ts, 65, 3)) +>x : Symbol(x, Decl(throwStatements.ts, 66, 3)) throw x; ->x : Symbol(x, Decl(throwStatements.ts, 65, 3)) +>x : Symbol(x, Decl(throwStatements.ts, 66, 3)) // literals throw 0.0; @@ -190,13 +191,13 @@ throw undefined; throw 'a string'; throw function () { return 'a string' }; throw (x:T) => 42; ->T : Symbol(T, Decl(throwStatements.ts, 75, 7)) ->x : Symbol(x, Decl(throwStatements.ts, 75, 10)) ->T : Symbol(T, Decl(throwStatements.ts, 75, 7)) +>T : Symbol(T, Decl(throwStatements.ts, 76, 7)) +>x : Symbol(x, Decl(throwStatements.ts, 76, 10)) +>T : Symbol(T, Decl(throwStatements.ts, 76, 7)) throw { x: 12, y: 13 }; ->x : Symbol(x, Decl(throwStatements.ts, 76, 7)) ->y : Symbol(y, Decl(throwStatements.ts, 76, 14)) +>x : Symbol(x, Decl(throwStatements.ts, 77, 7)) +>y : Symbol(y, Decl(throwStatements.ts, 77, 14)) throw []; throw ['a', ['b']]; @@ -205,11 +206,11 @@ throw new Date(); >Date : Symbol(Date, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw new C(); ->C : Symbol(C, Decl(throwStatements.ts, 4, 1)) +>C : Symbol(C, Decl(throwStatements.ts, 5, 1)) throw new Object(); >Object : Symbol(Object, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --)) throw new D(); ->D : Symbol(D, Decl(throwStatements.ts, 8, 1)) +>D : Symbol(D, Decl(throwStatements.ts, 9, 1)) diff --git a/tests/baselines/reference/throwStatements.types b/tests/baselines/reference/throwStatements.types index 3d365a1b65a0c..5023513ee5372 100644 --- a/tests/baselines/reference/throwStatements.types +++ b/tests/baselines/reference/throwStatements.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/throwStatements/throwStatements.ts === + // all legal interface I { diff --git a/tests/baselines/reference/throwWithoutNewLine2.errors.txt b/tests/baselines/reference/throwWithoutNewLine2.errors.txt index 6930d240e7b82..83f4e4cc24627 100644 --- a/tests/baselines/reference/throwWithoutNewLine2.errors.txt +++ b/tests/baselines/reference/throwWithoutNewLine2.errors.txt @@ -1,11 +1,14 @@ tests/cases/compiler/throwWithoutNewLine2.ts(1,6): error TS1142: Line break not permitted here. tests/cases/compiler/throwWithoutNewLine2.ts(2,1): error TS2304: Cannot find name 'a'. +tests/cases/compiler/throwWithoutNewLine2.ts(2,1): error TS7027: Unreachable code detected. -==== tests/cases/compiler/throwWithoutNewLine2.ts (2 errors) ==== +==== tests/cases/compiler/throwWithoutNewLine2.ts (3 errors) ==== throw !!! error TS1142: Line break not permitted here. a; ~ -!!! error TS2304: Cannot find name 'a'. \ No newline at end of file +!!! error TS2304: Cannot find name 'a'. + ~ +!!! error TS7027: Unreachable code detected. \ No newline at end of file diff --git a/tests/baselines/reference/typeGuardFunctionErrors.errors.txt b/tests/baselines/reference/typeGuardFunctionErrors.errors.txt index b178b02c6b457..ca06e4f63a2eb 100644 --- a/tests/baselines/reference/typeGuardFunctionErrors.errors.txt +++ b/tests/baselines/reference/typeGuardFunctionErrors.errors.txt @@ -9,6 +9,7 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(38,51) Property 'propA' is missing in type 'B'. tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(42,56): error TS2322: Type 'number' is not assignable to type 'string'. tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(46,56): error TS2322: Type 'T[]' is not assignable to type 'string'. +tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(50,1): error TS7027: Unreachable code detected. tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(60,7): error TS2339: Property 'propB' does not exist on type 'A'. tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(65,7): error TS2339: Property 'propB' does not exist on type 'A'. tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(70,7): error TS2339: Property 'propB' does not exist on type 'A'. @@ -37,7 +38,7 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(133,34 tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(137,39): error TS1230: A type predicate cannot reference element 'p1' in a binding pattern. -==== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts (31 errors) ==== +==== tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts (32 errors) ==== class A { propA: number; @@ -109,6 +110,8 @@ tests/cases/conformance/expressions/typeGuards/typeGuardFunctionErrors.ts(137,39 } let a: A; + ~~~ +!!! error TS7027: Unreachable code detected. let b: B; declare function isB(p1): p1 is B; diff --git a/tests/baselines/reference/typeofOperatorWithAnyOtherType.errors.txt b/tests/baselines/reference/typeofOperatorWithAnyOtherType.errors.txt index 6112b61ceb639..0139c96b3f998 100644 --- a/tests/baselines/reference/typeofOperatorWithAnyOtherType.errors.txt +++ b/tests/baselines/reference/typeofOperatorWithAnyOtherType.errors.txt @@ -1,9 +1,12 @@ tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(46,32): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'. tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(47,32): error TS2365: Operator '+' cannot be applied to types 'null' and 'null'. tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(48,32): error TS2365: Operator '+' cannot be applied to types 'undefined' and 'undefined'. +tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(68,1): error TS7028: Unused label. +tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(69,1): error TS7028: Unused label. +tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts(70,1): error TS7028: Unused label. -==== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts (3 errors) ==== +==== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithAnyOtherType.ts (6 errors) ==== // typeof operator on any type var ANY: any; @@ -78,8 +81,14 @@ tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperator var x: any[]; var r: () => any; z: typeof ANY; + ~ +!!! error TS7028: Unused label. x: typeof ANY2; + ~ +!!! error TS7028: Unused label. r: typeof foo; + ~ +!!! error TS7028: Unused label. z: typeof objA.a; z: typeof A.foo; z: typeof M.n; diff --git a/tests/baselines/reference/typeofOperatorWithBooleanType.js b/tests/baselines/reference/typeofOperatorWithBooleanType.js index c0538b78b1448..b9db33b11a4bb 100644 --- a/tests/baselines/reference/typeofOperatorWithBooleanType.js +++ b/tests/baselines/reference/typeofOperatorWithBooleanType.js @@ -1,4 +1,5 @@ //// [typeofOperatorWithBooleanType.ts] + // typeof operator on boolean type var BOOLEAN: boolean; diff --git a/tests/baselines/reference/typeofOperatorWithBooleanType.symbols b/tests/baselines/reference/typeofOperatorWithBooleanType.symbols index 39276e6162562..0167a14ae03ff 100644 --- a/tests/baselines/reference/typeofOperatorWithBooleanType.symbols +++ b/tests/baselines/reference/typeofOperatorWithBooleanType.symbols @@ -1,130 +1,131 @@ === tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithBooleanType.ts === + // typeof operator on boolean type var BOOLEAN: boolean; ->BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 1, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 2, 3)) function foo(): boolean { return true; } ->foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 1, 21)) +>foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 2, 21)) class A { ->A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 3, 40)) +>A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 4, 40)) public a: boolean; ->a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 5, 9)) +>a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 6, 9)) static foo() { return false; } ->foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 6, 22)) +>foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 7, 22)) } module M { ->M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 8, 1)) +>M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 9, 1)) export var n: boolean; ->n : Symbol(n, Decl(typeofOperatorWithBooleanType.ts, 10, 14)) +>n : Symbol(n, Decl(typeofOperatorWithBooleanType.ts, 11, 14)) } var objA = new A(); ->objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 13, 3)) ->A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 3, 40)) +>objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 14, 3)) +>A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 4, 40)) // boolean type var var ResultIsString1 = typeof BOOLEAN; ->ResultIsString1 : Symbol(ResultIsString1, Decl(typeofOperatorWithBooleanType.ts, 16, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 1, 3)) +>ResultIsString1 : Symbol(ResultIsString1, Decl(typeofOperatorWithBooleanType.ts, 17, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 2, 3)) // boolean type literal var ResultIsString2 = typeof true; ->ResultIsString2 : Symbol(ResultIsString2, Decl(typeofOperatorWithBooleanType.ts, 19, 3)) +>ResultIsString2 : Symbol(ResultIsString2, Decl(typeofOperatorWithBooleanType.ts, 20, 3)) var ResultIsString3 = typeof { x: true, y: false }; ->ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithBooleanType.ts, 20, 3)) ->x : Symbol(x, Decl(typeofOperatorWithBooleanType.ts, 20, 30)) ->y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 20, 39)) +>ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithBooleanType.ts, 21, 3)) +>x : Symbol(x, Decl(typeofOperatorWithBooleanType.ts, 21, 30)) +>y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 21, 39)) // boolean type expressions var ResultIsString4 = typeof objA.a; ->ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithBooleanType.ts, 23, 3)) ->objA.a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 5, 9)) ->objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 13, 3)) ->a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 5, 9)) +>ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithBooleanType.ts, 24, 3)) +>objA.a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 6, 9)) +>objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 14, 3)) +>a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 6, 9)) var ResultIsString5 = typeof M.n; ->ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithBooleanType.ts, 24, 3)) ->M.n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 10, 14)) ->M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 8, 1)) ->n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 10, 14)) +>ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithBooleanType.ts, 25, 3)) +>M.n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 11, 14)) +>M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 9, 1)) +>n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 11, 14)) var ResultIsString6 = typeof foo(); ->ResultIsString6 : Symbol(ResultIsString6, Decl(typeofOperatorWithBooleanType.ts, 25, 3)) ->foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 1, 21)) +>ResultIsString6 : Symbol(ResultIsString6, Decl(typeofOperatorWithBooleanType.ts, 26, 3)) +>foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 2, 21)) var ResultIsString7 = typeof A.foo(); ->ResultIsString7 : Symbol(ResultIsString7, Decl(typeofOperatorWithBooleanType.ts, 26, 3)) ->A.foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 6, 22)) ->A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 3, 40)) ->foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 6, 22)) +>ResultIsString7 : Symbol(ResultIsString7, Decl(typeofOperatorWithBooleanType.ts, 27, 3)) +>A.foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 7, 22)) +>A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 4, 40)) +>foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 7, 22)) // multiple typeof operator var ResultIsString8 = typeof typeof BOOLEAN; ->ResultIsString8 : Symbol(ResultIsString8, Decl(typeofOperatorWithBooleanType.ts, 29, 3)) ->BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 1, 3)) +>ResultIsString8 : Symbol(ResultIsString8, Decl(typeofOperatorWithBooleanType.ts, 30, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 2, 3)) // miss assignment operators typeof true; typeof BOOLEAN; ->BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 1, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 2, 3)) typeof foo(); ->foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 1, 21)) +>foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 2, 21)) typeof true, false; typeof objA.a; ->objA.a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 5, 9)) ->objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 13, 3)) ->a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 5, 9)) +>objA.a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 6, 9)) +>objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 14, 3)) +>a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 6, 9)) typeof M.n; ->M.n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 10, 14)) ->M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 8, 1)) ->n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 10, 14)) +>M.n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 11, 14)) +>M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 9, 1)) +>n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 11, 14)) // use typeof in type query var z: boolean; ->z : Symbol(z, Decl(typeofOperatorWithBooleanType.ts, 40, 3)) +>z : Symbol(z, Decl(typeofOperatorWithBooleanType.ts, 41, 3)) var x: boolean[]; ->x : Symbol(x, Decl(typeofOperatorWithBooleanType.ts, 41, 3)) +>x : Symbol(x, Decl(typeofOperatorWithBooleanType.ts, 42, 3)) var r: () => boolean; ->r : Symbol(r, Decl(typeofOperatorWithBooleanType.ts, 42, 3)) +>r : Symbol(r, Decl(typeofOperatorWithBooleanType.ts, 43, 3)) z: typeof BOOLEAN; ->BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 1, 3)) +>BOOLEAN : Symbol(BOOLEAN, Decl(typeofOperatorWithBooleanType.ts, 2, 3)) r: typeof foo; ->foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 1, 21)) +>foo : Symbol(foo, Decl(typeofOperatorWithBooleanType.ts, 2, 21)) var y = { a: true, b: false}; ->y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 45, 3)) ->a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 45, 9)) ->b : Symbol(b, Decl(typeofOperatorWithBooleanType.ts, 45, 18)) +>y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 46, 3)) +>a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 46, 9)) +>b : Symbol(b, Decl(typeofOperatorWithBooleanType.ts, 46, 18)) z: typeof y.a; ->y.a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 45, 9)) ->y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 45, 3)) ->a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 45, 9)) +>y.a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 46, 9)) +>y : Symbol(y, Decl(typeofOperatorWithBooleanType.ts, 46, 3)) +>a : Symbol(a, Decl(typeofOperatorWithBooleanType.ts, 46, 9)) z: typeof objA.a; ->objA.a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 5, 9)) ->objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 13, 3)) ->a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 5, 9)) +>objA.a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 6, 9)) +>objA : Symbol(objA, Decl(typeofOperatorWithBooleanType.ts, 14, 3)) +>a : Symbol(A.a, Decl(typeofOperatorWithBooleanType.ts, 6, 9)) z: typeof A.foo; ->A.foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 6, 22)) ->A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 3, 40)) ->foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 6, 22)) +>A.foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 7, 22)) +>A : Symbol(A, Decl(typeofOperatorWithBooleanType.ts, 4, 40)) +>foo : Symbol(A.foo, Decl(typeofOperatorWithBooleanType.ts, 7, 22)) z: typeof M.n; ->M.n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 10, 14)) ->M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 8, 1)) ->n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 10, 14)) +>M.n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 11, 14)) +>M : Symbol(M, Decl(typeofOperatorWithBooleanType.ts, 9, 1)) +>n : Symbol(M.n, Decl(typeofOperatorWithBooleanType.ts, 11, 14)) diff --git a/tests/baselines/reference/typeofOperatorWithBooleanType.types b/tests/baselines/reference/typeofOperatorWithBooleanType.types index 06cd7466a1830..043307cfb0051 100644 --- a/tests/baselines/reference/typeofOperatorWithBooleanType.types +++ b/tests/baselines/reference/typeofOperatorWithBooleanType.types @@ -1,4 +1,5 @@ === tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithBooleanType.ts === + // typeof operator on boolean type var BOOLEAN: boolean; >BOOLEAN : boolean diff --git a/tests/baselines/reference/typeofOperatorWithEnumType.js b/tests/baselines/reference/typeofOperatorWithEnumType.js index 2e2963b0955aa..2ce326681862b 100644 --- a/tests/baselines/reference/typeofOperatorWithEnumType.js +++ b/tests/baselines/reference/typeofOperatorWithEnumType.js @@ -1,4 +1,5 @@ //// [typeofOperatorWithEnumType.ts] + // typeof operator on enum type enum ENUM { }; diff --git a/tests/baselines/reference/typeofOperatorWithEnumType.symbols b/tests/baselines/reference/typeofOperatorWithEnumType.symbols index 3ae150ece0310..a8e3d6d351f00 100644 --- a/tests/baselines/reference/typeofOperatorWithEnumType.symbols +++ b/tests/baselines/reference/typeofOperatorWithEnumType.symbols @@ -1,69 +1,70 @@ === tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts === + // typeof operator on enum type enum ENUM { }; >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0)) enum ENUM1 { A, B, "" }; ->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14)) ->A : Symbol(ENUM1.A, Decl(typeofOperatorWithEnumType.ts, 3, 12)) ->B : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 3, 15)) +>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14)) +>A : Symbol(ENUM1.A, Decl(typeofOperatorWithEnumType.ts, 4, 12)) +>B : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 4, 15)) // enum type var var ResultIsString1 = typeof ENUM; ->ResultIsString1 : Symbol(ResultIsString1, Decl(typeofOperatorWithEnumType.ts, 6, 3)) +>ResultIsString1 : Symbol(ResultIsString1, Decl(typeofOperatorWithEnumType.ts, 7, 3)) >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0)) var ResultIsString2 = typeof ENUM1; ->ResultIsString2 : Symbol(ResultIsString2, Decl(typeofOperatorWithEnumType.ts, 7, 3)) ->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14)) +>ResultIsString2 : Symbol(ResultIsString2, Decl(typeofOperatorWithEnumType.ts, 8, 3)) +>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14)) // enum type expressions var ResultIsString3 = typeof ENUM1["A"]; ->ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithEnumType.ts, 10, 3)) ->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14)) ->"A" : Symbol(ENUM1.A, Decl(typeofOperatorWithEnumType.ts, 3, 12)) +>ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithEnumType.ts, 11, 3)) +>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14)) +>"A" : Symbol(ENUM1.A, Decl(typeofOperatorWithEnumType.ts, 4, 12)) var ResultIsString4 = typeof (ENUM[0] + ENUM1["B"]); ->ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithEnumType.ts, 11, 3)) +>ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithEnumType.ts, 12, 3)) >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0)) ->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14)) ->"B" : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 3, 15)) +>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14)) +>"B" : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 4, 15)) // multiple typeof operators var ResultIsString5 = typeof typeof ENUM; ->ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithEnumType.ts, 14, 3)) +>ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithEnumType.ts, 15, 3)) >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0)) var ResultIsString6 = typeof typeof typeof (ENUM[0] + ENUM1.B); ->ResultIsString6 : Symbol(ResultIsString6, Decl(typeofOperatorWithEnumType.ts, 15, 3)) +>ResultIsString6 : Symbol(ResultIsString6, Decl(typeofOperatorWithEnumType.ts, 16, 3)) >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0)) ->ENUM1.B : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 3, 15)) ->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14)) ->B : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 3, 15)) +>ENUM1.B : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 4, 15)) +>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14)) +>B : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 4, 15)) // miss assignment operators typeof ENUM; >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0)) typeof ENUM1; ->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14)) +>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14)) typeof ENUM1["B"]; ->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14)) ->"B" : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 3, 15)) +>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14)) +>"B" : Symbol(ENUM1.B, Decl(typeofOperatorWithEnumType.ts, 4, 15)) typeof ENUM, ENUM1; >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0)) ->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14)) +>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14)) // use typeof in type query enum z { }; ->z : Symbol(z, Decl(typeofOperatorWithEnumType.ts, 21, 19)) +>z : Symbol(z, Decl(typeofOperatorWithEnumType.ts, 22, 19)) z: typeof ENUM; >ENUM : Symbol(ENUM, Decl(typeofOperatorWithEnumType.ts, 0, 0)) z: typeof ENUM1; ->ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 2, 14)) +>ENUM1 : Symbol(ENUM1, Decl(typeofOperatorWithEnumType.ts, 3, 14)) diff --git a/tests/baselines/reference/typeofOperatorWithEnumType.types b/tests/baselines/reference/typeofOperatorWithEnumType.types index 82bf699a22f20..f9224811393c5 100644 --- a/tests/baselines/reference/typeofOperatorWithEnumType.types +++ b/tests/baselines/reference/typeofOperatorWithEnumType.types @@ -1,4 +1,5 @@ === tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts === + // typeof operator on enum type enum ENUM { }; diff --git a/tests/baselines/reference/typeofOperatorWithStringType.errors.txt b/tests/baselines/reference/typeofOperatorWithStringType.errors.txt new file mode 100644 index 0000000000000..37b2cafab370c --- /dev/null +++ b/tests/baselines/reference/typeofOperatorWithStringType.errors.txt @@ -0,0 +1,69 @@ +tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithStringType.ts(50,1): error TS7028: Unused label. +tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithStringType.ts(51,1): error TS7028: Unused label. +tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithStringType.ts(52,1): error TS7028: Unused label. + + +==== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithStringType.ts (3 errors) ==== + // typeof operator on string type + var STRING: string; + var STRING1: string[] = ["", "abc"]; + + function foo(): string { return "abc"; } + + class A { + public a: string; + static foo() { return ""; } + } + module M { + export var n: string; + } + + var objA = new A(); + + // string type var + var ResultIsString1 = typeof STRING; + var ResultIsString2 = typeof STRING1; + + // string type literal + var ResultIsString3 = typeof ""; + var ResultIsString4 = typeof { x: "", y: "" }; + var ResultIsString5 = typeof { x: "", y: (s: string) => { return s; } }; + + // string type expressions + var ResultIsString6 = typeof objA.a; + var ResultIsString7 = typeof M.n; + var ResultIsString8 = typeof STRING1[0]; + var ResultIsString9 = typeof foo(); + var ResultIsString10 = typeof A.foo(); + var ResultIsString11 = typeof (STRING + STRING); + var ResultIsString12 = typeof STRING.charAt(0); + + // multiple typeof operators + var ResultIsString13 = typeof typeof STRING; + var ResultIsString14 = typeof typeof typeof (STRING + STRING); + + // miss assignment operators + typeof ""; + typeof STRING; + typeof STRING1; + typeof foo(); + typeof objA.a, M.n; + + // use typeof in type query + var z: string; + var x: string[]; + var r: () => string; + z: typeof STRING; + ~ +!!! error TS7028: Unused label. + x: typeof STRING1; + ~ +!!! error TS7028: Unused label. + r: typeof foo; + ~ +!!! error TS7028: Unused label. + var y = { a: "", b: "" }; + z: typeof y.a; + z: typeof objA.a; + z: typeof A.foo; + z: typeof M.n; \ No newline at end of file diff --git a/tests/baselines/reference/typeofOperatorWithStringType.symbols b/tests/baselines/reference/typeofOperatorWithStringType.symbols deleted file mode 100644 index 090e0958e601d..0000000000000 --- a/tests/baselines/reference/typeofOperatorWithStringType.symbols +++ /dev/null @@ -1,167 +0,0 @@ -=== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithStringType.ts === -// typeof operator on string type -var STRING: string; ->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3)) - -var STRING1: string[] = ["", "abc"]; ->STRING1 : Symbol(STRING1, Decl(typeofOperatorWithStringType.ts, 2, 3)) - -function foo(): string { return "abc"; } ->foo : Symbol(foo, Decl(typeofOperatorWithStringType.ts, 2, 36)) - -class A { ->A : Symbol(A, Decl(typeofOperatorWithStringType.ts, 4, 40)) - - public a: string; ->a : Symbol(a, Decl(typeofOperatorWithStringType.ts, 6, 9)) - - static foo() { return ""; } ->foo : Symbol(A.foo, Decl(typeofOperatorWithStringType.ts, 7, 21)) -} -module M { ->M : Symbol(M, Decl(typeofOperatorWithStringType.ts, 9, 1)) - - export var n: string; ->n : Symbol(n, Decl(typeofOperatorWithStringType.ts, 11, 14)) -} - -var objA = new A(); ->objA : Symbol(objA, Decl(typeofOperatorWithStringType.ts, 14, 3)) ->A : Symbol(A, Decl(typeofOperatorWithStringType.ts, 4, 40)) - -// string type var -var ResultIsString1 = typeof STRING; ->ResultIsString1 : Symbol(ResultIsString1, Decl(typeofOperatorWithStringType.ts, 17, 3)) ->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3)) - -var ResultIsString2 = typeof STRING1; ->ResultIsString2 : Symbol(ResultIsString2, Decl(typeofOperatorWithStringType.ts, 18, 3)) ->STRING1 : Symbol(STRING1, Decl(typeofOperatorWithStringType.ts, 2, 3)) - -// string type literal -var ResultIsString3 = typeof ""; ->ResultIsString3 : Symbol(ResultIsString3, Decl(typeofOperatorWithStringType.ts, 21, 3)) - -var ResultIsString4 = typeof { x: "", y: "" }; ->ResultIsString4 : Symbol(ResultIsString4, Decl(typeofOperatorWithStringType.ts, 22, 3)) ->x : Symbol(x, Decl(typeofOperatorWithStringType.ts, 22, 30)) ->y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 22, 37)) - -var ResultIsString5 = typeof { x: "", y: (s: string) => { return s; } }; ->ResultIsString5 : Symbol(ResultIsString5, Decl(typeofOperatorWithStringType.ts, 23, 3)) ->x : Symbol(x, Decl(typeofOperatorWithStringType.ts, 23, 30)) ->y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 23, 37)) ->s : Symbol(s, Decl(typeofOperatorWithStringType.ts, 23, 42)) ->s : Symbol(s, Decl(typeofOperatorWithStringType.ts, 23, 42)) - -// string type expressions -var ResultIsString6 = typeof objA.a; ->ResultIsString6 : Symbol(ResultIsString6, Decl(typeofOperatorWithStringType.ts, 26, 3)) ->objA.a : Symbol(A.a, Decl(typeofOperatorWithStringType.ts, 6, 9)) ->objA : Symbol(objA, Decl(typeofOperatorWithStringType.ts, 14, 3)) ->a : Symbol(A.a, Decl(typeofOperatorWithStringType.ts, 6, 9)) - -var ResultIsString7 = typeof M.n; ->ResultIsString7 : Symbol(ResultIsString7, Decl(typeofOperatorWithStringType.ts, 27, 3)) ->M.n : Symbol(M.n, Decl(typeofOperatorWithStringType.ts, 11, 14)) ->M : Symbol(M, Decl(typeofOperatorWithStringType.ts, 9, 1)) ->n : Symbol(M.n, Decl(typeofOperatorWithStringType.ts, 11, 14)) - -var ResultIsString8 = typeof STRING1[0]; ->ResultIsString8 : Symbol(ResultIsString8, Decl(typeofOperatorWithStringType.ts, 28, 3)) ->STRING1 : Symbol(STRING1, Decl(typeofOperatorWithStringType.ts, 2, 3)) - -var ResultIsString9 = typeof foo(); ->ResultIsString9 : Symbol(ResultIsString9, Decl(typeofOperatorWithStringType.ts, 29, 3)) ->foo : Symbol(foo, Decl(typeofOperatorWithStringType.ts, 2, 36)) - -var ResultIsString10 = typeof A.foo(); ->ResultIsString10 : Symbol(ResultIsString10, Decl(typeofOperatorWithStringType.ts, 30, 3)) ->A.foo : Symbol(A.foo, Decl(typeofOperatorWithStringType.ts, 7, 21)) ->A : Symbol(A, Decl(typeofOperatorWithStringType.ts, 4, 40)) ->foo : Symbol(A.foo, Decl(typeofOperatorWithStringType.ts, 7, 21)) - -var ResultIsString11 = typeof (STRING + STRING); ->ResultIsString11 : Symbol(ResultIsString11, Decl(typeofOperatorWithStringType.ts, 31, 3)) ->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3)) ->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3)) - -var ResultIsString12 = typeof STRING.charAt(0); ->ResultIsString12 : Symbol(ResultIsString12, Decl(typeofOperatorWithStringType.ts, 32, 3)) ->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, --, --)) - -// multiple typeof operators -var ResultIsString13 = typeof typeof STRING; ->ResultIsString13 : Symbol(ResultIsString13, Decl(typeofOperatorWithStringType.ts, 35, 3)) ->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3)) - -var ResultIsString14 = typeof typeof typeof (STRING + STRING); ->ResultIsString14 : Symbol(ResultIsString14, Decl(typeofOperatorWithStringType.ts, 36, 3)) ->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3)) ->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3)) - -// miss assignment operators -typeof ""; -typeof STRING; ->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3)) - -typeof STRING1; ->STRING1 : Symbol(STRING1, Decl(typeofOperatorWithStringType.ts, 2, 3)) - -typeof foo(); ->foo : Symbol(foo, Decl(typeofOperatorWithStringType.ts, 2, 36)) - -typeof objA.a, M.n; ->objA.a : Symbol(A.a, Decl(typeofOperatorWithStringType.ts, 6, 9)) ->objA : Symbol(objA, Decl(typeofOperatorWithStringType.ts, 14, 3)) ->a : Symbol(A.a, Decl(typeofOperatorWithStringType.ts, 6, 9)) ->M.n : Symbol(M.n, Decl(typeofOperatorWithStringType.ts, 11, 14)) ->M : Symbol(M, Decl(typeofOperatorWithStringType.ts, 9, 1)) ->n : Symbol(M.n, Decl(typeofOperatorWithStringType.ts, 11, 14)) - -// use typeof in type query -var z: string; ->z : Symbol(z, Decl(typeofOperatorWithStringType.ts, 46, 3)) - -var x: string[]; ->x : Symbol(x, Decl(typeofOperatorWithStringType.ts, 47, 3)) - -var r: () => string; ->r : Symbol(r, Decl(typeofOperatorWithStringType.ts, 48, 3)) - -z: typeof STRING; ->STRING : Symbol(STRING, Decl(typeofOperatorWithStringType.ts, 1, 3)) - -x: typeof STRING1; ->STRING1 : Symbol(STRING1, Decl(typeofOperatorWithStringType.ts, 2, 3)) - -r: typeof foo; ->foo : Symbol(foo, Decl(typeofOperatorWithStringType.ts, 2, 36)) - -var y = { a: "", b: "" }; ->y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 52, 3)) ->a : Symbol(a, Decl(typeofOperatorWithStringType.ts, 52, 9)) ->b : Symbol(b, Decl(typeofOperatorWithStringType.ts, 52, 16)) - -z: typeof y.a; ->y.a : Symbol(a, Decl(typeofOperatorWithStringType.ts, 52, 9)) ->y : Symbol(y, Decl(typeofOperatorWithStringType.ts, 52, 3)) ->a : Symbol(a, Decl(typeofOperatorWithStringType.ts, 52, 9)) - -z: typeof objA.a; ->objA.a : Symbol(A.a, Decl(typeofOperatorWithStringType.ts, 6, 9)) ->objA : Symbol(objA, Decl(typeofOperatorWithStringType.ts, 14, 3)) ->a : Symbol(A.a, Decl(typeofOperatorWithStringType.ts, 6, 9)) - -z: typeof A.foo; ->A.foo : Symbol(A.foo, Decl(typeofOperatorWithStringType.ts, 7, 21)) ->A : Symbol(A, Decl(typeofOperatorWithStringType.ts, 4, 40)) ->foo : Symbol(A.foo, Decl(typeofOperatorWithStringType.ts, 7, 21)) - -z: typeof M.n; ->M.n : Symbol(M.n, Decl(typeofOperatorWithStringType.ts, 11, 14)) ->M : Symbol(M, Decl(typeofOperatorWithStringType.ts, 9, 1)) ->n : Symbol(M.n, Decl(typeofOperatorWithStringType.ts, 11, 14)) - diff --git a/tests/baselines/reference/typeofOperatorWithStringType.types b/tests/baselines/reference/typeofOperatorWithStringType.types deleted file mode 100644 index 3ae657a995100..0000000000000 --- a/tests/baselines/reference/typeofOperatorWithStringType.types +++ /dev/null @@ -1,233 +0,0 @@ -=== tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithStringType.ts === -// typeof operator on string type -var STRING: string; ->STRING : string - -var STRING1: string[] = ["", "abc"]; ->STRING1 : string[] ->["", "abc"] : string[] ->"" : string ->"abc" : string - -function foo(): string { return "abc"; } ->foo : () => string ->"abc" : string - -class A { ->A : A - - public a: string; ->a : string - - static foo() { return ""; } ->foo : () => string ->"" : string -} -module M { ->M : typeof M - - export var n: string; ->n : string -} - -var objA = new A(); ->objA : A ->new A() : A ->A : typeof A - -// string type var -var ResultIsString1 = typeof STRING; ->ResultIsString1 : string ->typeof STRING : string ->STRING : string - -var ResultIsString2 = typeof STRING1; ->ResultIsString2 : string ->typeof STRING1 : string ->STRING1 : string[] - -// string type literal -var ResultIsString3 = typeof ""; ->ResultIsString3 : string ->typeof "" : string ->"" : string - -var ResultIsString4 = typeof { x: "", y: "" }; ->ResultIsString4 : string ->typeof { x: "", y: "" } : string ->{ x: "", y: "" } : { x: string; y: string; } ->x : string ->"" : string ->y : string ->"" : string - -var ResultIsString5 = typeof { x: "", y: (s: string) => { return s; } }; ->ResultIsString5 : string ->typeof { x: "", y: (s: string) => { return s; } } : string ->{ x: "", y: (s: string) => { return s; } } : { x: string; y: (s: string) => string; } ->x : string ->"" : string ->y : (s: string) => string ->(s: string) => { return s; } : (s: string) => string ->s : string ->s : string - -// string type expressions -var ResultIsString6 = typeof objA.a; ->ResultIsString6 : string ->typeof objA.a : string ->objA.a : string ->objA : A ->a : string - -var ResultIsString7 = typeof M.n; ->ResultIsString7 : string ->typeof M.n : string ->M.n : string ->M : typeof M ->n : string - -var ResultIsString8 = typeof STRING1[0]; ->ResultIsString8 : string ->typeof STRING1[0] : string ->STRING1[0] : string ->STRING1 : string[] ->0 : number - -var ResultIsString9 = typeof foo(); ->ResultIsString9 : string ->typeof foo() : string ->foo() : string ->foo : () => string - -var ResultIsString10 = typeof A.foo(); ->ResultIsString10 : string ->typeof A.foo() : string ->A.foo() : string ->A.foo : () => string ->A : typeof A ->foo : () => string - -var ResultIsString11 = typeof (STRING + STRING); ->ResultIsString11 : string ->typeof (STRING + STRING) : string ->(STRING + STRING) : string ->STRING + STRING : string ->STRING : string ->STRING : string - -var ResultIsString12 = typeof STRING.charAt(0); ->ResultIsString12 : string ->typeof STRING.charAt(0) : string ->STRING.charAt(0) : string ->STRING.charAt : (pos: number) => string ->STRING : string ->charAt : (pos: number) => string ->0 : number - -// multiple typeof operators -var ResultIsString13 = typeof typeof STRING; ->ResultIsString13 : string ->typeof typeof STRING : string ->typeof STRING : string ->STRING : string - -var ResultIsString14 = typeof typeof typeof (STRING + STRING); ->ResultIsString14 : string ->typeof typeof typeof (STRING + STRING) : string ->typeof typeof (STRING + STRING) : string ->typeof (STRING + STRING) : string ->(STRING + STRING) : string ->STRING + STRING : string ->STRING : string ->STRING : string - -// miss assignment operators -typeof ""; ->typeof "" : string ->"" : string - -typeof STRING; ->typeof STRING : string ->STRING : string - -typeof STRING1; ->typeof STRING1 : string ->STRING1 : string[] - -typeof foo(); ->typeof foo() : string ->foo() : string ->foo : () => string - -typeof objA.a, M.n; ->typeof objA.a, M.n : string ->typeof objA.a : string ->objA.a : string ->objA : A ->a : string ->M.n : string ->M : typeof M ->n : string - -// use typeof in type query -var z: string; ->z : string - -var x: string[]; ->x : string[] - -var r: () => string; ->r : () => string - -z: typeof STRING; ->z : any ->typeof STRING : string ->STRING : string - -x: typeof STRING1; ->x : any ->typeof STRING1 : string ->STRING1 : string[] - -r: typeof foo; ->r : any ->typeof foo : string ->foo : () => string - -var y = { a: "", b: "" }; ->y : { a: string; b: string; } ->{ a: "", b: "" } : { a: string; b: string; } ->a : string ->"" : string ->b : string ->"" : string - -z: typeof y.a; ->z : any ->typeof y.a : string ->y.a : string ->y : { a: string; b: string; } ->a : string - -z: typeof objA.a; ->z : any ->typeof objA.a : string ->objA.a : string ->objA : A ->a : string - -z: typeof A.foo; ->z : any ->typeof A.foo : string ->A.foo : () => string ->A : typeof A ->foo : () => string - -z: typeof M.n; ->z : any ->typeof M.n : string ->M.n : string ->M : typeof M ->n : string - diff --git a/tests/baselines/reference/undeclaredVarEmit.errors.txt b/tests/baselines/reference/undeclaredVarEmit.errors.txt index af6298b61d2d8..a95323aa362a0 100644 --- a/tests/baselines/reference/undeclaredVarEmit.errors.txt +++ b/tests/baselines/reference/undeclaredVarEmit.errors.txt @@ -1,7 +1,10 @@ +tests/cases/compiler/undeclaredVarEmit.ts(1,1): error TS7028: Unused label. tests/cases/compiler/undeclaredVarEmit.ts(1,4): error TS2304: Cannot find name 'number'. -==== tests/cases/compiler/undeclaredVarEmit.ts (1 errors) ==== +==== tests/cases/compiler/undeclaredVarEmit.ts (2 errors) ==== f: number; + ~ +!!! error TS7028: Unused label. ~~~~~~ !!! error TS2304: Cannot find name 'number'. \ No newline at end of file diff --git a/tests/baselines/reference/validMultipleVariableDeclarations.errors.txt b/tests/baselines/reference/validMultipleVariableDeclarations.errors.txt new file mode 100644 index 0000000000000..8f751e9efeead --- /dev/null +++ b/tests/baselines/reference/validMultipleVariableDeclarations.errors.txt @@ -0,0 +1,45 @@ +tests/cases/conformance/statements/VariableStatements/validMultipleVariableDeclarations.ts(9,1): error TS7027: Unreachable code detected. + + +==== tests/cases/conformance/statements/VariableStatements/validMultipleVariableDeclarations.ts (1 errors) ==== + // all expected to be valid + + var x: number; + var x = 2; + if (true) { + var x = 3; + for (var x = 0; ;) { } + } + var x = undefined; + ~~~ +!!! error TS7027: Unreachable code detected. + + // new declaration space, making redeclaring x as a string valid + function declSpace() { + var x = 'this is a string'; + } + + interface Point { x: number; y: number; } + + var p: Point; + var p = { x: 1, y: 2 }; + var p: Point = { x: 0, y: undefined }; + var p = { x: 1, y: undefined }; + var p: { x: number; y: number; } = { x: 1, y: 2 }; + var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; + var p: typeof p; + + var fn = function (s: string) { return 42; } + var fn = (s: string) => 3; + var fn: (s: string) => number; + var fn: { (s: string): number }; + var fn = <(s: string) => number> null; + var fn: typeof fn; + + var a: string[]; + var a = ['a', 'b'] + var a = []; + var a: string[] = []; + var a = new Array(); + var a: typeof a; + \ No newline at end of file diff --git a/tests/baselines/reference/validMultipleVariableDeclarations.symbols b/tests/baselines/reference/validMultipleVariableDeclarations.symbols deleted file mode 100644 index 1c3a1feb75c9c..0000000000000 --- a/tests/baselines/reference/validMultipleVariableDeclarations.symbols +++ /dev/null @@ -1,118 +0,0 @@ -=== tests/cases/conformance/statements/VariableStatements/validMultipleVariableDeclarations.ts === -// all expected to be valid - -var x: number; ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 2, 3), Decl(validMultipleVariableDeclarations.ts, 3, 3), Decl(validMultipleVariableDeclarations.ts, 5, 7), Decl(validMultipleVariableDeclarations.ts, 6, 12), Decl(validMultipleVariableDeclarations.ts, 8, 3)) - -var x = 2; ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 2, 3), Decl(validMultipleVariableDeclarations.ts, 3, 3), Decl(validMultipleVariableDeclarations.ts, 5, 7), Decl(validMultipleVariableDeclarations.ts, 6, 12), Decl(validMultipleVariableDeclarations.ts, 8, 3)) - -if (true) { - var x = 3; ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 2, 3), Decl(validMultipleVariableDeclarations.ts, 3, 3), Decl(validMultipleVariableDeclarations.ts, 5, 7), Decl(validMultipleVariableDeclarations.ts, 6, 12), Decl(validMultipleVariableDeclarations.ts, 8, 3)) - - for (var x = 0; ;) { } ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 2, 3), Decl(validMultipleVariableDeclarations.ts, 3, 3), Decl(validMultipleVariableDeclarations.ts, 5, 7), Decl(validMultipleVariableDeclarations.ts, 6, 12), Decl(validMultipleVariableDeclarations.ts, 8, 3)) -} -var x = undefined; ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 2, 3), Decl(validMultipleVariableDeclarations.ts, 3, 3), Decl(validMultipleVariableDeclarations.ts, 5, 7), Decl(validMultipleVariableDeclarations.ts, 6, 12), Decl(validMultipleVariableDeclarations.ts, 8, 3)) ->undefined : Symbol(undefined) - -// new declaration space, making redeclaring x as a string valid -function declSpace() { ->declSpace : Symbol(declSpace, Decl(validMultipleVariableDeclarations.ts, 8, 26)) - - var x = 'this is a string'; ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 12, 7)) -} - -interface Point { x: number; y: number; } ->Point : Symbol(Point, Decl(validMultipleVariableDeclarations.ts, 13, 1)) ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 15, 17)) ->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 15, 28)) - -var p: Point; ->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3)) ->Point : Symbol(Point, Decl(validMultipleVariableDeclarations.ts, 13, 1)) - -var p = { x: 1, y: 2 }; ->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3)) ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 18, 9)) ->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 18, 15)) - -var p: Point = { x: 0, y: undefined }; ->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3)) ->Point : Symbol(Point, Decl(validMultipleVariableDeclarations.ts, 13, 1)) ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 19, 16)) ->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 19, 22)) ->undefined : Symbol(undefined) - -var p = { x: 1, y: undefined }; ->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3)) ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 20, 9)) ->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 20, 15)) ->undefined : Symbol(undefined) - -var p: { x: number; y: number; } = { x: 1, y: 2 }; ->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3)) ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 21, 8)) ->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 21, 19)) ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 21, 36)) ->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 21, 42)) - -var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3)) ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 22, 10)) ->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 22, 21)) ->x : Symbol(x, Decl(validMultipleVariableDeclarations.ts, 22, 36)) ->y : Symbol(y, Decl(validMultipleVariableDeclarations.ts, 22, 42)) ->undefined : Symbol(undefined) - -var p: typeof p; ->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3)) ->p : Symbol(p, Decl(validMultipleVariableDeclarations.ts, 17, 3), Decl(validMultipleVariableDeclarations.ts, 18, 3), Decl(validMultipleVariableDeclarations.ts, 19, 3), Decl(validMultipleVariableDeclarations.ts, 20, 3), Decl(validMultipleVariableDeclarations.ts, 21, 3), Decl(validMultipleVariableDeclarations.ts, 22, 3), Decl(validMultipleVariableDeclarations.ts, 23, 3)) - -var fn = function (s: string) { return 42; } ->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3)) ->s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 25, 19)) - -var fn = (s: string) => 3; ->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3)) ->s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 26, 10)) - -var fn: (s: string) => number; ->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3)) ->s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 27, 9)) - -var fn: { (s: string): number }; ->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3)) ->s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 28, 11)) - -var fn = <(s: string) => number> null; ->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3)) ->s : Symbol(s, Decl(validMultipleVariableDeclarations.ts, 29, 11)) - -var fn: typeof fn; ->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3)) ->fn : Symbol(fn, Decl(validMultipleVariableDeclarations.ts, 25, 3), Decl(validMultipleVariableDeclarations.ts, 26, 3), Decl(validMultipleVariableDeclarations.ts, 27, 3), Decl(validMultipleVariableDeclarations.ts, 28, 3), Decl(validMultipleVariableDeclarations.ts, 29, 3), Decl(validMultipleVariableDeclarations.ts, 30, 3)) - -var a: string[]; ->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)) - -var a = ['a', 'b'] ->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)) - -var 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)) - -var a: string[] = []; ->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)) - -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, --, --), 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)) ->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/validMultipleVariableDeclarations.types b/tests/baselines/reference/validMultipleVariableDeclarations.types deleted file mode 100644 index 966128350b018..0000000000000 --- a/tests/baselines/reference/validMultipleVariableDeclarations.types +++ /dev/null @@ -1,152 +0,0 @@ -=== tests/cases/conformance/statements/VariableStatements/validMultipleVariableDeclarations.ts === -// all expected to be valid - -var x: number; ->x : number - -var x = 2; ->x : number ->2 : number - -if (true) { ->true : boolean - - var x = 3; ->x : number ->3 : number - - for (var x = 0; ;) { } ->x : number ->0 : number -} -var x = undefined; ->x : number ->undefined : number ->undefined : undefined - -// new declaration space, making redeclaring x as a string valid -function declSpace() { ->declSpace : () => void - - var x = 'this is a string'; ->x : string ->'this is a string' : string -} - -interface Point { x: number; y: number; } ->Point : Point ->x : number ->y : number - -var p: Point; ->p : Point ->Point : Point - -var p = { x: 1, y: 2 }; ->p : Point ->{ x: 1, y: 2 } : { x: number; y: number; } ->x : number ->1 : number ->y : number ->2 : number - -var p: Point = { x: 0, y: undefined }; ->p : Point ->Point : Point ->{ x: 0, y: undefined } : { x: number; y: undefined; } ->x : number ->0 : number ->y : undefined ->undefined : undefined - -var p = { x: 1, y: undefined }; ->p : Point ->{ x: 1, y: undefined } : { x: number; y: number; } ->x : number ->1 : number ->y : number ->undefined : number ->undefined : undefined - -var p: { x: number; y: number; } = { x: 1, y: 2 }; ->p : Point ->x : number ->y : number ->{ x: 1, y: 2 } : { x: number; y: number; } ->x : number ->1 : number ->y : number ->2 : number - -var p = <{ x: number; y: number; }>{ x: 0, y: undefined }; ->p : Point -><{ x: number; y: number; }>{ x: 0, y: undefined } : { x: number; y: number; } ->x : number ->y : number ->{ x: 0, y: undefined } : { x: number; y: undefined; } ->x : number ->0 : number ->y : undefined ->undefined : undefined - -var p: typeof p; ->p : Point ->p : Point - -var fn = function (s: string) { return 42; } ->fn : (s: string) => number ->function (s: string) { return 42; } : (s: string) => number ->s : string ->42 : number - -var fn = (s: string) => 3; ->fn : (s: string) => number ->(s: string) => 3 : (s: string) => number ->s : string ->3 : number - -var fn: (s: string) => number; ->fn : (s: string) => number ->s : string - -var fn: { (s: string): number }; ->fn : (s: string) => number ->s : string - -var fn = <(s: string) => number> null; ->fn : (s: string) => number -><(s: string) => number> null : (s: string) => number ->s : string ->null : null - -var fn: typeof fn; ->fn : (s: string) => number ->fn : (s: string) => number - -var a: string[]; ->a : string[] - -var a = ['a', 'b'] ->a : string[] ->['a', 'b'] : string[] ->'a' : string ->'b' : string - -var a = []; ->a : string[] ->[] : string[] ->[] : undefined[] - -var a: string[] = []; ->a : string[] ->[] : undefined[] - -var a = new Array(); ->a : string[] ->new Array() : string[] ->Array : ArrayConstructor - -var a: typeof a; ->a : string[] ->a : string[] - diff --git a/tests/baselines/reference/whileBreakStatements.js b/tests/baselines/reference/whileBreakStatements.js index 818be39a242cb..15dffe3e582b9 100644 --- a/tests/baselines/reference/whileBreakStatements.js +++ b/tests/baselines/reference/whileBreakStatements.js @@ -1,4 +1,5 @@ //// [whileBreakStatements.ts] + while(true) { break; } diff --git a/tests/baselines/reference/whileBreakStatements.symbols b/tests/baselines/reference/whileBreakStatements.symbols index 2ac7721621da5..022fe9a12a83f 100644 --- a/tests/baselines/reference/whileBreakStatements.symbols +++ b/tests/baselines/reference/whileBreakStatements.symbols @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts === + while(true) { break; } @@ -38,7 +39,7 @@ while (true) EIGHT: while (true) { var fn = function () { } ->fn : Symbol(fn, Decl(whileBreakStatements.ts, 38, 7)) +>fn : Symbol(fn, Decl(whileBreakStatements.ts, 39, 7)) break EIGHT; } diff --git a/tests/baselines/reference/whileBreakStatements.types b/tests/baselines/reference/whileBreakStatements.types index e7ca0a5322fdd..a31d1e9b40e38 100644 --- a/tests/baselines/reference/whileBreakStatements.types +++ b/tests/baselines/reference/whileBreakStatements.types @@ -1,4 +1,5 @@ === tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts === + while(true) { >true : boolean diff --git a/tests/baselines/reference/whileContinueStatements.errors.txt b/tests/baselines/reference/whileContinueStatements.errors.txt new file mode 100644 index 0000000000000..c2009b02600ec --- /dev/null +++ b/tests/baselines/reference/whileContinueStatements.errors.txt @@ -0,0 +1,59 @@ +tests/cases/conformance/statements/continueStatements/whileContinueStatements.ts(5,1): error TS7027: Unreachable code detected. + + +==== tests/cases/conformance/statements/continueStatements/whileContinueStatements.ts (1 errors) ==== + while(true) { + continue; + } + + while (true) { + ~~~~~ +!!! error TS7027: Unreachable code detected. + if (true) { + continue; + } + } + + ONE: + + while (true) { + continue ONE; + } + + TWO: + THREE: + while (true) { + continue THREE; + } + + FOUR: + while (true) { + FIVE: + while (true) { + continue FOUR; + } + } + + while (true) { + SIX: + while (true) + continue SIX; + } + + SEVEN: + while (true) + while (true) + while (true) + continue SEVEN; + + EIGHT: + while (true) { + var fn = function () { } + continue EIGHT; + } + + NINE: + while (true) { + if (true) { continue NINE; } + } + \ No newline at end of file diff --git a/tests/baselines/reference/whileContinueStatements.symbols b/tests/baselines/reference/whileContinueStatements.symbols deleted file mode 100644 index 67508556f70cf..0000000000000 --- a/tests/baselines/reference/whileContinueStatements.symbols +++ /dev/null @@ -1,56 +0,0 @@ -=== tests/cases/conformance/statements/continueStatements/whileContinueStatements.ts === -while(true) { - continue; -} - -while (true) { - if (true) { - continue; - } -} - -ONE: - -while (true) { - continue ONE; -} - -TWO: -THREE: -while (true) { - continue THREE; -} - -FOUR: -while (true) { - FIVE: - while (true) { - continue FOUR; - } -} - -while (true) { - SIX: - while (true) - continue SIX; -} - -SEVEN: -while (true) - while (true) - while (true) - continue SEVEN; - -EIGHT: -while (true) { - var fn = function () { } ->fn : Symbol(fn, Decl(whileContinueStatements.ts, 44, 7)) - - continue EIGHT; -} - -NINE: -while (true) { - if (true) { continue NINE; } -} - diff --git a/tests/baselines/reference/whileContinueStatements.types b/tests/baselines/reference/whileContinueStatements.types deleted file mode 100644 index 6bf371cde9edb..0000000000000 --- a/tests/baselines/reference/whileContinueStatements.types +++ /dev/null @@ -1,110 +0,0 @@ -=== tests/cases/conformance/statements/continueStatements/whileContinueStatements.ts === -while(true) { ->true : boolean - - continue; -} - -while (true) { ->true : boolean - - if (true) { ->true : boolean - - continue; - } -} - -ONE: ->ONE : any - -while (true) { ->true : boolean - - continue ONE; ->ONE : any -} - -TWO: ->TWO : any - -THREE: ->THREE : any - -while (true) { ->true : boolean - - continue THREE; ->THREE : any -} - -FOUR: ->FOUR : any - -while (true) { ->true : boolean - - FIVE: ->FIVE : any - - while (true) { ->true : boolean - - continue FOUR; ->FOUR : any - } -} - -while (true) { ->true : boolean - - SIX: ->SIX : any - - while (true) ->true : boolean - - continue SIX; ->SIX : any -} - -SEVEN: ->SEVEN : any - -while (true) ->true : boolean - - while (true) ->true : boolean - - while (true) ->true : boolean - - continue SEVEN; ->SEVEN : any - -EIGHT: ->EIGHT : any - -while (true) { ->true : boolean - - var fn = function () { } ->fn : () => void ->function () { } : () => void - - continue EIGHT; ->EIGHT : any -} - -NINE: ->NINE : any - -while (true) { ->true : boolean - - if (true) { continue NINE; } ->true : boolean ->NINE : any -} - diff --git a/tests/cases/compiler/bestCommonTypeReturnStatement.ts b/tests/cases/compiler/bestCommonTypeReturnStatement.ts index aff173664f60d..cb481147f9b8b 100644 --- a/tests/cases/compiler/bestCommonTypeReturnStatement.ts +++ b/tests/cases/compiler/bestCommonTypeReturnStatement.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + interface IPromise { then(successCallback: (promiseValue: T) => any, errorCallback?: (reason: any) => any): IPromise; } diff --git a/tests/cases/compiler/breakTarget3.ts b/tests/cases/compiler/breakTarget3.ts index 9cef599692c30..64a9357706fb0 100644 --- a/tests/cases/compiler/breakTarget3.ts +++ b/tests/cases/compiler/breakTarget3.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target1: target2: while (true) { diff --git a/tests/cases/compiler/breakTarget4.ts b/tests/cases/compiler/breakTarget4.ts index 2c3eadca7dbcd..3e00bca659b90 100644 --- a/tests/cases/compiler/breakTarget4.ts +++ b/tests/cases/compiler/breakTarget4.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target1: target2: while (true) { diff --git a/tests/cases/compiler/breakTarget5.ts b/tests/cases/compiler/breakTarget5.ts index a05ee1cf8793a..f0bceb5015f2f 100644 --- a/tests/cases/compiler/breakTarget5.ts +++ b/tests/cases/compiler/breakTarget5.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target: while (true) { function f() { diff --git a/tests/cases/compiler/capturedLetConstInLoop9.ts b/tests/cases/compiler/capturedLetConstInLoop9.ts index 8163a75c20bf4..4b67349690d6f 100644 --- a/tests/cases/compiler/capturedLetConstInLoop9.ts +++ b/tests/cases/compiler/capturedLetConstInLoop9.ts @@ -74,9 +74,8 @@ function foo() { break l0; } - return 100; - () => b + return 100; } diff --git a/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts index e11cf6d344a0f..25c696ff7e641 100644 --- a/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts +++ b/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts @@ -75,10 +75,8 @@ function foo() { if (b === 2) { break l0; } - - return 100; - () => b + return 100; } diff --git a/tests/cases/compiler/commentEmitAtEndOfFile1.ts b/tests/cases/compiler/commentEmitAtEndOfFile1.ts index b1b863890d5f4..5713ef006e5fc 100644 --- a/tests/cases/compiler/commentEmitAtEndOfFile1.ts +++ b/tests/cases/compiler/commentEmitAtEndOfFile1.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + // test var f = '' // test #2 diff --git a/tests/cases/compiler/commentsAtEndOfFile1.ts b/tests/cases/compiler/commentsAtEndOfFile1.ts index 8e37b2361a545..04c90b3433a6c 100644 --- a/tests/cases/compiler/commentsAtEndOfFile1.ts +++ b/tests/cases/compiler/commentsAtEndOfFile1.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + Input: ; //Testing two diff --git a/tests/cases/compiler/conditionalExpressions2.ts b/tests/cases/compiler/conditionalExpressions2.ts index 6f2f097f6dedc..ece002d7778fc 100644 --- a/tests/cases/compiler/conditionalExpressions2.ts +++ b/tests/cases/compiler/conditionalExpressions2.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + var a = false ? 1 : null; var b = false ? undefined : 0; var c = false ? 1 : 0; diff --git a/tests/cases/compiler/constDeclarations-invalidContexts.ts b/tests/cases/compiler/constDeclarations-invalidContexts.ts index b509318099012..6d21ee31ec243 100644 --- a/tests/cases/compiler/constDeclarations-invalidContexts.ts +++ b/tests/cases/compiler/constDeclarations-invalidContexts.ts @@ -1,3 +1,4 @@ +// @allowUnreachableCode: true // @target: ES6 // Errors, const must be defined inside a block diff --git a/tests/cases/compiler/constDeclarations-validContexts.ts b/tests/cases/compiler/constDeclarations-validContexts.ts index ffde8e45d6fa1..63af6d169597d 100644 --- a/tests/cases/compiler/constDeclarations-validContexts.ts +++ b/tests/cases/compiler/constDeclarations-validContexts.ts @@ -1,3 +1,4 @@ +// @allowUnreachableCode: true // @target: ES6 diff --git a/tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts b/tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts index a93628e5494c8..63e0fc30141f9 100644 --- a/tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts +++ b/tests/cases/compiler/constructorWithIncompleteTypeAnnotation.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + declare module "fs" { export class File { constructor(filename: string); diff --git a/tests/cases/compiler/continueNotInIterationStatement4.ts b/tests/cases/compiler/continueNotInIterationStatement4.ts index 5996eb4323af8..218cb151df3d1 100644 --- a/tests/cases/compiler/continueNotInIterationStatement4.ts +++ b/tests/cases/compiler/continueNotInIterationStatement4.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + TWO: while (true){ var x = () => { diff --git a/tests/cases/compiler/continueTarget3.ts b/tests/cases/compiler/continueTarget3.ts index 26bea241a7a36..a7b47ff071bd6 100644 --- a/tests/cases/compiler/continueTarget3.ts +++ b/tests/cases/compiler/continueTarget3.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target1: target2: while (true) { diff --git a/tests/cases/compiler/continueTarget4.ts b/tests/cases/compiler/continueTarget4.ts index e00c222aa9ca7..5ba2bd69b1173 100644 --- a/tests/cases/compiler/continueTarget4.ts +++ b/tests/cases/compiler/continueTarget4.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target1: target2: while (true) { diff --git a/tests/cases/compiler/continueTarget5.ts b/tests/cases/compiler/continueTarget5.ts index dd3a806ab2dba..5f3d068282b6b 100644 --- a/tests/cases/compiler/continueTarget5.ts +++ b/tests/cases/compiler/continueTarget5.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target: while (true) { function f() { diff --git a/tests/cases/compiler/downlevelLetConst16.ts b/tests/cases/compiler/downlevelLetConst16.ts index 30a27ba61f48a..b30f26b4b82f9 100644 --- a/tests/cases/compiler/downlevelLetConst16.ts +++ b/tests/cases/compiler/downlevelLetConst16.ts @@ -1,4 +1,6 @@ // @target:es5 +// @allowUnreachableCode: true + 'use strict' declare function use(a: any); diff --git a/tests/cases/compiler/downlevelLetConst17.ts b/tests/cases/compiler/downlevelLetConst17.ts index b581281f67975..7cea2031ac5b6 100644 --- a/tests/cases/compiler/downlevelLetConst17.ts +++ b/tests/cases/compiler/downlevelLetConst17.ts @@ -1,4 +1,5 @@ // @target:es5 +// @allowUnreachableCode: true 'use strict' declare function use(a: any); diff --git a/tests/cases/compiler/downlevelLetConst18.ts b/tests/cases/compiler/downlevelLetConst18.ts index 59f2ee7a46ee3..61cb2f46cc987 100644 --- a/tests/cases/compiler/downlevelLetConst18.ts +++ b/tests/cases/compiler/downlevelLetConst18.ts @@ -1,4 +1,6 @@ // @target:es5 +// @allowUnreachableCode: true + 'use strict' for (let x; ;) { @@ -6,7 +8,7 @@ for (let x; ;) { } for (let x; ;) { - function foo() { x }; + function foo1() { x }; } for (let x; ;) { diff --git a/tests/cases/compiler/duplicateLabel1.ts b/tests/cases/compiler/duplicateLabel1.ts index c588e7b81837d..ff248c6454858 100644 --- a/tests/cases/compiler/duplicateLabel1.ts +++ b/tests/cases/compiler/duplicateLabel1.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target: target: while (true) { diff --git a/tests/cases/compiler/duplicateLabel2.ts b/tests/cases/compiler/duplicateLabel2.ts index bdb0396a246a2..5ebf273c1187f 100644 --- a/tests/cases/compiler/duplicateLabel2.ts +++ b/tests/cases/compiler/duplicateLabel2.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target: while (true) { target: diff --git a/tests/cases/compiler/duplicateLabel3.ts b/tests/cases/compiler/duplicateLabel3.ts index d4db9399ed232..d6add9804471f 100644 --- a/tests/cases/compiler/duplicateLabel3.ts +++ b/tests/cases/compiler/duplicateLabel3.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target: while (true) { function f() { diff --git a/tests/cases/compiler/duplicateLabel4.ts b/tests/cases/compiler/duplicateLabel4.ts index 2c62180a2ab69..bf7ea5c22c6a4 100644 --- a/tests/cases/compiler/duplicateLabel4.ts +++ b/tests/cases/compiler/duplicateLabel4.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + target: while (true) { } diff --git a/tests/cases/compiler/duplicateLocalVariable1.ts b/tests/cases/compiler/duplicateLocalVariable1.ts index fc20a19c2d99b..f6288cfc6ae4e 100644 --- a/tests/cases/compiler/duplicateLocalVariable1.ts +++ b/tests/cases/compiler/duplicateLocalVariable1.ts @@ -1,4 +1,6 @@ -//@module: commonjs + +// @allowUnreachableCode: true +/ /@module: commonjs //import FileManager = require('filemanager'); //import App = require('app'); diff --git a/tests/cases/compiler/duplicateVariablesByScope.ts b/tests/cases/compiler/duplicateVariablesByScope.ts index 481c1bb950ebb..dc811130d4fb7 100644 --- a/tests/cases/compiler/duplicateVariablesByScope.ts +++ b/tests/cases/compiler/duplicateVariablesByScope.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + // duplicate local variables are only reported at global scope module M { diff --git a/tests/cases/compiler/es6ClassSuperCodegenBug.ts b/tests/cases/compiler/es6ClassSuperCodegenBug.ts index 7ab8344c81509..2e3f306d5d68b 100644 --- a/tests/cases/compiler/es6ClassSuperCodegenBug.ts +++ b/tests/cases/compiler/es6ClassSuperCodegenBug.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + class A { constructor(str1:string, str2:string) {} } diff --git a/tests/cases/compiler/escapedIdentifiers.ts b/tests/cases/compiler/escapedIdentifiers.ts index 795aeca2481ac..c58c59d9b4241 100644 --- a/tests/cases/compiler/escapedIdentifiers.ts +++ b/tests/cases/compiler/escapedIdentifiers.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + /* 0 .. \u0030 9 .. \u0039 diff --git a/tests/cases/compiler/for.ts b/tests/cases/compiler/for.ts index e27dab7dbd222..636c7e4a5fc33 100644 --- a/tests/cases/compiler/for.ts +++ b/tests/cases/compiler/for.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + for (var i = 0; i < 10; i++) { // ok var x1 = i; } diff --git a/tests/cases/compiler/functionOverloads12.ts b/tests/cases/compiler/functionOverloads12.ts index 3e8a9882d0876..48a8af06cc5de 100644 --- a/tests/cases/compiler/functionOverloads12.ts +++ b/tests/cases/compiler/functionOverloads12.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + function foo():string; function foo():number; function foo():any { if (true) return ""; else return 0;} diff --git a/tests/cases/compiler/functionReturn.ts b/tests/cases/compiler/functionReturn.ts index 8ea0cb8f5a1b9..897480c64d61e 100644 --- a/tests/cases/compiler/functionReturn.ts +++ b/tests/cases/compiler/functionReturn.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + function f0(): void { } function f1() { var n: any = f0(); diff --git a/tests/cases/compiler/functionWithNoBestCommonType1.ts b/tests/cases/compiler/functionWithNoBestCommonType1.ts index 1162881292531..2d7a1191770b1 100644 --- a/tests/cases/compiler/functionWithNoBestCommonType1.ts +++ b/tests/cases/compiler/functionWithNoBestCommonType1.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + function foo() { return true; return bar(); diff --git a/tests/cases/compiler/functionWithNoBestCommonType2.ts b/tests/cases/compiler/functionWithNoBestCommonType2.ts index 974ccdfe035d4..6bc3878d834ff 100644 --- a/tests/cases/compiler/functionWithNoBestCommonType2.ts +++ b/tests/cases/compiler/functionWithNoBestCommonType2.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + var v = function () { return true; return bar(); diff --git a/tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts b/tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts index 81259fd7c0c7f..fde615af41db5 100644 --- a/tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts +++ b/tests/cases/compiler/functionsMissingReturnStatementsAndExpressions.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + // @target: es5 function f1(): string { diff --git a/tests/cases/compiler/ifElseWithStatements1.ts b/tests/cases/compiler/ifElseWithStatements1.ts index a7f337068cb10..5ed7f7dd7a31b 100644 --- a/tests/cases/compiler/ifElseWithStatements1.ts +++ b/tests/cases/compiler/ifElseWithStatements1.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + if (true) f(); else diff --git a/tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts b/tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts index d150fb1930a98..6465e7f12000e 100644 --- a/tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts +++ b/tests/cases/compiler/inferredFunctionReturnTypeIsEmptyType.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + function foo() { if (true) { return 42; diff --git a/tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts b/tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts index 2620e7d88d4c5..e325ae4582aad 100644 --- a/tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts +++ b/tests/cases/compiler/inheritanceStaticPropertyOverridingAccessor.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + class a { static get x(): () => string { return null;; diff --git a/tests/cases/compiler/letAndVarRedeclaration.ts b/tests/cases/compiler/letAndVarRedeclaration.ts index 1f901ded5207e..aaf2ce1a68cde 100644 --- a/tests/cases/compiler/letAndVarRedeclaration.ts +++ b/tests/cases/compiler/letAndVarRedeclaration.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + // @target: es6 let e0 diff --git a/tests/cases/compiler/letDeclarations-invalidContexts.ts b/tests/cases/compiler/letDeclarations-invalidContexts.ts index 4d165ba2cda0e..cde6c2006bbe9 100644 --- a/tests/cases/compiler/letDeclarations-invalidContexts.ts +++ b/tests/cases/compiler/letDeclarations-invalidContexts.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + // @target: ES6 // Errors, let must be defined inside a block diff --git a/tests/cases/compiler/letDeclarations-scopes.ts b/tests/cases/compiler/letDeclarations-scopes.ts index 93f4ce5b4ed0f..b050a5e9bd0ff 100644 --- a/tests/cases/compiler/letDeclarations-scopes.ts +++ b/tests/cases/compiler/letDeclarations-scopes.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + // @target: ES6 // global diff --git a/tests/cases/compiler/letDeclarations-validContexts.ts b/tests/cases/compiler/letDeclarations-validContexts.ts index baedfa2644cb0..2a4022901c151 100644 --- a/tests/cases/compiler/letDeclarations-validContexts.ts +++ b/tests/cases/compiler/letDeclarations-validContexts.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + // @target: ES6 diff --git a/tests/cases/compiler/null.ts b/tests/cases/compiler/null.ts index eb88d387bccb1..e8fa9a5d68724 100644 --- a/tests/cases/compiler/null.ts +++ b/tests/cases/compiler/null.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + var x=null; var y=3+x; var z=3+null; diff --git a/tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts b/tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts index 21884031aec0c..12b99fb29ceae 100644 --- a/tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts +++ b/tests/cases/compiler/overloadOnConstAsTypeAnnotation.ts @@ -1 +1,3 @@ +// @allowUnreachableCode: true + var f: (x: 'hi') => number = ('hi') => { return 1; }; \ No newline at end of file diff --git a/tests/cases/compiler/reachabilityChecks1.ts b/tests/cases/compiler/reachabilityChecks1.ts new file mode 100644 index 0000000000000..6430556a203b7 --- /dev/null +++ b/tests/cases/compiler/reachabilityChecks1.ts @@ -0,0 +1,76 @@ +// @allowUnreachableCode: false +// @preserveConstEnums: true + +while (true); +var x = 1; + +module A { + while (true); + let x; +} + +module A1 { + do {} while(true); + module A { + interface F {} + } +} + +module A2 { + while (true); + module A { + var x = 1; + } +} + +module A3 { + while (true); + type T = string; +} + +module A4 { + while (true); + module A { + const enum E { X } + } +} + +function f1(x) { + if (x) { + return; + } + else { + throw new Error("123"); + } + var x; +} + +function f2() { + return; + class A { + } +} + +module B { + for (; ;); + module C { + } +} + +function f3() { + do { + } while (true); + enum E { + X = 1 + } +} + +function f4() { + if (true) { + throw new Error(); + } + const enum E { + X = 1 + } +} + diff --git a/tests/cases/compiler/reachabilityChecks2.ts b/tests/cases/compiler/reachabilityChecks2.ts new file mode 100644 index 0000000000000..5a7a8aaab58e3 --- /dev/null +++ b/tests/cases/compiler/reachabilityChecks2.ts @@ -0,0 +1,13 @@ +// @allowUnreachableCode: false +// @preserveConstEnums: false + +while (true) { } +const enum E { X } + +module A4 { + while (true); + module A { + const enum E { X } + } +} + diff --git a/tests/cases/compiler/reachabilityChecks3.ts b/tests/cases/compiler/reachabilityChecks3.ts new file mode 100644 index 0000000000000..19f57e55b6738 --- /dev/null +++ b/tests/cases/compiler/reachabilityChecks3.ts @@ -0,0 +1,16 @@ +// @allowUnusedLabels: false + +let x = 1; +loop: while (true) { + if (x == 100) { + break; + } + else { + x++; + } +} +{ + x: 100 +} + +var y = () => { f: 1 } \ No newline at end of file diff --git a/tests/cases/compiler/reachabilityChecks4.ts b/tests/cases/compiler/reachabilityChecks4.ts new file mode 100644 index 0000000000000..f07395ac38ec5 --- /dev/null +++ b/tests/cases/compiler/reachabilityChecks4.ts @@ -0,0 +1,15 @@ +// @noFallthroughCasesInSwitch: true + +function foo(x, y) { + switch (x) { + case 1: + case 2: + return 1; + case 3: + if (y) { + return 2; + } + case 4: + return 3; + } +} \ No newline at end of file diff --git a/tests/cases/compiler/reachabilityChecks5.ts b/tests/cases/compiler/reachabilityChecks5.ts new file mode 100644 index 0000000000000..97df11ccb79bb --- /dev/null +++ b/tests/cases/compiler/reachabilityChecks5.ts @@ -0,0 +1,131 @@ +// @allowUnreachableCode: false +// @noImplicitReturns: true + +function f0(x): number { + while (true); +} + +function f1(x): number { + if (x) { + return 1 + } +} + +function f2(x): number { + while (x) { + throw new Error(); + } + return 1; +} + +function f3(x): number { + while (x) { + throw new Error(); + } +} + +function f3_1 (x): number { + while (x) { + } + throw new Error(); +} + +function f4(x): number { + try { + if (x) { + return 1; + } + } + catch (e) { + } +} + +function f5(x): number { + try { + if (x) { + return 1; + } + } + catch (e) { + return 2; + } +} + +function f6(x): number { + try { + if (x) { + return 1; + } + else + { + throw new Error(); + } + } + catch (e) { + } +} + +function f7(x): number { + try { + if (x) { + return 1; + } + else { + throw new Error(); + } + } + catch (e) { + return 1; + } +} + +function f8(x): number { + try { + if (true) { + x++; + } + else { + return 1; + } + } + catch (e) { + return 1; + } +} + +function f9(x): number { + try { + while (false) { + return 1; + } + } + catch (e) { + return 1; + } +} + +function f10(x): number { + try { + do { + x++; + } while (true); + } + catch (e) { + return 1; + } +} + +function f11(x): number { + test: + try { + do { + do { + break test; + } while (true); + x++; + } while (true); + } + catch (e) { + return 1; + } +} \ No newline at end of file diff --git a/tests/cases/compiler/recursiveMods.ts b/tests/cases/compiler/recursiveMods.ts index fa07646ba72b6..84dbafff55829 100644 --- a/tests/cases/compiler/recursiveMods.ts +++ b/tests/cases/compiler/recursiveMods.ts @@ -1,4 +1,6 @@ -//@module: commonjs +// @allowUnreachableCode: true +// @module: commonjs + export module Foo { export class C {} } diff --git a/tests/cases/compiler/returnStatement1.ts b/tests/cases/compiler/returnStatement1.ts index e87635b37d7c1..06d1bdb956970 100644 --- a/tests/cases/compiler/returnStatement1.ts +++ b/tests/cases/compiler/returnStatement1.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + function f() { return function (s) { var x = s; diff --git a/tests/cases/compiler/sourceMapValidationLabeled.ts b/tests/cases/compiler/sourceMapValidationLabeled.ts index 5993e82aacc09..e36bdd9a0b340 100644 --- a/tests/cases/compiler/sourceMapValidationLabeled.ts +++ b/tests/cases/compiler/sourceMapValidationLabeled.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true // @sourcemap: true + x: var b = 10; \ No newline at end of file diff --git a/tests/cases/compiler/systemModule8.ts b/tests/cases/compiler/systemModule8.ts index c3e0c7c74373e..4490b2a85294f 100644 --- a/tests/cases/compiler/systemModule8.ts +++ b/tests/cases/compiler/systemModule8.ts @@ -1,3 +1,4 @@ +// @allowUnreachableCode: true // @module: system export var x; diff --git a/tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts b/tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts index b36f423be21fd..62311ee75c9e3 100644 --- a/tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts +++ b/tests/cases/conformance/expressions/assignmentOperator/compoundAssignmentLHSIsValue.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + // expected error for all the LHS of compound assignments (arithmetic and addition) var value; diff --git a/tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts b/tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts index cd0fb64e0d2d2..d6bfd84fd9a8c 100644 --- a/tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts +++ b/tests/cases/conformance/expressions/contextualTyping/generatedContextualTyping.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + class Base { private p; } class Derived1 extends Base { private m; } class Derived2 extends Base { private n; } diff --git a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithBooleanType.ts b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithBooleanType.ts index 00460181c2b61..c22ed94087b6b 100644 --- a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithBooleanType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithBooleanType.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + // typeof operator on boolean type var BOOLEAN: boolean; diff --git a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts index 9abb602db06bd..57b22e3646c1c 100644 --- a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + // typeof operator on enum type enum ENUM { }; diff --git a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts index 06ac3e297841e..81687e4f86098 100644 --- a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithNumberType.ts @@ -1,3 +1,4 @@ +// @allowUnusedLabels: true // typeof operator on number type var NUMBER: number; var NUMBER1: number[] = [1, 2]; diff --git a/tests/cases/conformance/functions/functionImplementationErrors.ts b/tests/cases/conformance/functions/functionImplementationErrors.ts index ddd3ba0a2c1b8..0a7c7812932f8 100644 --- a/tests/cases/conformance/functions/functionImplementationErrors.ts +++ b/tests/cases/conformance/functions/functionImplementationErrors.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + // FunctionExpression with no return type annotation with multiple return statements with unrelated types var f1 = function () { return ''; diff --git a/tests/cases/conformance/functions/functionImplementations.ts b/tests/cases/conformance/functions/functionImplementations.ts index df36a0b445799..3c5adefd2e40a 100644 --- a/tests/cases/conformance/functions/functionImplementations.ts +++ b/tests/cases/conformance/functions/functionImplementations.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + // FunctionExpression with no return type annotation and no return statement returns void var v: void = function () { } (); diff --git a/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts b/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts index 31407b88590cd..d35002e2f65fc 100644 --- a/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts +++ b/tests/cases/conformance/interfaces/interfacesExtendingClasses/interfaceExtendingClass2.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + class Foo { x: string; y() { } diff --git a/tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts b/tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts index cad137cc88dff..62c0153f2248c 100644 --- a/tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts +++ b/tests/cases/conformance/parser/ecmascript5/Fuzz/parser768531.ts @@ -1,2 +1,4 @@ +// @allowUnusedLabels: true + {a: 3} /x/ \ No newline at end of file diff --git a/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts b/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts index 9cef599692c30..64a9357706fb0 100644 --- a/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts +++ b/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget3.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target1: target2: while (true) { diff --git a/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts b/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts index 2c3eadca7dbcd..3e00bca659b90 100644 --- a/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts +++ b/tests/cases/conformance/parser/ecmascript5/Statements/BreakStatements/parser_breakTarget4.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target1: target2: while (true) { diff --git a/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts b/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts index 26bea241a7a36..a7b47ff071bd6 100644 --- a/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts +++ b/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget3.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target1: target2: while (true) { diff --git a/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts b/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts index e00c222aa9ca7..5ba2bd69b1173 100644 --- a/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts +++ b/tests/cases/conformance/parser/ecmascript5/Statements/ContinueStatements/parser_continueTarget4.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target1: target2: while (true) { diff --git a/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts b/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts index d4db9399ed232..d6add9804471f 100644 --- a/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts +++ b/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel3.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + target: while (true) { function f() { diff --git a/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts b/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts index 2c62180a2ab69..bf7ea5c22c6a4 100644 --- a/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts +++ b/tests/cases/conformance/parser/ecmascript5/Statements/LabeledStatements/parser_duplicateLabel4.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + target: while (true) { } diff --git a/tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts b/tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts index 88476ac4a7820..b35204beb4851 100644 --- a/tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts +++ b/tests/cases/conformance/parser/ecmascript5/parser10.1.1-8gs.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + /// Copyright (c) 2012 Ecma International. All rights reserved. /// Ecma International makes this code available under the terms and conditions set /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the diff --git a/tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts index 49bfaaca13fa9..cca94947a5da5 100644 --- a/tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts +++ b/tests/cases/conformance/statements/breakStatements/doWhileBreakStatements.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + do { break; } while(true) diff --git a/tests/cases/conformance/statements/breakStatements/forBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/forBreakStatements.ts index 20a93db441857..9cf07e1eef7d4 100644 --- a/tests/cases/conformance/statements/breakStatements/forBreakStatements.ts +++ b/tests/cases/conformance/statements/breakStatements/forBreakStatements.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + for (; ;) { break; } diff --git a/tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts index 5810d5221829c..ffc99ee904bf3 100644 --- a/tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts +++ b/tests/cases/conformance/statements/breakStatements/forInBreakStatements.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + for(var x in {}) { break; } diff --git a/tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts index 7c93553a726b8..d164691db68c3 100644 --- a/tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts +++ b/tests/cases/conformance/statements/breakStatements/invalidDoWhileBreakStatements.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + // All errors // naked break not allowed diff --git a/tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts index cc21818b80f14..142a8f8b3b5e8 100644 --- a/tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts +++ b/tests/cases/conformance/statements/breakStatements/invalidForBreakStatements.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + // All errors // naked break not allowed diff --git a/tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts index 9cda003e6f557..db49a13c8f743 100644 --- a/tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts +++ b/tests/cases/conformance/statements/breakStatements/invalidForInBreakStatements.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + // All errors // naked break not allowed diff --git a/tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts index f5ce6ffa52fbd..3080a6b38a82a 100644 --- a/tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts +++ b/tests/cases/conformance/statements/breakStatements/switchBreakStatements.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + switch ('') { case 'a': break; diff --git a/tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts b/tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts index c471e6552b92f..e2a836b62a348 100644 --- a/tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts +++ b/tests/cases/conformance/statements/breakStatements/whileBreakStatements.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + while(true) { break; } diff --git a/tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts index d3d999ccb4955..4685cc9f046c7 100644 --- a/tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts +++ b/tests/cases/conformance/statements/continueStatements/doWhileContinueStatements.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + do { continue; } while(true) diff --git a/tests/cases/conformance/statements/continueStatements/forContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/forContinueStatements.ts index 1f8a3fc7b68d6..9b852df80c7a9 100644 --- a/tests/cases/conformance/statements/continueStatements/forContinueStatements.ts +++ b/tests/cases/conformance/statements/continueStatements/forContinueStatements.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + for (; ;) { continue; } diff --git a/tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts index 863caec2ccf1e..b5ccd8189ca1b 100644 --- a/tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts +++ b/tests/cases/conformance/statements/continueStatements/forInContinueStatements.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + for(var x in {}) { continue; } diff --git a/tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts index 54192212ef79a..dcf543ed7e31f 100644 --- a/tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts +++ b/tests/cases/conformance/statements/continueStatements/invalidDoWhileContinueStatements.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + // All errors // naked continue not allowed diff --git a/tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts index 751cd9477ad35..ba367ef87b75d 100644 --- a/tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts +++ b/tests/cases/conformance/statements/continueStatements/invalidForContinueStatements.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + // All errors // naked continue not allowed diff --git a/tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts index be274005961d4..861d7e9062939 100644 --- a/tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts +++ b/tests/cases/conformance/statements/continueStatements/invalidForInContinueStatements.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + // All errors // naked continue not allowed diff --git a/tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts b/tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts index cf913671315f3..ef94466ffba33 100644 --- a/tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts +++ b/tests/cases/conformance/statements/continueStatements/invalidWhileContinueStatements.ts @@ -1,3 +1,6 @@ +// @allowUnusedLabels: true +// @allowUnreachableCode: true + // All errors // naked continue not allowed diff --git a/tests/cases/conformance/statements/forStatements/forStatements.ts b/tests/cases/conformance/statements/forStatements/forStatements.ts index 567c49c1098a9..1e65bdc293216 100644 --- a/tests/cases/conformance/statements/forStatements/forStatements.ts +++ b/tests/cases/conformance/statements/forStatements/forStatements.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + interface I { id: number; } diff --git a/tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts b/tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts index 0c2bb3d40dced..64317b233369d 100644 --- a/tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts +++ b/tests/cases/conformance/statements/forStatements/forStatementsMultipleInvalidDecl.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + interface I { id: number; } diff --git a/tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts b/tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts index 9f5557e7756f6..af19fd404dfe3 100644 --- a/tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts +++ b/tests/cases/conformance/statements/forStatements/forStatementsMultipleValidDecl.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + // all expected to be valid for (var x: number; ;) { } diff --git a/tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts b/tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts index f2cd9aa43eec2..03f042401d822 100644 --- a/tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts +++ b/tests/cases/conformance/statements/ifDoWhileStatements/ifDoWhileStatements.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + interface I { id: number; } diff --git a/tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts b/tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts index aa382d4ec3485..8cc294d01f7b0 100644 --- a/tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts +++ b/tests/cases/conformance/statements/throwStatements/invalidThrowStatement.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + throw; export throw null; diff --git a/tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts b/tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts index 4b9675f9d63b8..c5875327b50af 100644 --- a/tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts +++ b/tests/cases/conformance/statements/throwStatements/throwInEnclosingStatements.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + function fn(x) { throw x; } diff --git a/tests/cases/conformance/statements/throwStatements/throwStatements.ts b/tests/cases/conformance/statements/throwStatements/throwStatements.ts index 8d155cbc8cf16..07c09da93fc68 100644 --- a/tests/cases/conformance/statements/throwStatements/throwStatements.ts +++ b/tests/cases/conformance/statements/throwStatements/throwStatements.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + // all legal interface I { diff --git a/tests/cases/conformance/types/localTypes/localTypes4.ts b/tests/cases/conformance/types/localTypes/localTypes4.ts index bd31e76a80f86..388d5efb637d4 100644 --- a/tests/cases/conformance/types/localTypes/localTypes4.ts +++ b/tests/cases/conformance/types/localTypes/localTypes4.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + function f1() { // Type parameters are in scope in parameters and return types function f(x: T): T { diff --git a/tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts b/tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts index c249d2e5671c5..5cb52588644c2 100644 --- a/tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts +++ b/tests/cases/conformance/types/namedTypes/interfaceWithPrivateMember.ts @@ -1,3 +1,5 @@ +// @allowUnusedLabels: true + // interfaces do not permit private members, these are errors interface I { diff --git a/tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts b/tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts index 7ea4f414e151b..1cc499c7d6e03 100644 --- a/tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts +++ b/tests/cases/conformance/types/objectTypeLiteral/callSignatures/callSignatureWithoutReturnTypeAnnotationInference.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + // Call signatures without a return type should infer one from the function body (if present) // Simple types diff --git a/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts b/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts index 9b12363ff08a9..9864ddab4887a 100644 --- a/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts +++ b/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + // return type of a function with multiple returns is the BCT of each return statement // it is an error if there is no single BCT, these are error cases diff --git a/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts b/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts index 41d4fddfbebe5..03021bfdd106b 100644 --- a/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts +++ b/tests/cases/conformance/types/typeRelationships/bestCommonType/functionWithMultipleReturnStatements2.ts @@ -1,3 +1,5 @@ +// @allowUnreachableCode: true + // return type of a function with multiple returns is the BCT of each return statement // no errors expected here diff --git a/tests/cases/fourslash/unclosedFunctionErrorRecovery3.ts b/tests/cases/fourslash/unclosedFunctionErrorRecovery3.ts index bcb79811a6276..7a52ddc2c328a 100644 --- a/tests/cases/fourslash/unclosedFunctionErrorRecovery3.ts +++ b/tests/cases/fourslash/unclosedFunctionErrorRecovery3.ts @@ -1,4 +1,5 @@ /// +// @allowUnreachableCode: true //// class alpha { static beta() return 5; } } //// /**/ var gamma = alpha.beta() * 5; diff --git a/tests/webTestServer.ts b/tests/webTestServer.ts index 18a1f05d47ba4..6ddc18f1344cf 100644 --- a/tests/webTestServer.ts +++ b/tests/webTestServer.ts @@ -192,7 +192,6 @@ function getRequestOperation(req: http.ServerRequest, filename: string) { } return RequestType.Unknown } - return RequestType.Unknown } function handleRequestOperation(req: http.ServerRequest, res: http.ServerResponse, operation: RequestType, reqPath: string) {