diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 72b9e4acadedb..b01352968eb42 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -1000,6 +1000,7 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { const saveExceptionTarget = currentExceptionTarget; const saveActiveLabelList = activeLabelList; const saveHasExplicitReturn = hasExplicitReturn; + const saveSeenThisKeyword = seenThisKeyword; const isImmediatelyInvoked = ( containerFlags & ContainerFlags.IsFunctionExpression && !hasSyntacticModifier(node, ModifierFlags.Async) && @@ -1022,19 +1023,22 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { currentContinueTarget = undefined; activeLabelList = undefined; hasExplicitReturn = false; + seenThisKeyword = false; bindChildren(node); - // Reset all reachability check related flags on node (for incremental scenarios) - node.flags &= ~NodeFlags.ReachabilityAndEmitFlags; + // Reset flags (for incremental scenarios) + node.flags &= ~(NodeFlags.ReachabilityAndEmitFlags | NodeFlags.ContainsThis); if (!(currentFlow.flags & FlowFlags.Unreachable) && containerFlags & ContainerFlags.IsFunctionLike && nodeIsPresent((node as FunctionLikeDeclaration | ClassStaticBlockDeclaration).body)) { node.flags |= NodeFlags.HasImplicitReturn; if (hasExplicitReturn) node.flags |= NodeFlags.HasExplicitReturn; (node as FunctionLikeDeclaration | ClassStaticBlockDeclaration).endFlowNode = currentFlow; } + if (seenThisKeyword) { + node.flags |= NodeFlags.ContainsThis; + } if (node.kind === SyntaxKind.SourceFile) { node.flags |= emitFlags; (node as SourceFile).endFlowNode = currentFlow; } - if (currentReturnTarget) { addAntecedent(currentReturnTarget, currentFlow); currentFlow = finishFlowLabel(currentReturnTarget); @@ -1051,12 +1055,15 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { currentExceptionTarget = saveExceptionTarget; activeLabelList = saveActiveLabelList; hasExplicitReturn = saveHasExplicitReturn; + seenThisKeyword = node.kind === SyntaxKind.ArrowFunction ? saveSeenThisKeyword || seenThisKeyword : saveSeenThisKeyword; } else if (containerFlags & ContainerFlags.IsInterface) { + const saveSeenThisKeyword = seenThisKeyword; seenThisKeyword = false; bindChildren(node); Debug.assertNotNode(node, isIdentifier); // ContainsThis cannot overlap with HasExtendedUnicodeEscape on Identifier node.flags = seenThisKeyword ? node.flags | NodeFlags.ContainsThis : node.flags & ~NodeFlags.ContainsThis; + seenThisKeyword = saveSeenThisKeyword; } else { bindChildren(node); @@ -2852,6 +2859,9 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { } // falls through case SyntaxKind.ThisKeyword: + if (node.kind === SyntaxKind.ThisKeyword) { + seenThisKeyword = true; + } // TODO: Why use `isExpression` here? both Identifier and ThisKeyword are expressions. if (currentFlow && (isExpression(node) || parent.kind === SyntaxKind.ShorthandPropertyAssignment)) { (node as Identifier | ThisExpression).flowNode = currentFlow; @@ -3833,6 +3843,8 @@ export function getContainerFlags(node: Node): ContainerFlags { // falls through case SyntaxKind.Constructor: case SyntaxKind.FunctionDeclaration: + case SyntaxKind.ClassStaticBlockDeclaration: + return ContainerFlags.IsContainer | ContainerFlags.IsControlFlowContainer | ContainerFlags.HasLocals | ContainerFlags.IsFunctionLike; case SyntaxKind.MethodSignature: case SyntaxKind.CallSignature: case SyntaxKind.JSDocSignature: @@ -3840,12 +3852,11 @@ export function getContainerFlags(node: Node): ContainerFlags { case SyntaxKind.FunctionType: case SyntaxKind.ConstructSignature: case SyntaxKind.ConstructorType: - case SyntaxKind.ClassStaticBlockDeclaration: - return ContainerFlags.IsContainer | ContainerFlags.IsControlFlowContainer | ContainerFlags.HasLocals | ContainerFlags.IsFunctionLike; + return ContainerFlags.IsContainer | ContainerFlags.HasLocals | ContainerFlags.IsFunctionLike; case SyntaxKind.JSDocImportTag: // treat as a container to prevent using an enclosing effective host, ensuring import bindings are scoped correctly - return ContainerFlags.IsContainer | ContainerFlags.IsControlFlowContainer | ContainerFlags.HasLocals; + return ContainerFlags.IsContainer | ContainerFlags.HasLocals; case SyntaxKind.FunctionExpression: case SyntaxKind.ArrowFunction: @@ -3853,8 +3864,6 @@ export function getContainerFlags(node: Node): ContainerFlags { case SyntaxKind.ModuleBlock: return ContainerFlags.IsControlFlowContainer; - case SyntaxKind.PropertyDeclaration: - return (node as PropertyDeclaration).initializer ? ContainerFlags.IsControlFlowContainer : 0; case SyntaxKind.CatchClause: case SyntaxKind.ForStatement: diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 74663e107cc66..b2f82e335fbdd 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -21143,9 +21143,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { const { initializer } = node as JsxAttribute; return !!initializer && isContextSensitive(initializer); } - case SyntaxKind.JsxExpression: { + case SyntaxKind.JsxExpression: + case SyntaxKind.YieldExpression: { // It is possible to that node.expression is undefined (e.g
) - const { expression } = node as JsxExpression; + const { expression } = node as JsxExpression | YieldExpression; return !!expression && isContextSensitive(expression); } } @@ -21154,7 +21155,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { } function isContextSensitiveFunctionLikeDeclaration(node: FunctionLikeDeclaration): boolean { - return hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node); + return hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node) || hasContextSensitiveYieldExpression(node); } function hasContextSensitiveReturnExpression(node: FunctionLikeDeclaration) { @@ -21167,6 +21168,17 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { return !!forEachReturnStatement(node.body as Block, statement => !!statement.expression && isContextSensitive(statement.expression)); } + function hasContextSensitiveYieldExpression(node: FunctionLikeDeclaration): boolean { + // yield expressions can be context sensitive in situations like: + // + // declare function test(gen: () => Generator<(arg: number) => string, void, void>): void; + // + // test(function* () { + // yield (arg) => String(arg); + // }); + return !!(getFunctionFlags(node) & FunctionFlags.Generator && node.body && forEachYieldExpression(node.body as Block, isContextSensitive)); + } + function isContextSensitiveFunctionOrObjectLiteralMethod(func: Node): func is FunctionExpression | ArrowFunction | MethodDeclaration { return (isFunctionExpressionOrArrowFunction(func) || isObjectLiteralMethod(func)) && isContextSensitiveFunctionLikeDeclaration(func); @@ -32629,7 +32641,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { if (inferenceContext && contextFlags! & ContextFlags.Signature && some(inferenceContext.inferences, hasInferenceCandidatesOrDefault)) { // For contextual signatures we incorporate all inferences made so far, e.g. from return // types as well as arguments to the left in a function call. - return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper); + const type = instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper); + if (!(type.flags & TypeFlags.AnyOrUnknown)) { + return type; + } } if (inferenceContext?.returnMapper) { // For other purposes (e.g. determining whether to produce literal types) we only @@ -32637,9 +32652,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { // the 'boolean' type from the contextual type such that contextually typed boolean // literals actually end up widening to 'boolean' (see #48363). const type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper); - return type.flags & TypeFlags.Union && containsType((type as UnionType).types, regularFalseType) && containsType((type as UnionType).types, regularTrueType) ? - filterType(type, t => t !== regularFalseType && t !== regularTrueType) : - type; + if (!(type.flags & TypeFlags.AnyOrUnknown)) { + return type.flags & TypeFlags.Union && containsType((type as UnionType).types, regularFalseType) && containsType((type as UnionType).types, regularTrueType) ? + filterType(type, t => t !== regularFalseType && t !== regularTrueType) : + type; + } } } return contextualType; diff --git a/src/compiler/types.ts b/src/compiler/types.ts index cdba2e880afc3..bdb213f622451 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -6526,7 +6526,7 @@ export const enum ObjectFlags { /** @internal */ ContainsObjectOrArrayLiteral = 1 << 17, // Type is or contains object literal type /** @internal */ - NonInferrableType = 1 << 18, // Type is or contains anyFunctionType or silentNeverType + NonInferrableType = 1 << 18, // Type is or contains anyFunctionType or silentNeverType, or it's a context free `returnTypeOnly` /** @internal */ CouldContainTypeVariablesComputed = 1 << 19, // CouldContainTypeVariables flag has been computed /** @internal */ diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index cdf898ca8c3fc..5562f9f736397 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -2880,19 +2880,24 @@ export function forEachReturnStatement(body: Block | Statement, visitor: (stm } } +// Warning: This has the same semantics as the forEach family of functions, +// in that traversal terminates in the event that 'visitor' supplies a truthy value. /** @internal */ -export function forEachYieldExpression(body: Block, visitor: (expr: YieldExpression) => void): void { +export function forEachYieldExpression(body: Block, visitor: (expr: YieldExpression) => T): T | undefined { return traverse(body); - function traverse(node: Node): void { + function traverse(node: Node): T | undefined { switch (node.kind) { case SyntaxKind.YieldExpression: - visitor(node as YieldExpression); + const value = visitor(node as YieldExpression); + if (value) { + return value; + } const operand = (node as YieldExpression).expression; - if (operand) { - traverse(operand); + if (!operand) { + return; } - return; + return traverse(operand); case SyntaxKind.EnumDeclaration: case SyntaxKind.InterfaceDeclaration: case SyntaxKind.ModuleDeclaration: @@ -2905,14 +2910,13 @@ export function forEachYieldExpression(body: Block, visitor: (expr: YieldExpress if (node.name && node.name.kind === SyntaxKind.ComputedPropertyName) { // Note that we will not include methods/accessors of a class because they would require // first descending into the class. This is by design. - traverse(node.name.expression); - return; + return traverse(node.name.expression); } } else if (!isPartOfTypeNode(node)) { // This is the general case, which should include mostly expressions and statements. // Also includes NodeArrays. - forEachChild(node, traverse); + return forEachChild(node, traverse); } } } @@ -10829,7 +10833,7 @@ export function hasContextSensitiveParameters(node: FunctionLikeDeclaration): bo // an implicit 'this' parameter which is subject to contextual typing. const parameter = firstOrUndefined(node.parameters); if (!(parameter && parameterIsThisKeyword(parameter))) { - return true; + return !!(node.flags & NodeFlags.ContainsThis); } } } diff --git a/tests/baselines/reference/circularlySimplifyingConditionalTypesNoCrash.types b/tests/baselines/reference/circularlySimplifyingConditionalTypesNoCrash.types index 29b958c768ad3..5aa7b5c308c6b 100644 --- a/tests/baselines/reference/circularlySimplifyingConditionalTypesNoCrash.types +++ b/tests/baselines/reference/circularlySimplifyingConditionalTypesNoCrash.types @@ -1,8 +1,5 @@ //// [tests/cases/compiler/circularlySimplifyingConditionalTypesNoCrash.ts] //// -=== Performance Stats === -Instantiation count: 1,000 - === circularlySimplifyingConditionalTypesNoCrash.ts === type Omit = Pick>; >Omit : Omit @@ -71,8 +68,8 @@ declare var connect: Connect; const myStoreConnect: Connect = function( >myStoreConnect : Connect > : ^^^^^^^ ->function( mapStateToProps?: any, mapDispatchToProps?: any, mergeProps?: any, options: unknown = {},) { return connect( mapStateToProps, mapDispatchToProps, mergeProps, options, );} : (mapStateToProps?: any, mapDispatchToProps?: any, mergeProps?: any, options?: unknown) => InferableComponentEnhancerWithProps> & TOwnProps> -> : ^ ^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>function( mapStateToProps?: any, mapDispatchToProps?: any, mergeProps?: any, options: unknown = {},) { return connect( mapStateToProps, mapDispatchToProps, mergeProps, options, );} : (mapStateToProps?: any, mapDispatchToProps?: any, mergeProps?: any, options?: unknown) => InferableComponentEnhancerWithProps> & TOwnProps> +> : ^ ^^^ ^^ ^^^ ^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mapStateToProps?: any, >mapStateToProps : any diff --git a/tests/baselines/reference/classCanExtendConstructorFunction.errors.txt b/tests/baselines/reference/classCanExtendConstructorFunction.errors.txt index 6be00dcf3fb7c..d7a29da097bae 100644 --- a/tests/baselines/reference/classCanExtendConstructorFunction.errors.txt +++ b/tests/baselines/reference/classCanExtendConstructorFunction.errors.txt @@ -1,6 +1,6 @@ first.js(23,9): error TS2554: Expected 1 arguments, but got 0. first.js(31,5): error TS2416: Property 'load' in type 'Sql' is not assignable to the same property in base type 'Wagon'. - Type '(files: string[], format: "csv" | "json" | "xmlolololol") => void' is not assignable to type '(supplies?: any[]) => void'. + Type '(files: string[], format: "csv" | "json" | "xmlolololol") => void' is not assignable to type '(supplies?: any[] | undefined) => void'. Target signature provides too few arguments. Expected 2 or more, but got 1. first.js(47,24): error TS2507: Type '(numberEaten: number) => void' is not a constructor function type. generic.js(19,19): error TS2554: Expected 1 arguments, but got 0. @@ -8,7 +8,7 @@ generic.js(20,32): error TS2345: Argument of type 'number' is not assignable to second.ts(8,25): error TS2507: Type '(numberEaten: number) => void' is not a constructor function type. second.ts(14,7): error TS2417: Class static side 'typeof Conestoga' incorrectly extends base class static side 'typeof Wagon'. Types of property 'circle' are incompatible. - Type '(others: (typeof Wagon)[]) => number' is not assignable to type '(wagons?: Wagon[]) => number'. + Type '(others: (typeof Wagon)[]) => number' is not assignable to type '(wagons?: Wagon[] | undefined) => number'. Types of parameters 'others' and 'wagons' are incompatible. Type 'Wagon[]' is not assignable to type '(typeof Wagon)[]'. Property 'circle' is missing in type 'Wagon' but required in type 'typeof Wagon'. @@ -52,7 +52,7 @@ second.ts(17,15): error TS2345: Argument of type 'string' is not assignable to p load(files, format) { ~~~~ !!! error TS2416: Property 'load' in type 'Sql' is not assignable to the same property in base type 'Wagon'. -!!! error TS2416: Type '(files: string[], format: "csv" | "json" | "xmlolololol") => void' is not assignable to type '(supplies?: any[]) => void'. +!!! error TS2416: Type '(files: string[], format: "csv" | "json" | "xmlolololol") => void' is not assignable to type '(supplies?: any[] | undefined) => void'. !!! error TS2416: Target signature provides too few arguments. Expected 2 or more, but got 1. if (format === "xmlolololol") { throw new Error("please do not use XML. It was a joke."); @@ -95,7 +95,7 @@ second.ts(17,15): error TS2345: Argument of type 'string' is not assignable to p ~~~~~~~~~ !!! error TS2417: Class static side 'typeof Conestoga' incorrectly extends base class static side 'typeof Wagon'. !!! error TS2417: Types of property 'circle' are incompatible. -!!! error TS2417: Type '(others: (typeof Wagon)[]) => number' is not assignable to type '(wagons?: Wagon[]) => number'. +!!! error TS2417: Type '(others: (typeof Wagon)[]) => number' is not assignable to type '(wagons?: Wagon[] | undefined) => number'. !!! error TS2417: Types of parameters 'others' and 'wagons' are incompatible. !!! error TS2417: Type 'Wagon[]' is not assignable to type '(typeof Wagon)[]'. !!! error TS2417: Property 'circle' is missing in type 'Wagon' but required in type 'typeof Wagon'. diff --git a/tests/baselines/reference/generatorTypeCheck62.types b/tests/baselines/reference/generatorTypeCheck62.types index 6196ace757ddb..0a4b1e599cf2e 100644 --- a/tests/baselines/reference/generatorTypeCheck62.types +++ b/tests/baselines/reference/generatorTypeCheck62.types @@ -117,8 +117,8 @@ export const Nothing2: Strategy = strategy("Nothing", function*(state: St export const Nothing3: Strategy = strategy("Nothing", function* (state: State) { >Nothing3 : Strategy > : ^^^^^^^^^^^^^^^ ->strategy("Nothing", function* (state: State) { yield ; return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.}) : (a: State) => IterableIterator -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>strategy("Nothing", function* (state: State) { yield ; return state; // `return`/`TReturn` isn't supported by `strategy`, so this should error.}) : (a: any) => IterableIterator +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ >strategy : (stratName: string, gen: (a: T) => IterableIterator) => (a: T) => IterableIterator > : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ >"Nothing" : "Nothing" diff --git a/tests/baselines/reference/genericCallAtYieldExpressionInGenericCall3.symbols b/tests/baselines/reference/genericCallAtYieldExpressionInGenericCall3.symbols new file mode 100644 index 0000000000000..d3772db880ab9 --- /dev/null +++ b/tests/baselines/reference/genericCallAtYieldExpressionInGenericCall3.symbols @@ -0,0 +1,181 @@ +//// [tests/cases/compiler/genericCallAtYieldExpressionInGenericCall3.ts] //// + +=== genericCallAtYieldExpressionInGenericCall3.ts === +type ReadonlyRecord = { +>ReadonlyRecord : Symbol(ReadonlyRecord, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 0)) +>K : Symbol(K, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 20)) +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 53)) + + readonly [P in K]: A; +>P : Symbol(P, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 1, 12)) +>K : Symbol(K, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 20)) +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 53)) + +}; + +type Success = T extends Micro ? _A : never; +>Success : Symbol(Success, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 2, 2)) +>T : Symbol(T, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 13)) +>T : Symbol(T, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 13)) +>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1)) +>_A : Symbol(_A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 39)) +>_E : Symbol(_E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 49)) +>_R : Symbol(_R, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 59)) +>_A : Symbol(_A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 39)) + +interface MicroIterator> { +>MicroIterator : Symbol(MicroIterator, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 77)) +>T : Symbol(T, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 6, 24)) +>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1)) + + next(...args: ReadonlyArray): IteratorResult>; +>next : Symbol(MicroIterator.next, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 6, 57)) +>args : Symbol(args, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 7, 7)) +>ReadonlyArray : Symbol(ReadonlyArray, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2016.array.include.d.ts, --, --) ... and 3 more) +>IteratorResult : Symbol(IteratorResult, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 6, 24)) +>Success : Symbol(Success, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 2, 2)) +>T : Symbol(T, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 6, 24)) +} + +interface Micro { +>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1)) +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 16)) +>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 22)) +>R : Symbol(R, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 37)) + + _A: A; +>_A : Symbol(Micro._A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 54)) +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 16)) + + _E: E; +>_E : Symbol(Micro._E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 11, 8)) +>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 22)) + + _R: R; +>_R : Symbol(Micro._R, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 12, 8)) +>R : Symbol(R, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 37)) + + [Symbol.iterator](): MicroIterator>; +>[Symbol.iterator] : Symbol(Micro[Symbol.iterator], Decl(genericCallAtYieldExpressionInGenericCall3.ts, 13, 8)) +>Symbol.iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>iterator : Symbol(SymbolConstructor.iterator, Decl(lib.es2015.iterable.d.ts, --, --)) +>MicroIterator : Symbol(MicroIterator, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 4, 77)) +>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1)) +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 16)) +>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 22)) +>R : Symbol(R, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 10, 37)) +} + +declare function runPromise(effect: Micro): Promise; +>runPromise : Symbol(runPromise, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 15, 1)) +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 28)) +>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 30)) +>effect : Symbol(effect, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 34)) +>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1)) +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 28)) +>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 30)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 28)) + +declare function gen, AEff>( +>gen : Symbol(gen, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 67)) +>Eff : Symbol(Eff, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 19, 21)) +>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1)) +>AEff : Symbol(AEff, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 19, 54)) + + body: () => Generator, +>body : Symbol(body, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 19, 61)) +>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --)) +>Eff : Symbol(Eff, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 19, 21)) +>AEff : Symbol(AEff, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 19, 54)) + +): Micro; +>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1)) +>AEff : Symbol(AEff, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 19, 54)) + +declare const traverse: { +>traverse : Symbol(traverse, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 23, 13)) + + ( +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 3)) +>R : Symbol(R, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 5)) +>O : Symbol(O, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 8)) +>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 11)) +>B : Symbol(B, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 14)) + + f: (a: A) => Micro, +>f : Symbol(f, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 18)) +>a : Symbol(a, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 25, 8)) +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 3)) +>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1)) +>B : Symbol(B, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 14)) +>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 11)) +>O : Symbol(O, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 8)) + + ): ( + self: ReadonlyRecord, +>self : Symbol(self, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 26, 6)) +>ReadonlyRecord : Symbol(ReadonlyRecord, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 0)) +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 3)) + + ) => Micro, E, O>; +>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1)) +>ReadonlyRecord : Symbol(ReadonlyRecord, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 0)) +>B : Symbol(B, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 14)) +>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 11)) +>O : Symbol(O, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 24, 8)) + + ( +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 3)) +>O : Symbol(O, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 5)) +>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 8)) +>B : Symbol(B, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 11)) + + self: ReadonlyRecord, +>self : Symbol(self, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 15)) +>ReadonlyRecord : Symbol(ReadonlyRecord, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 0)) +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 3)) + + f: (a: A) => Micro, +>f : Symbol(f, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 30, 36)) +>a : Symbol(a, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 31, 8)) +>A : Symbol(A, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 3)) +>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1)) +>B : Symbol(B, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 11)) +>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 8)) +>O : Symbol(O, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 5)) + + ): Micro, E, O>; +>Micro : Symbol(Micro, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 8, 1)) +>ReadonlyRecord : Symbol(ReadonlyRecord, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 0, 0)) +>B : Symbol(B, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 11)) +>E : Symbol(E, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 8)) +>O : Symbol(O, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 29, 5)) + +}; + +runPromise( +>runPromise : Symbol(runPromise, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 15, 1)) + + gen(function* () { +>gen : Symbol(gen, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 67)) + + yield* traverse({ a: 1, b: 2 }, (n) => +>traverse : Symbol(traverse, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 23, 13)) +>a : Symbol(a, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 37, 21)) +>b : Symbol(b, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 37, 27)) +>n : Symbol(n, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 37, 37)) + + gen(function* () { +>gen : Symbol(gen, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 17, 67)) + + return n + 1; +>n : Symbol(n, Decl(genericCallAtYieldExpressionInGenericCall3.ts, 37, 37)) + + }), + ); + }), +); + diff --git a/tests/baselines/reference/genericCallAtYieldExpressionInGenericCall3.types b/tests/baselines/reference/genericCallAtYieldExpressionInGenericCall3.types new file mode 100644 index 0000000000000..6888c696198b1 --- /dev/null +++ b/tests/baselines/reference/genericCallAtYieldExpressionInGenericCall3.types @@ -0,0 +1,154 @@ +//// [tests/cases/compiler/genericCallAtYieldExpressionInGenericCall3.ts] //// + +=== Performance Stats === +Type Count: 1,000 +Instantiation count: 2,500 + +=== genericCallAtYieldExpressionInGenericCall3.ts === +type ReadonlyRecord = { +>ReadonlyRecord : ReadonlyRecord +> : ^^^^^^^^^^^^^^^^^^^^ + + readonly [P in K]: A; +}; + +type Success = T extends Micro ? _A : never; +>Success : Success +> : ^^^^^^^^^^ + +interface MicroIterator> { + next(...args: ReadonlyArray): IteratorResult>; +>next : (...args: ReadonlyArray) => IteratorResult> +> : ^^^^ ^^ ^^^^^ +>args : readonly any[] +> : ^^^^^^^^^^^^^^ +} + +interface Micro { + _A: A; +>_A : A +> : ^ + + _E: E; +>_E : E +> : ^ + + _R: R; +>_R : R +> : ^ + + [Symbol.iterator](): MicroIterator>; +>[Symbol.iterator] : () => MicroIterator> +> : ^^^^^^ +>Symbol.iterator : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>iterator : unique symbol +> : ^^^^^^^^^^^^^ +} + +declare function runPromise(effect: Micro): Promise; +>runPromise : (effect: Micro) => Promise +> : ^ ^^ ^^ ^^ ^^^^^ +>effect : Micro +> : ^^^^^^^^^^^^^^^^^^ + +declare function gen, AEff>( +>gen : , AEff>(body: () => Generator) => Micro +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ + + body: () => Generator, +>body : () => Generator +> : ^^^^^^ + +): Micro; + +declare const traverse: { +>traverse : { (f: (a: A) => Micro): (self: ReadonlyRecord) => Micro, E, O>; (self: ReadonlyRecord, f: (a: A) => Micro): Micro, E, O>; } +> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ + + ( + f: (a: A) => Micro, +>f : (a: A) => Micro +> : ^ ^^ ^^^^^ +>a : A +> : ^ + + ): ( + self: ReadonlyRecord, +>self : ReadonlyRecord +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + ) => Micro, E, O>; + ( + self: ReadonlyRecord, +>self : ReadonlyRecord +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ + + f: (a: A) => Micro, +>f : (a: A) => Micro +> : ^ ^^ ^^^^^ +>a : A +> : ^ + + ): Micro, E, O>; +}; + +runPromise( +>runPromise( gen(function* () { yield* traverse({ a: 1, b: 2 }, (n) => gen(function* () { return n + 1; }), ); }),) : Promise +> : ^^^^^^^^^^^^^ +>runPromise : (effect: Micro) => Promise +> : ^ ^^ ^^ ^^ ^^^^^ + + gen(function* () { +>gen(function* () { yield* traverse({ a: 1, b: 2 }, (n) => gen(function* () { return n + 1; }), ); }) : Micro +> : ^^^^^^^^^^^^^^^^^^^^^^^ +>gen : , AEff>(body: () => Generator) => Micro +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>function* () { yield* traverse({ a: 1, b: 2 }, (n) => gen(function* () { return n + 1; }), ); } : () => Generator, any, never>, void, any> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + yield* traverse({ a: 1, b: 2 }, (n) => +>yield* traverse({ a: 1, b: 2 }, (n) => gen(function* () { return n + 1; }), ) : ReadonlyRecord +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>traverse({ a: 1, b: 2 }, (n) => gen(function* () { return n + 1; }), ) : Micro, any, never> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>traverse : { (f: (a: A) => Micro): (self: ReadonlyRecord) => Micro, E, O>; (self: ReadonlyRecord, f: (a: A) => Micro): Micro, E, O>; } +> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ +>{ a: 1, b: 2 } : { a: number; b: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>a : number +> : ^^^^^^ +>1 : 1 +> : ^ +>b : number +> : ^^^^^^ +>2 : 2 +> : ^ +>(n) => gen(function* () { return n + 1; }) : (n: number) => Micro +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>n : number +> : ^^^^^^ + + gen(function* () { +>gen(function* () { return n + 1; }) : Micro +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ +>gen : , AEff>(body: () => Generator) => Micro +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>function* () { return n + 1; } : () => Generator +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + return n + 1; +>n + 1 : number +> : ^^^^^^ +>n : number +> : ^^^^^^ +>1 : 1 +> : ^ + + }), + ); + }), +); + diff --git a/tests/baselines/reference/jsdocTemplateTag.errors.txt b/tests/baselines/reference/jsdocTemplateTag.errors.txt index 74a150c6e3cd0..308b9e4bd23c7 100644 --- a/tests/baselines/reference/jsdocTemplateTag.errors.txt +++ b/tests/baselines/reference/jsdocTemplateTag.errors.txt @@ -1,4 +1,4 @@ -forgot.js(23,1): error TS2322: Type '(keyframes: any[]) => void' is not assignable to type '(keyframes: Keyframe[] | PropertyIndexedKeyframes, options?: number | KeyframeAnimationOptions) => Animation'. +forgot.js(23,1): error TS2322: Type '(keyframes: Array) => void' is not assignable to type '(keyframes: Keyframe[] | PropertyIndexedKeyframes, options?: number | KeyframeAnimationOptions) => Animation'. Type 'void' is not assignable to type 'Animation'. @@ -27,6 +27,6 @@ forgot.js(23,1): error TS2322: Type '(keyframes: any[]) => void' is not assignab */ Element.prototype.animate = function(keyframes) {}; ~~~~~~~~~~~~~~~~~~~~~~~~~ -!!! error TS2322: Type '(keyframes: any[]) => void' is not assignable to type '(keyframes: Keyframe[] | PropertyIndexedKeyframes, options?: number | KeyframeAnimationOptions) => Animation'. +!!! error TS2322: Type '(keyframes: Array) => void' is not assignable to type '(keyframes: Keyframe[] | PropertyIndexedKeyframes, options?: number | KeyframeAnimationOptions) => Animation'. !!! error TS2322: Type 'void' is not assignable to type 'Animation'. \ No newline at end of file diff --git a/tests/baselines/reference/redefineArray.errors.txt b/tests/baselines/reference/redefineArray.errors.txt index 87a448e677a3f..b831151ee7922 100644 --- a/tests/baselines/reference/redefineArray.errors.txt +++ b/tests/baselines/reference/redefineArray.errors.txt @@ -1,7 +1,7 @@ -redefineArray.ts(1,1): error TS2739: Type '(n: number, s: string) => number' is missing the following properties from type 'ArrayConstructor': isArray, from, of, [Symbol.species] +redefineArray.ts(1,1): error TS2739: Type '(n: number, s: string) => number' is missing the following properties from type 'ArrayConstructor': isArray, from, of, [Symbol.species] ==== redefineArray.ts (1 errors) ==== Array = function (n:number, s:string) {return n;}; ~~~~~ -!!! error TS2739: Type '(n: number, s: string) => number' is missing the following properties from type 'ArrayConstructor': isArray, from, of, [Symbol.species] \ No newline at end of file +!!! error TS2739: Type '(n: number, s: string) => number' is missing the following properties from type 'ArrayConstructor': isArray, from, of, [Symbol.species] \ No newline at end of file diff --git a/tests/baselines/reference/redefineArray.types b/tests/baselines/reference/redefineArray.types index d4df39d46b393..221d20711fa31 100644 --- a/tests/baselines/reference/redefineArray.types +++ b/tests/baselines/reference/redefineArray.types @@ -2,12 +2,12 @@ === redefineArray.ts === Array = function (n:number, s:string) {return n;}; ->Array = function (n:number, s:string) {return n;} : (n: number, s: string) => number -> : ^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^ +>Array = function (n:number, s:string) {return n;} : (n: number, s: string) => number +> : ^ ^^ ^^ ^^ ^^^^^^^^^^^ >Array : ArrayConstructor > : ^^^^^^^^^^^^^^^^ ->function (n:number, s:string) {return n;} : (n: number, s: string) => number -> : ^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^ +>function (n:number, s:string) {return n;} : (n: number, s: string) => number +> : ^ ^^ ^^ ^^ ^^^^^^^^^^^ >n : number > : ^^^^^^ >s : string diff --git a/tests/baselines/reference/returnTypeInferenceContextualParameterTypesInGenerator1.symbols b/tests/baselines/reference/returnTypeInferenceContextualParameterTypesInGenerator1.symbols new file mode 100644 index 0000000000000..ef2a5fd660edc --- /dev/null +++ b/tests/baselines/reference/returnTypeInferenceContextualParameterTypesInGenerator1.symbols @@ -0,0 +1,165 @@ +//// [tests/cases/compiler/returnTypeInferenceContextualParameterTypesInGenerator1.ts] //// + +=== returnTypeInferenceContextualParameterTypesInGenerator1.ts === +interface Effect { +>Effect : Symbol(Effect, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 0)) +>A : Symbol(A, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 17)) + + readonly _A: A; +>_A : Symbol(Effect._A, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 25)) +>A : Symbol(A, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 17)) +} + +declare function gen, AEff>( +>gen : Symbol(gen, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 2, 1)) +>Eff : Symbol(Eff, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 4, 21)) +>Effect : Symbol(Effect, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 0)) +>AEff : Symbol(AEff, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 4, 45)) + + f: () => Generator +>f : Symbol(f, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 4, 52)) +>Generator : Symbol(Generator, Decl(lib.es2015.generator.d.ts, --, --)) +>Eff : Symbol(Eff, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 4, 21)) +>AEff : Symbol(AEff, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 4, 45)) + +): Effect; +>Effect : Symbol(Effect, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 0)) +>AEff : Symbol(AEff, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 4, 45)) + +interface Rpc< +>Rpc : Symbol(Rpc, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 6, 16)) + + in out Tag extends string, +>Tag : Symbol(Tag, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 8, 14)) + + out Payload = unknown, +>Payload : Symbol(Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 9, 28)) + + out Success = unknown +>Success : Symbol(Success, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 10, 24)) + +> { + readonly _tag: Tag; +>_tag : Symbol(Rpc._tag, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 12, 3)) +>Tag : Symbol(Tag, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 8, 14)) + + readonly payloadSchema: Payload; +>payloadSchema : Symbol(Rpc.payloadSchema, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 13, 21)) +>Payload : Symbol(Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 9, 28)) + + readonly successSchema: Success; +>successSchema : Symbol(Rpc.successSchema, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 14, 34)) +>Success : Symbol(Success, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 10, 24)) +} + +interface RpcAny { +>RpcAny : Symbol(RpcAny, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 16, 1)) + + readonly _tag: string; +>_tag : Symbol(RpcAny._tag, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 18, 18)) +} + +type Payload = R extends Rpc +>Payload : Symbol(Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 20, 1)) +>R : Symbol(R, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 22, 13)) +>R : Symbol(R, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 22, 13)) +>Rpc : Symbol(Rpc, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 6, 16)) +>_Tag : Symbol(_Tag, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 22, 37)) +>_Payload : Symbol(_Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 22, 49)) +>_Success : Symbol(_Success, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 22, 65)) + + ? _Payload +>_Payload : Symbol(_Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 22, 49)) + + : never; + +type ResultFrom = R extends Rpc< +>ResultFrom : Symbol(ResultFrom, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 24, 10)) +>R : Symbol(R, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 26, 16)) +>RpcAny : Symbol(RpcAny, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 16, 1)) +>R : Symbol(R, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 26, 16)) +>Rpc : Symbol(Rpc, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 6, 16)) + + infer _Tag, +>_Tag : Symbol(_Tag, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 27, 7)) + + infer _Payload, +>_Payload : Symbol(_Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 28, 7)) + + infer _Success +>_Success : Symbol(_Success, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 29, 7)) + +> + ? _Success +>_Success : Symbol(_Success, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 29, 7)) + + : never; + +type ToHandlerFn = ( +>ToHandlerFn : Symbol(ToHandlerFn, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 32, 10)) +>Current : Symbol(Current, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 34, 17)) +>RpcAny : Symbol(RpcAny, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 16, 1)) + + payload: Payload +>payload : Symbol(payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 34, 44)) +>Payload : Symbol(Payload, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 20, 1)) +>Current : Symbol(Current, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 34, 17)) + +) => ResultFrom; +>ResultFrom : Symbol(ResultFrom, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 24, 10)) +>Current : Symbol(Current, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 34, 17)) + +type HandlersFrom = { +>HandlersFrom : Symbol(HandlersFrom, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 36, 25)) +>Rpc : Symbol(Rpc, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 38, 18)) +>RpcAny : Symbol(RpcAny, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 16, 1)) + + readonly [Current in Rpc as Current["_tag"]]: ToHandlerFn; +>Current : Symbol(Current, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 39, 12)) +>Rpc : Symbol(Rpc, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 38, 18)) +>Current : Symbol(Current, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 39, 12)) +>ToHandlerFn : Symbol(ToHandlerFn, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 32, 10)) +>Current : Symbol(Current, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 39, 12)) + +}; + +interface RpcGroup { +>RpcGroup : Symbol(RpcGroup, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 40, 2)) +>R : Symbol(R, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 42, 19)) +>RpcAny : Symbol(RpcAny, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 16, 1)) + + toLayer>(build: Effect): unknown; +>toLayer : Symbol(RpcGroup.toLayer, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 42, 45)) +>Handlers : Symbol(Handlers, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 43, 10)) +>HandlersFrom : Symbol(HandlersFrom, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 36, 25)) +>R : Symbol(R, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 42, 19)) +>build : Symbol(build, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 43, 44)) +>Effect : Symbol(Effect, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 0, 0)) +>Handlers : Symbol(Handlers, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 43, 10)) +} + +declare const Rpcs: RpcGroup>; +>Rpcs : Symbol(Rpcs, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 46, 13)) +>RpcGroup : Symbol(RpcGroup, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 40, 2)) +>Rpc : Symbol(Rpc, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 6, 16)) + +export const layerServerHandlers = Rpcs.toLayer( +>layerServerHandlers : Symbol(layerServerHandlers, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 48, 12)) +>Rpcs.toLayer : Symbol(RpcGroup.toLayer, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 42, 45)) +>Rpcs : Symbol(Rpcs, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 46, 13)) +>toLayer : Symbol(RpcGroup.toLayer, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 42, 45)) + + gen(function* () { +>gen : Symbol(gen, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 2, 1)) + + return { + Register: (id) => String(id), +>Register : Symbol(Register, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 50, 12)) +>id : Symbol(id, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 51, 17)) +>String : Symbol(String, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.core.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --) ... and 7 more) +>id : Symbol(id, Decl(returnTypeInferenceContextualParameterTypesInGenerator1.ts, 51, 17)) + + }; + }) +); + diff --git a/tests/baselines/reference/returnTypeInferenceContextualParameterTypesInGenerator1.types b/tests/baselines/reference/returnTypeInferenceContextualParameterTypesInGenerator1.types new file mode 100644 index 0000000000000..71a5b114a505e --- /dev/null +++ b/tests/baselines/reference/returnTypeInferenceContextualParameterTypesInGenerator1.types @@ -0,0 +1,136 @@ +//// [tests/cases/compiler/returnTypeInferenceContextualParameterTypesInGenerator1.ts] //// + +=== Performance Stats === +Type Count: 1,000 +Instantiation count: 2,500 + +=== returnTypeInferenceContextualParameterTypesInGenerator1.ts === +interface Effect { + readonly _A: A; +>_A : A +> : ^ +} + +declare function gen, AEff>( +>gen : , AEff>(f: () => Generator) => Effect +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ + + f: () => Generator +>f : () => Generator +> : ^^^^^^ + +): Effect; + +interface Rpc< + in out Tag extends string, + out Payload = unknown, + out Success = unknown +> { + readonly _tag: Tag; +>_tag : Tag +> : ^^^ + + readonly payloadSchema: Payload; +>payloadSchema : Payload +> : ^^^^^^^ + + readonly successSchema: Success; +>successSchema : Success +> : ^^^^^^^ +} + +interface RpcAny { + readonly _tag: string; +>_tag : string +> : ^^^^^^ +} + +type Payload = R extends Rpc +>Payload : Payload +> : ^^^^^^^^^^ + + ? _Payload + : never; + +type ResultFrom = R extends Rpc< +>ResultFrom : ResultFrom +> : ^^^^^^^^^^^^^ + + infer _Tag, + infer _Payload, + infer _Success +> + ? _Success + : never; + +type ToHandlerFn = ( +>ToHandlerFn : ToHandlerFn +> : ^^^^^^^^^^^^^^^^^^^^ + + payload: Payload +>payload : Payload +> : ^^^^^^^^^^^^^^^^ + +) => ResultFrom; + +type HandlersFrom = { +>HandlersFrom : HandlersFrom +> : ^^^^^^^^^^^^^^^^^ + + readonly [Current in Rpc as Current["_tag"]]: ToHandlerFn; +}; + +interface RpcGroup { + toLayer>(build: Effect): unknown; +>toLayer : >(build: Effect) => unknown +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>build : Effect +> : ^^^^^^^^^^^^^^^^ +} + +declare const Rpcs: RpcGroup>; +>Rpcs : RpcGroup> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +export const layerServerHandlers = Rpcs.toLayer( +>layerServerHandlers : unknown +> : ^^^^^^^ +>Rpcs.toLayer( gen(function* () { return { Register: (id) => String(id), }; })) : unknown +> : ^^^^^^^ +>Rpcs.toLayer : >>(build: Effect) => unknown +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ +>Rpcs : RpcGroup> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>toLayer : >>(build: Effect) => unknown +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ + + gen(function* () { +>gen(function* () { return { Register: (id) => String(id), }; }) : Effect<{ Register: (id: number) => string; }> +> : ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ +>gen : , AEff>(f: () => Generator) => Effect +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ +>function* () { return { Register: (id) => String(id), }; } : () => Generator string; }, any> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + return { +>{ Register: (id) => String(id), } : { Register: (id: number) => string; } +> : ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ + + Register: (id) => String(id), +>Register : (id: number) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>(id) => String(id) : (id: number) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>id : number +> : ^^^^^^ +>String(id) : string +> : ^^^^^^ +>String : StringConstructor +> : ^^^^^^^^^^^^^^^^^ +>id : number +> : ^^^^^^ + + }; + }) +); + diff --git a/tests/baselines/reference/returnTypeInferenceContextualTypeIgnoreAnyUnknown1.symbols b/tests/baselines/reference/returnTypeInferenceContextualTypeIgnoreAnyUnknown1.symbols new file mode 100644 index 0000000000000..9f787b05bad1b --- /dev/null +++ b/tests/baselines/reference/returnTypeInferenceContextualTypeIgnoreAnyUnknown1.symbols @@ -0,0 +1,85 @@ +//// [tests/cases/compiler/returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts] //// + +=== returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts === +declare function outer1(arg: { prop: any }): void; +>outer1 : Symbol(outer1, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 0, 0)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 0, 24)) +>prop : Symbol(prop, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 0, 30)) + +declare function outer2(arg: { prop: unknown }): void; +>outer2 : Symbol(outer2, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 0, 50)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 1, 24)) +>prop : Symbol(prop, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 1, 30)) + +declare function inner1 any>(arg: T): T; +>inner1 : Symbol(inner1, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 1, 54)) +>T : Symbol(T, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 3, 24)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 3, 35)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 3, 56)) +>T : Symbol(T, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 3, 24)) +>T : Symbol(T, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 3, 24)) + +const result1 = inner1((arg) => arg); +>result1 : Symbol(result1, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 5, 5)) +>inner1 : Symbol(inner1, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 1, 54)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 5, 24)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 5, 24)) + +outer1({ +>outer1 : Symbol(outer1, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 0, 0)) + + prop: inner1((arg) => arg), +>prop : Symbol(prop, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 7, 8)) +>inner1 : Symbol(inner1, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 1, 54)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 8, 16)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 8, 16)) + +}); + +outer2({ +>outer2 : Symbol(outer2, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 0, 50)) + + prop: inner1((arg) => arg), +>prop : Symbol(prop, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 11, 8)) +>inner1 : Symbol(inner1, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 1, 54)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 12, 16)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 12, 16)) + +}); + +declare function inner2(arg: T & ((arg: string) => any)): T; +>inner2 : Symbol(inner2, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 13, 3)) +>T : Symbol(T, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 15, 24)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 15, 27)) +>T : Symbol(T, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 15, 24)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 15, 38)) +>T : Symbol(T, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 15, 24)) + +const result2 = inner2((arg) => arg); +>result2 : Symbol(result2, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 17, 5)) +>inner2 : Symbol(inner2, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 13, 3)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 17, 24)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 17, 24)) + +outer1({ +>outer1 : Symbol(outer1, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 0, 0)) + + prop: inner2((arg) => arg), +>prop : Symbol(prop, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 19, 8)) +>inner2 : Symbol(inner2, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 13, 3)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 20, 16)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 20, 16)) + +}); + +outer2({ +>outer2 : Symbol(outer2, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 0, 50)) + + prop: inner2((arg) => arg), +>prop : Symbol(prop, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 23, 8)) +>inner2 : Symbol(inner2, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 13, 3)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 24, 16)) +>arg : Symbol(arg, Decl(returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts, 24, 16)) + +}); + diff --git a/tests/baselines/reference/returnTypeInferenceContextualTypeIgnoreAnyUnknown1.types b/tests/baselines/reference/returnTypeInferenceContextualTypeIgnoreAnyUnknown1.types new file mode 100644 index 0000000000000..298ea70a69e42 --- /dev/null +++ b/tests/baselines/reference/returnTypeInferenceContextualTypeIgnoreAnyUnknown1.types @@ -0,0 +1,158 @@ +//// [tests/cases/compiler/returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts] //// + +=== returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts === +declare function outer1(arg: { prop: any }): void; +>outer1 : (arg: { prop: any; }) => void +> : ^ ^^ ^^^^^ +>arg : { prop: any; } +> : ^^^^^^^^ ^^^ +>prop : any + +declare function outer2(arg: { prop: unknown }): void; +>outer2 : (arg: { prop: unknown; }) => void +> : ^ ^^ ^^^^^ +>arg : { prop: unknown; } +> : ^^^^^^^^ ^^^ +>prop : unknown +> : ^^^^^^^ + +declare function inner1 any>(arg: T): T; +>inner1 : any>(arg: T) => T +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>arg : string +> : ^^^^^^ +>arg : T +> : ^ + +const result1 = inner1((arg) => arg); +>result1 : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>inner1((arg) => arg) : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>inner1 : any>(arg: T) => T +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>(arg) => arg : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>arg : string +> : ^^^^^^ +>arg : string +> : ^^^^^^ + +outer1({ +>outer1({ prop: inner1((arg) => arg),}) : void +> : ^^^^ +>outer1 : (arg: { prop: any; }) => void +> : ^ ^^ ^^^^^ +>{ prop: inner1((arg) => arg),} : { prop: (arg: string) => string; } +> : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ + + prop: inner1((arg) => arg), +>prop : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>inner1((arg) => arg) : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>inner1 : any>(arg: T) => T +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>(arg) => arg : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>arg : string +> : ^^^^^^ +>arg : string +> : ^^^^^^ + +}); + +outer2({ +>outer2({ prop: inner1((arg) => arg),}) : void +> : ^^^^ +>outer2 : (arg: { prop: unknown; }) => void +> : ^ ^^ ^^^^^ +>{ prop: inner1((arg) => arg),} : { prop: (arg: string) => string; } +> : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ + + prop: inner1((arg) => arg), +>prop : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>inner1((arg) => arg) : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>inner1 : any>(arg: T) => T +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>(arg) => arg : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>arg : string +> : ^^^^^^ +>arg : string +> : ^^^^^^ + +}); + +declare function inner2(arg: T & ((arg: string) => any)): T; +>inner2 : (arg: T & ((arg: string) => any)) => T +> : ^ ^^ ^^ ^^^^^ +>arg : T & ((arg: string) => any) +> : ^^^^^^ ^^ ^^^^^ ^ +>arg : string +> : ^^^^^^ + +const result2 = inner2((arg) => arg); +>result2 : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>inner2((arg) => arg) : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>inner2 : (arg: T & ((arg: string) => any)) => T +> : ^ ^^ ^^ ^^^^^ +>(arg) => arg : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>arg : string +> : ^^^^^^ +>arg : string +> : ^^^^^^ + +outer1({ +>outer1({ prop: inner2((arg) => arg),}) : void +> : ^^^^ +>outer1 : (arg: { prop: any; }) => void +> : ^ ^^ ^^^^^ +>{ prop: inner2((arg) => arg),} : { prop: (arg: string) => string; } +> : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ + + prop: inner2((arg) => arg), +>prop : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>inner2((arg) => arg) : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>inner2 : (arg: T & ((arg: string) => any)) => T +> : ^ ^^ ^^ ^^^^^ +>(arg) => arg : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>arg : string +> : ^^^^^^ +>arg : string +> : ^^^^^^ + +}); + +outer2({ +>outer2({ prop: inner2((arg) => arg),}) : void +> : ^^^^ +>outer2 : (arg: { prop: unknown; }) => void +> : ^ ^^ ^^^^^ +>{ prop: inner2((arg) => arg),} : { prop: (arg: string) => string; } +> : ^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ + + prop: inner2((arg) => arg), +>prop : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>inner2((arg) => arg) : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>inner2 : (arg: T & ((arg: string) => any)) => T +> : ^ ^^ ^^ ^^^^^ +>(arg) => arg : (arg: string) => string +> : ^ ^^^^^^^^^^^^^^^^^^^ +>arg : string +> : ^^^^^^ +>arg : string +> : ^^^^^^ + +}); + diff --git a/tests/baselines/reference/thisTypeInFunctions.types b/tests/baselines/reference/thisTypeInFunctions.types index 1f704de6562eb..26dbe2202d918 100644 --- a/tests/baselines/reference/thisTypeInFunctions.types +++ b/tests/baselines/reference/thisTypeInFunctions.types @@ -203,8 +203,8 @@ function implicitThis(n: number): number { let impl: I = { >impl : I > : ^ ->{ a: 12, explicitVoid2: () => this.a, // ok, this: any because it refers to some outer object (window?) explicitVoid1() { return 12; }, explicitStructural() { return this.a; }, explicitInterface() { return this.a; }, explicitThis() { return this.a; },} : { a: number; explicitVoid2: () => any; explicitVoid1(this: void): number; explicitStructural(this: { a: number; }): number; explicitInterface(this: I): number; explicitThis(this: I): number; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ +>{ a: 12, explicitVoid2: () => this.a, // ok, this: any because it refers to some outer object (window?) explicitVoid1() { return 12; }, explicitStructural() { return this.a; }, explicitInterface() { return this.a; }, explicitThis() { return this.a; },} : { a: number; explicitVoid2: () => any; explicitVoid1(): number; explicitStructural(this: { a: number; }): number; explicitInterface(this: I): number; explicitThis(this: I): number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ a: 12, >a : number @@ -225,8 +225,8 @@ let impl: I = { > : ^^^ explicitVoid1() { return 12; }, ->explicitVoid1 : (this: void) => number -> : ^ ^^ ^^^^^^^^^^^ +>explicitVoid1 : () => number +> : ^^^^^^^^^^^^ >12 : 12 > : ^^ @@ -271,16 +271,16 @@ let impl: I = { }, } impl.explicitVoid1 = function () { return 12; }; ->impl.explicitVoid1 = function () { return 12; } : (this: void) => number -> : ^ ^^ ^^^^^^^^^^^ +>impl.explicitVoid1 = function () { return 12; } : () => number +> : ^^^^^^^^^^^^ >impl.explicitVoid1 : (this: void) => number > : ^ ^^ ^^^^^ >impl : I > : ^ >explicitVoid1 : (this: void) => number > : ^ ^^ ^^^^^ ->function () { return 12; } : (this: void) => number -> : ^ ^^ ^^^^^^^^^^^ +>function () { return 12; } : () => number +> : ^^^^^^^^^^^^ >12 : 12 > : ^^ @@ -736,8 +736,8 @@ let anyToSpecified: (this: { y: number }, x: number) => number = function(x: num > : ^^^^^^ >x : number > : ^^^^^^ ->function(x: number): number { return x + 12; } : (this: { y: number; }, x: number) => number -> : ^ ^^ ^^ ^^ ^^^^^ +>function(x: number): number { return x + 12; } : (x: number) => number +> : ^ ^^ ^^^^^ >x : number > : ^^^^^^ >x + 12 : number diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive1.errors.txt b/tests/baselines/reference/thislessFunctionsNotContextSensitive1.errors.txt new file mode 100644 index 0000000000000..f3ad16d09ea13 --- /dev/null +++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive1.errors.txt @@ -0,0 +1,252 @@ +thislessFunctionsNotContextSensitive1.ts(25,3): error TS2345: Argument of type 'false' is not assignable to parameter of type 'true'. +thislessFunctionsNotContextSensitive1.ts(143,13): error TS2345: Argument of type '"value"' is not assignable to parameter of type 'never'. +thislessFunctionsNotContextSensitive1.ts(176,3): error TS2820: Type '"$test6"' is not assignable to type 'ExtractFields<{ target: "$test6"; data1: { $test1: number; $test2: null; }; data2: { $test3: {}; $test4: () => void; $test5(): void; }; }> | undefined'. Did you mean '"$test4"'? + + +==== thislessFunctionsNotContextSensitive1.ts (3 errors) ==== + // https://github.com/microsoft/TypeScript/issues/62204 + + declare function TestConfig( + config: TConfig, + test: keyof Omit extends never ? true : false, + ): void; + + TestConfig( + { + a: "hello", + b: function () { + return 123; + }, + }, + true, + ); + + TestConfig( + { + a: "hello", + b: function () { + return 123; + }, + }, + false, // error + ~~~~~ +!!! error TS2345: Argument of type 'false' is not assignable to parameter of type 'true'. + ); + + // https://github.com/microsoft/TypeScript/issues/60986 + interface SubscribeFieldOptions { + subscribe: () => Event; + resolve: (event: Event) => number; + } + + declare function defineOptions( + options: SubscribeFieldOptions, + ): void; + + defineOptions({ + resolve: (event) => event, // number + subscribe() { + return 123; + }, + }); + + defineOptions({ + resolve: (event) => event, // number + subscribe: function () { + return 123; + }, + }); + + // https://github.com/microsoft/TypeScript/issues/58630 + + export type StateFunction = (s: State, ...args: any[]) => any; + + export type VuexStoreOptions = { + state?: State | (() => State) | { (): State }; + mutations?: Record>; + modules?: { + [k in keyof Modules]: VuexStoreOptions; + }; + }; + + export function createStore< + State extends Record, + Modules extends Record>, + >(options: VuexStoreOptions) {} + + const store = createStore({ + state() { + return { bar2: 1 }; + }, + mutations: { inc: (state123) => state123.bar2++ }, + modules: { + foo: { + state() { + return { bar2: 1 }; + }, + mutations: { inc: (state) => state.bar2++ }, + }, + }, + }); + + // https://github.com/microsoft/TypeScript/issues/57572 + + type C = void>(options: { + methods: Methods; + attached: Attached; + }) => any; + + var Component: C = () => {}; + + Component({ + attached(methods) { + methods.bbb(); // ok + }, + methods: { + bbb() {}, + }, + }); + + Component({ + attached(methods) { + methods.bbb(); // ok + }, + methods: { + bbb: () => {}, + }, + }); + + // https://github.com/microsoft/TypeScript/issues/56067 + + declare function create56067< + State extends Record, + Data extends Record, + Actions extends (state: State, data: Data) => Record, + >(args: { getState: () => State; actions: Actions; getData: () => Data }): void; + + create56067({ + getState() { + return { a: 1 }; + }, + getData: () => { + return { b: 2 }; + }, + actions(state, data) { + state // { a: number } + data; // { b: number } + return { + z: 1, + }; + }, + }); + + // https://github.com/microsoft/TypeScript/issues/55489 + type NonStringIterable = + T extends string ? never : T extends Iterable ? T : never; + + declare function doSomething(value: NonStringIterable): T; + + const o = { foo() {} }; + + doSomething('value'); // error + ~~~~~~~ +!!! error TS2345: Argument of type '"value"' is not assignable to parameter of type 'never'. + doSomething(['v']); // ok + doSomething([o]); // ok + doSomething([{ foo() {} }]); // ok + + // https://github.com/microsoft/TypeScript/issues/55124 + type Values = T[keyof T]; + type ExtractFields = Values<{ + [K in keyof Options]: Options[K] extends object ? keyof Options[K] : never; + }>; + type SetType = { + [key: string]: any; + target?: ExtractFields; + }; + + declare function test55124>( + options: OptionsData, + ): void; + + test55124({ + target: "$test4", // ok + data1: { + $test1: 111, + $test2: null, + }, + data2: { + $test3: {}, + $test4: () => {}, + $test5() {}, + }, + }); + + test55124({ + target: "$test6", // error + ~~~~~~ +!!! error TS2820: Type '"$test6"' is not assignable to type 'ExtractFields<{ target: "$test6"; data1: { $test1: number; $test2: null; }; data2: { $test3: {}; $test4: () => void; $test5(): void; }; }> | undefined'. Did you mean '"$test4"'? +!!! related TS6500 thislessFunctionsNotContextSensitive1.ts:155:3: The expected type comes from property 'target' which is declared here on type 'SetType<{ target: "$test6"; data1: { $test1: number; $test2: null; }; data2: { $test3: {}; $test4: () => void; $test5(): void; }; }>' + data1: { + $test1: 111, + $test2: null, + }, + data2: { + $test3: {}, + $test4: () => {}, + $test5() {}, + }, + }); + + // https://github.com/microsoft/TypeScript/issues/53924 + function test53924(options: { a: (c: T) => void; b: () => T }) {} + + test53924({ + a: (c) => { + c; // number; + }, + b: () => 123, + }); + + test53924({ + b: () => 123, + a: (c) => { + return c; // number + }, + }); + + test53924({ + b() { + return 123; + }, + a(c) { + return c; // number + }, + }); + + test53924({ + a(c) { + return c; // number + }, + b() { + return 123; + }, + }); + + // https://github.com/microsoft/TypeScript/issues/50258 + declare function monitor any>( + extractor: (...args: Parameters) => Record, + executor: T, + ): (...args: Parameters) => ReturnType; + + monitor( + (p) => ({ p }), // { p: number } + (p: number) => p, + ); + monitor( + (p) => ({ p }), // { p: number } + function (p: number) { + return p; + }, + ); + \ No newline at end of file diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive1.symbols b/tests/baselines/reference/thislessFunctionsNotContextSensitive1.symbols new file mode 100644 index 0000000000000..133cc720cbab1 --- /dev/null +++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive1.symbols @@ -0,0 +1,621 @@ +//// [tests/cases/compiler/thislessFunctionsNotContextSensitive1.ts] //// + +=== thislessFunctionsNotContextSensitive1.ts === +// https://github.com/microsoft/TypeScript/issues/62204 + +declare function TestConfig( +>TestConfig : Symbol(TestConfig, Decl(thislessFunctionsNotContextSensitive1.ts, 0, 0)) +>TConfig : Symbol(TConfig, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 28)) +>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 51)) +>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 60)) +>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 69)) + + config: TConfig, +>config : Symbol(config, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 81)) +>TConfig : Symbol(TConfig, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 28)) + + test: keyof Omit extends never ? true : false, +>test : Symbol(test, Decl(thislessFunctionsNotContextSensitive1.ts, 3, 18)) +>Omit : Symbol(Omit, Decl(lib.es5.d.ts, --, --)) +>TConfig : Symbol(TConfig, Decl(thislessFunctionsNotContextSensitive1.ts, 2, 28)) + +): void; + +TestConfig( +>TestConfig : Symbol(TestConfig, Decl(thislessFunctionsNotContextSensitive1.ts, 0, 0)) + { + a: "hello", +>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 8, 3)) + + b: function () { +>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 9, 15)) + + return 123; + }, + }, + true, +); + +TestConfig( +>TestConfig : Symbol(TestConfig, Decl(thislessFunctionsNotContextSensitive1.ts, 0, 0)) + { + a: "hello", +>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 18, 3)) + + b: function () { +>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 19, 15)) + + return 123; + }, + }, + false, // error +); + +// https://github.com/microsoft/TypeScript/issues/60986 +interface SubscribeFieldOptions { +>SubscribeFieldOptions : Symbol(SubscribeFieldOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 25, 2)) +>Event : Symbol(Event, Decl(thislessFunctionsNotContextSensitive1.ts, 28, 32)) + + subscribe: () => Event; +>subscribe : Symbol(SubscribeFieldOptions.subscribe, Decl(thislessFunctionsNotContextSensitive1.ts, 28, 40)) +>Event : Symbol(Event, Decl(thislessFunctionsNotContextSensitive1.ts, 28, 32)) + + resolve: (event: Event) => number; +>resolve : Symbol(SubscribeFieldOptions.resolve, Decl(thislessFunctionsNotContextSensitive1.ts, 29, 25)) +>event : Symbol(event, Decl(thislessFunctionsNotContextSensitive1.ts, 30, 12)) +>Event : Symbol(Event, Decl(thislessFunctionsNotContextSensitive1.ts, 28, 32)) +} + +declare function defineOptions( +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 31, 1)) +>Event : Symbol(Event, Decl(thislessFunctionsNotContextSensitive1.ts, 33, 31)) + + options: SubscribeFieldOptions, +>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive1.ts, 33, 38)) +>SubscribeFieldOptions : Symbol(SubscribeFieldOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 25, 2)) +>Event : Symbol(Event, Decl(thislessFunctionsNotContextSensitive1.ts, 33, 31)) + +): void; + +defineOptions({ +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 31, 1)) + + resolve: (event) => event, // number +>resolve : Symbol(resolve, Decl(thislessFunctionsNotContextSensitive1.ts, 37, 15)) +>event : Symbol(event, Decl(thislessFunctionsNotContextSensitive1.ts, 38, 12)) +>event : Symbol(event, Decl(thislessFunctionsNotContextSensitive1.ts, 38, 12)) + + subscribe() { +>subscribe : Symbol(subscribe, Decl(thislessFunctionsNotContextSensitive1.ts, 38, 28)) + + return 123; + }, +}); + +defineOptions({ +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 31, 1)) + + resolve: (event) => event, // number +>resolve : Symbol(resolve, Decl(thislessFunctionsNotContextSensitive1.ts, 44, 15)) +>event : Symbol(event, Decl(thislessFunctionsNotContextSensitive1.ts, 45, 12)) +>event : Symbol(event, Decl(thislessFunctionsNotContextSensitive1.ts, 45, 12)) + + subscribe: function () { +>subscribe : Symbol(subscribe, Decl(thislessFunctionsNotContextSensitive1.ts, 45, 28)) + + return 123; + }, +}); + +// https://github.com/microsoft/TypeScript/issues/58630 + +export type StateFunction = (s: State, ...args: any[]) => any; +>StateFunction : Symbol(StateFunction, Decl(thislessFunctionsNotContextSensitive1.ts, 49, 3)) +>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 26)) +>s : Symbol(s, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 36)) +>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 26)) +>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 45)) + +export type VuexStoreOptions = { +>VuexStoreOptions : Symbol(VuexStoreOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 69)) +>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 29)) +>Modules : Symbol(Modules, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 35)) + + state?: State | (() => State) | { (): State }; +>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 48)) +>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 29)) +>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 29)) +>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 29)) + + mutations?: Record>; +>mutations : Symbol(mutations, Decl(thislessFunctionsNotContextSensitive1.ts, 56, 48)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>StateFunction : Symbol(StateFunction, Decl(thislessFunctionsNotContextSensitive1.ts, 49, 3)) +>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 29)) + + modules?: { +>modules : Symbol(modules, Decl(thislessFunctionsNotContextSensitive1.ts, 57, 51)) + + [k in keyof Modules]: VuexStoreOptions; +>k : Symbol(k, Decl(thislessFunctionsNotContextSensitive1.ts, 59, 5)) +>Modules : Symbol(Modules, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 35)) +>VuexStoreOptions : Symbol(VuexStoreOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 69)) +>Modules : Symbol(Modules, Decl(thislessFunctionsNotContextSensitive1.ts, 55, 35)) +>k : Symbol(k, Decl(thislessFunctionsNotContextSensitive1.ts, 59, 5)) + + }; +}; + +export function createStore< +>createStore : Symbol(createStore, Decl(thislessFunctionsNotContextSensitive1.ts, 61, 2)) + + State extends Record, +>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 63, 28)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + + Modules extends Record>, +>Modules : Symbol(Modules, Decl(thislessFunctionsNotContextSensitive1.ts, 64, 40)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +>(options: VuexStoreOptions) {} +>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive1.ts, 66, 2)) +>VuexStoreOptions : Symbol(VuexStoreOptions, Decl(thislessFunctionsNotContextSensitive1.ts, 53, 69)) +>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 63, 28)) +>Modules : Symbol(Modules, Decl(thislessFunctionsNotContextSensitive1.ts, 64, 40)) + +const store = createStore({ +>store : Symbol(store, Decl(thislessFunctionsNotContextSensitive1.ts, 68, 5)) +>createStore : Symbol(createStore, Decl(thislessFunctionsNotContextSensitive1.ts, 61, 2)) + + state() { +>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 68, 27)) + + return { bar2: 1 }; +>bar2 : Symbol(bar2, Decl(thislessFunctionsNotContextSensitive1.ts, 70, 12)) + + }, + mutations: { inc: (state123) => state123.bar2++ }, +>mutations : Symbol(mutations, Decl(thislessFunctionsNotContextSensitive1.ts, 71, 4)) +>inc : Symbol(inc, Decl(thislessFunctionsNotContextSensitive1.ts, 72, 14)) +>state123 : Symbol(state123, Decl(thislessFunctionsNotContextSensitive1.ts, 72, 21)) +>state123.bar2 : Symbol(bar2, Decl(thislessFunctionsNotContextSensitive1.ts, 70, 12)) +>state123 : Symbol(state123, Decl(thislessFunctionsNotContextSensitive1.ts, 72, 21)) +>bar2 : Symbol(bar2, Decl(thislessFunctionsNotContextSensitive1.ts, 70, 12)) + + modules: { +>modules : Symbol(modules, Decl(thislessFunctionsNotContextSensitive1.ts, 72, 52)) + + foo: { +>foo : Symbol(foo, Decl(thislessFunctionsNotContextSensitive1.ts, 73, 12)) + + state() { +>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 74, 10)) + + return { bar2: 1 }; +>bar2 : Symbol(bar2, Decl(thislessFunctionsNotContextSensitive1.ts, 76, 16)) + + }, + mutations: { inc: (state) => state.bar2++ }, +>mutations : Symbol(mutations, Decl(thislessFunctionsNotContextSensitive1.ts, 77, 8)) +>inc : Symbol(inc, Decl(thislessFunctionsNotContextSensitive1.ts, 78, 18)) +>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 78, 25)) +>state.bar2 : Symbol(bar2, Decl(thislessFunctionsNotContextSensitive1.ts, 76, 16)) +>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 78, 25)) +>bar2 : Symbol(bar2, Decl(thislessFunctionsNotContextSensitive1.ts, 76, 16)) + + }, + }, +}); + +// https://github.com/microsoft/TypeScript/issues/57572 + +type C = void>(options: { +>C : Symbol(C, Decl(thislessFunctionsNotContextSensitive1.ts, 81, 3)) +>Methods : Symbol(Methods, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 10)) +>Attached : Symbol(Attached, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 18)) +>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 31)) +>Methods : Symbol(Methods, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 10)) +>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 58)) + + methods: Methods; +>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 68)) +>Methods : Symbol(Methods, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 10)) + + attached: Attached; +>attached : Symbol(attached, Decl(thislessFunctionsNotContextSensitive1.ts, 86, 19)) +>Attached : Symbol(Attached, Decl(thislessFunctionsNotContextSensitive1.ts, 85, 18)) + +}) => any; + +var Component: C = () => {}; +>Component : Symbol(Component, Decl(thislessFunctionsNotContextSensitive1.ts, 90, 3)) +>C : Symbol(C, Decl(thislessFunctionsNotContextSensitive1.ts, 81, 3)) + +Component({ +>Component : Symbol(Component, Decl(thislessFunctionsNotContextSensitive1.ts, 90, 3)) + + attached(methods) { +>attached : Symbol(attached, Decl(thislessFunctionsNotContextSensitive1.ts, 92, 11)) +>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 93, 11)) + + methods.bbb(); // ok +>methods.bbb : Symbol(bbb, Decl(thislessFunctionsNotContextSensitive1.ts, 96, 12)) +>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 93, 11)) +>bbb : Symbol(bbb, Decl(thislessFunctionsNotContextSensitive1.ts, 96, 12)) + + }, + methods: { +>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 95, 4)) + + bbb() {}, +>bbb : Symbol(bbb, Decl(thislessFunctionsNotContextSensitive1.ts, 96, 12)) + + }, +}); + +Component({ +>Component : Symbol(Component, Decl(thislessFunctionsNotContextSensitive1.ts, 90, 3)) + + attached(methods) { +>attached : Symbol(attached, Decl(thislessFunctionsNotContextSensitive1.ts, 101, 11)) +>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 102, 11)) + + methods.bbb(); // ok +>methods.bbb : Symbol(bbb, Decl(thislessFunctionsNotContextSensitive1.ts, 105, 12)) +>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 102, 11)) +>bbb : Symbol(bbb, Decl(thislessFunctionsNotContextSensitive1.ts, 105, 12)) + + }, + methods: { +>methods : Symbol(methods, Decl(thislessFunctionsNotContextSensitive1.ts, 104, 4)) + + bbb: () => {}, +>bbb : Symbol(bbb, Decl(thislessFunctionsNotContextSensitive1.ts, 105, 12)) + + }, +}); + +// https://github.com/microsoft/TypeScript/issues/56067 + +declare function create56067< +>create56067 : Symbol(create56067, Decl(thislessFunctionsNotContextSensitive1.ts, 108, 3)) + + State extends Record, +>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 112, 29)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + + Data extends Record, +>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive1.ts, 113, 36)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + + Actions extends (state: State, data: Data) => Record, +>Actions : Symbol(Actions, Decl(thislessFunctionsNotContextSensitive1.ts, 114, 35)) +>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 115, 19)) +>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 112, 29)) +>data : Symbol(data, Decl(thislessFunctionsNotContextSensitive1.ts, 115, 32)) +>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive1.ts, 113, 36)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + +>(args: { getState: () => State; actions: Actions; getData: () => Data }): void; +>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive1.ts, 116, 2)) +>getState : Symbol(getState, Decl(thislessFunctionsNotContextSensitive1.ts, 116, 9)) +>State : Symbol(State, Decl(thislessFunctionsNotContextSensitive1.ts, 112, 29)) +>actions : Symbol(actions, Decl(thislessFunctionsNotContextSensitive1.ts, 116, 32)) +>Actions : Symbol(Actions, Decl(thislessFunctionsNotContextSensitive1.ts, 114, 35)) +>getData : Symbol(getData, Decl(thislessFunctionsNotContextSensitive1.ts, 116, 50)) +>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive1.ts, 113, 36)) + +create56067({ +>create56067 : Symbol(create56067, Decl(thislessFunctionsNotContextSensitive1.ts, 108, 3)) + + getState() { +>getState : Symbol(getState, Decl(thislessFunctionsNotContextSensitive1.ts, 118, 13)) + + return { a: 1 }; +>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 120, 12)) + + }, + getData: () => { +>getData : Symbol(getData, Decl(thislessFunctionsNotContextSensitive1.ts, 121, 4)) + + return { b: 2 }; +>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 123, 12)) + + }, + actions(state, data) { +>actions : Symbol(actions, Decl(thislessFunctionsNotContextSensitive1.ts, 124, 4)) +>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 125, 10)) +>data : Symbol(data, Decl(thislessFunctionsNotContextSensitive1.ts, 125, 16)) + + state // { a: number } +>state : Symbol(state, Decl(thislessFunctionsNotContextSensitive1.ts, 125, 10)) + + data; // { b: number } +>data : Symbol(data, Decl(thislessFunctionsNotContextSensitive1.ts, 125, 16)) + + return { + z: 1, +>z : Symbol(z, Decl(thislessFunctionsNotContextSensitive1.ts, 128, 12)) + + }; + }, +}); + +// https://github.com/microsoft/TypeScript/issues/55489 +type NonStringIterable = +>NonStringIterable : Symbol(NonStringIterable, Decl(thislessFunctionsNotContextSensitive1.ts, 132, 3)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 135, 23)) + + T extends string ? never : T extends Iterable ? T : never; +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 135, 23)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 135, 23)) +>Iterable : Symbol(Iterable, Decl(lib.es2015.iterable.d.ts, --, --)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 135, 23)) + +declare function doSomething(value: NonStringIterable): T; +>doSomething : Symbol(doSomething, Decl(thislessFunctionsNotContextSensitive1.ts, 136, 65)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 138, 29)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive1.ts, 138, 32)) +>NonStringIterable : Symbol(NonStringIterable, Decl(thislessFunctionsNotContextSensitive1.ts, 132, 3)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 138, 29)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 138, 29)) + +const o = { foo() {} }; +>o : Symbol(o, Decl(thislessFunctionsNotContextSensitive1.ts, 140, 5)) +>foo : Symbol(foo, Decl(thislessFunctionsNotContextSensitive1.ts, 140, 11)) + +doSomething('value'); // error +>doSomething : Symbol(doSomething, Decl(thislessFunctionsNotContextSensitive1.ts, 136, 65)) + +doSomething(['v']); // ok +>doSomething : Symbol(doSomething, Decl(thislessFunctionsNotContextSensitive1.ts, 136, 65)) + +doSomething([o]); // ok +>doSomething : Symbol(doSomething, Decl(thislessFunctionsNotContextSensitive1.ts, 136, 65)) +>o : Symbol(o, Decl(thislessFunctionsNotContextSensitive1.ts, 140, 5)) + +doSomething([{ foo() {} }]); // ok +>doSomething : Symbol(doSomething, Decl(thislessFunctionsNotContextSensitive1.ts, 136, 65)) +>foo : Symbol(foo, Decl(thislessFunctionsNotContextSensitive1.ts, 145, 14)) + +// https://github.com/microsoft/TypeScript/issues/55124 +type Values = T[keyof T]; +>Values : Symbol(Values, Decl(thislessFunctionsNotContextSensitive1.ts, 145, 28)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 148, 12)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 148, 12)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 148, 12)) + +type ExtractFields = Values<{ +>ExtractFields : Symbol(ExtractFields, Decl(thislessFunctionsNotContextSensitive1.ts, 148, 28)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive1.ts, 149, 19)) +>Values : Symbol(Values, Decl(thislessFunctionsNotContextSensitive1.ts, 145, 28)) + + [K in keyof Options]: Options[K] extends object ? keyof Options[K] : never; +>K : Symbol(K, Decl(thislessFunctionsNotContextSensitive1.ts, 150, 3)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive1.ts, 149, 19)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive1.ts, 149, 19)) +>K : Symbol(K, Decl(thislessFunctionsNotContextSensitive1.ts, 150, 3)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive1.ts, 149, 19)) +>K : Symbol(K, Decl(thislessFunctionsNotContextSensitive1.ts, 150, 3)) + +}>; +type SetType = { +>SetType : Symbol(SetType, Decl(thislessFunctionsNotContextSensitive1.ts, 151, 3)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive1.ts, 152, 13)) + + [key: string]: any; +>key : Symbol(key, Decl(thislessFunctionsNotContextSensitive1.ts, 153, 3)) + + target?: ExtractFields; +>target : Symbol(target, Decl(thislessFunctionsNotContextSensitive1.ts, 153, 21)) +>ExtractFields : Symbol(ExtractFields, Decl(thislessFunctionsNotContextSensitive1.ts, 148, 28)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive1.ts, 152, 13)) + +}; + +declare function test55124>( +>test55124 : Symbol(test55124, Decl(thislessFunctionsNotContextSensitive1.ts, 155, 2)) +>OptionsData : Symbol(OptionsData, Decl(thislessFunctionsNotContextSensitive1.ts, 157, 27)) +>SetType : Symbol(SetType, Decl(thislessFunctionsNotContextSensitive1.ts, 151, 3)) +>OptionsData : Symbol(OptionsData, Decl(thislessFunctionsNotContextSensitive1.ts, 157, 27)) + + options: OptionsData, +>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive1.ts, 157, 69)) +>OptionsData : Symbol(OptionsData, Decl(thislessFunctionsNotContextSensitive1.ts, 157, 27)) + +): void; + +test55124({ +>test55124 : Symbol(test55124, Decl(thislessFunctionsNotContextSensitive1.ts, 155, 2)) + + target: "$test4", // ok +>target : Symbol(target, Decl(thislessFunctionsNotContextSensitive1.ts, 161, 11)) + + data1: { +>data1 : Symbol(data1, Decl(thislessFunctionsNotContextSensitive1.ts, 162, 19)) + + $test1: 111, +>$test1 : Symbol($test1, Decl(thislessFunctionsNotContextSensitive1.ts, 163, 10)) + + $test2: null, +>$test2 : Symbol($test2, Decl(thislessFunctionsNotContextSensitive1.ts, 164, 16)) + + }, + data2: { +>data2 : Symbol(data2, Decl(thislessFunctionsNotContextSensitive1.ts, 166, 4)) + + $test3: {}, +>$test3 : Symbol($test3, Decl(thislessFunctionsNotContextSensitive1.ts, 167, 10)) + + $test4: () => {}, +>$test4 : Symbol($test4, Decl(thislessFunctionsNotContextSensitive1.ts, 168, 15)) + + $test5() {}, +>$test5 : Symbol($test5, Decl(thislessFunctionsNotContextSensitive1.ts, 169, 21)) + + }, +}); + +test55124({ +>test55124 : Symbol(test55124, Decl(thislessFunctionsNotContextSensitive1.ts, 155, 2)) + + target: "$test6", // error +>target : Symbol(target, Decl(thislessFunctionsNotContextSensitive1.ts, 174, 11)) + + data1: { +>data1 : Symbol(data1, Decl(thislessFunctionsNotContextSensitive1.ts, 175, 19)) + + $test1: 111, +>$test1 : Symbol($test1, Decl(thislessFunctionsNotContextSensitive1.ts, 176, 10)) + + $test2: null, +>$test2 : Symbol($test2, Decl(thislessFunctionsNotContextSensitive1.ts, 177, 16)) + + }, + data2: { +>data2 : Symbol(data2, Decl(thislessFunctionsNotContextSensitive1.ts, 179, 4)) + + $test3: {}, +>$test3 : Symbol($test3, Decl(thislessFunctionsNotContextSensitive1.ts, 180, 10)) + + $test4: () => {}, +>$test4 : Symbol($test4, Decl(thislessFunctionsNotContextSensitive1.ts, 181, 15)) + + $test5() {}, +>$test5 : Symbol($test5, Decl(thislessFunctionsNotContextSensitive1.ts, 182, 21)) + + }, +}); + +// https://github.com/microsoft/TypeScript/issues/53924 +function test53924(options: { a: (c: T) => void; b: () => T }) {} +>test53924 : Symbol(test53924, Decl(thislessFunctionsNotContextSensitive1.ts, 185, 3)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 19)) +>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 32)) +>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 42)) +>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 47)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 19)) +>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 61)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 188, 19)) + +test53924({ +>test53924 : Symbol(test53924, Decl(thislessFunctionsNotContextSensitive1.ts, 185, 3)) + + a: (c) => { +>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 190, 11)) +>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 191, 6)) + + c; // number; +>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 191, 6)) + + }, + b: () => 123, +>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 193, 4)) + +}); + +test53924({ +>test53924 : Symbol(test53924, Decl(thislessFunctionsNotContextSensitive1.ts, 185, 3)) + + b: () => 123, +>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 197, 11)) + + a: (c) => { +>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 198, 15)) +>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 199, 6)) + + return c; // number +>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 199, 6)) + + }, +}); + +test53924({ +>test53924 : Symbol(test53924, Decl(thislessFunctionsNotContextSensitive1.ts, 185, 3)) + + b() { +>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 204, 11)) + + return 123; + }, + a(c) { +>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 207, 4)) +>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 208, 4)) + + return c; // number +>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 208, 4)) + + }, +}); + +test53924({ +>test53924 : Symbol(test53924, Decl(thislessFunctionsNotContextSensitive1.ts, 185, 3)) + + a(c) { +>a : Symbol(a, Decl(thislessFunctionsNotContextSensitive1.ts, 213, 11)) +>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 214, 4)) + + return c; // number +>c : Symbol(c, Decl(thislessFunctionsNotContextSensitive1.ts, 214, 4)) + + }, + b() { +>b : Symbol(b, Decl(thislessFunctionsNotContextSensitive1.ts, 216, 4)) + + return 123; + }, +}); + +// https://github.com/microsoft/TypeScript/issues/50258 +declare function monitor any>( +>monitor : Symbol(monitor, Decl(thislessFunctionsNotContextSensitive1.ts, 220, 3)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 25)) +>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 36)) + + extractor: (...args: Parameters) => Record, +>extractor : Symbol(extractor, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 58)) +>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive1.ts, 224, 14)) +>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 25)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) + + executor: T, +>executor : Symbol(executor, Decl(thislessFunctionsNotContextSensitive1.ts, 224, 65)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 25)) + +): (...args: Parameters) => ReturnType; +>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive1.ts, 226, 4)) +>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 25)) +>ReturnType : Symbol(ReturnType, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive1.ts, 223, 25)) + +monitor( +>monitor : Symbol(monitor, Decl(thislessFunctionsNotContextSensitive1.ts, 220, 3)) + + (p) => ({ p }), // { p: number } +>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 229, 3)) +>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 229, 11)) + + (p: number) => p, +>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 230, 3)) +>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 230, 3)) + +); +monitor( +>monitor : Symbol(monitor, Decl(thislessFunctionsNotContextSensitive1.ts, 220, 3)) + + (p) => ({ p }), // { p: number } +>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 233, 3)) +>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 233, 11)) + + function (p: number) { +>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 234, 12)) + + return p; +>p : Symbol(p, Decl(thislessFunctionsNotContextSensitive1.ts, 234, 12)) + + }, +); + diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive1.types b/tests/baselines/reference/thislessFunctionsNotContextSensitive1.types new file mode 100644 index 0000000000000..54eac35ad5070 --- /dev/null +++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive1.types @@ -0,0 +1,926 @@ +//// [tests/cases/compiler/thislessFunctionsNotContextSensitive1.ts] //// + +=== thislessFunctionsNotContextSensitive1.ts === +// https://github.com/microsoft/TypeScript/issues/62204 + +declare function TestConfig( +>TestConfig : (config: TConfig, test: keyof Omit extends never ? true : false) => void +> : ^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>a : any +> : ^^^ +>b : any +> : ^^^ +>c : any +> : ^^^ + + config: TConfig, +>config : TConfig +> : ^^^^^^^ + + test: keyof Omit extends never ? true : false, +>test : Exclude extends never ? true : false +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>true : true +> : ^^^^ +>false : false +> : ^^^^^ + +): void; + +TestConfig( +>TestConfig( { a: "hello", b: function () { return 123; }, }, true,) : void +> : ^^^^ +>TestConfig : (config: TConfig, test: keyof Omit extends never ? true : false) => void +> : ^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ + { +>{ a: "hello", b: function () { return 123; }, } : { a: "hello"; b: () => 123; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + a: "hello", +>a : "hello" +> : ^^^^^^^ +>"hello" : "hello" +> : ^^^^^^^ + + b: function () { +>b : () => 123 +> : ^^^^^^^^^ +>function () { return 123; } : () => 123 +> : ^^^^^^^^^ + + return 123; +>123 : 123 +> : ^^^ + + }, + }, + true, +>true : true +> : ^^^^ + +); + +TestConfig( +>TestConfig( { a: "hello", b: function () { return 123; }, }, false, // error) : void +> : ^^^^ +>TestConfig : (config: TConfig, test: keyof Omit extends never ? true : false) => void +> : ^^^^^^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ + { +>{ a: "hello", b: function () { return 123; }, } : { a: "hello"; b: () => 123; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + a: "hello", +>a : "hello" +> : ^^^^^^^ +>"hello" : "hello" +> : ^^^^^^^ + + b: function () { +>b : () => 123 +> : ^^^^^^^^^ +>function () { return 123; } : () => 123 +> : ^^^^^^^^^ + + return 123; +>123 : 123 +> : ^^^ + + }, + }, + false, // error +>false : false +> : ^^^^^ + +); + +// https://github.com/microsoft/TypeScript/issues/60986 +interface SubscribeFieldOptions { + subscribe: () => Event; +>subscribe : () => Event +> : ^^^^^^ + + resolve: (event: Event) => number; +>resolve : (event: Event) => number +> : ^ ^^ ^^^^^ +>event : Event +> : ^^^^^ +} + +declare function defineOptions( +>defineOptions : (options: SubscribeFieldOptions) => void +> : ^ ^^ ^^ ^^^^^ + + options: SubscribeFieldOptions, +>options : SubscribeFieldOptions +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +): void; + +defineOptions({ +>defineOptions({ resolve: (event) => event, // number subscribe() { return 123; },}) : void +> : ^^^^ +>defineOptions : (options: SubscribeFieldOptions) => void +> : ^ ^^ ^^ ^^^^^ +>{ resolve: (event) => event, // number subscribe() { return 123; },} : { resolve: (event: number) => number; subscribe(): number; } +> : ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + resolve: (event) => event, // number +>resolve : (event: number) => number +> : ^ ^^^^^^^^^^^^^^^^^^^ +>(event) => event : (event: number) => number +> : ^ ^^^^^^^^^^^^^^^^^^^ +>event : number +> : ^^^^^^ +>event : number +> : ^^^^^^ + + subscribe() { +>subscribe : () => number +> : ^^^^^^^^^^^^ + + return 123; +>123 : 123 +> : ^^^ + + }, +}); + +defineOptions({ +>defineOptions({ resolve: (event) => event, // number subscribe: function () { return 123; },}) : void +> : ^^^^ +>defineOptions : (options: SubscribeFieldOptions) => void +> : ^ ^^ ^^ ^^^^^ +>{ resolve: (event) => event, // number subscribe: function () { return 123; },} : { resolve: (event: number) => number; subscribe: () => number; } +> : ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + resolve: (event) => event, // number +>resolve : (event: number) => number +> : ^ ^^^^^^^^^^^^^^^^^^^ +>(event) => event : (event: number) => number +> : ^ ^^^^^^^^^^^^^^^^^^^ +>event : number +> : ^^^^^^ +>event : number +> : ^^^^^^ + + subscribe: function () { +>subscribe : () => number +> : ^^^^^^^^^^^^ +>function () { return 123; } : () => number +> : ^^^^^^^^^^^^ + + return 123; +>123 : 123 +> : ^^^ + + }, +}); + +// https://github.com/microsoft/TypeScript/issues/58630 + +export type StateFunction = (s: State, ...args: any[]) => any; +>StateFunction : StateFunction +> : ^^^^^^^^^^^^^^^^^^^^ +>s : State +> : ^^^^^ +>args : any[] +> : ^^^^^ + +export type VuexStoreOptions = { +>VuexStoreOptions : VuexStoreOptions +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + state?: State | (() => State) | { (): State }; +>state : State | (() => State) | (() => State) | undefined +> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^ + + mutations?: Record>; +>mutations : Record> | undefined +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + modules?: { +>modules : { [k in keyof Modules]: VuexStoreOptions; } | undefined +> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + [k in keyof Modules]: VuexStoreOptions; + }; +}; + +export function createStore< +>createStore : , Modules extends Record>>(options: VuexStoreOptions) => void +> : ^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^ + + State extends Record, + Modules extends Record>, +>(options: VuexStoreOptions) {} +>options : VuexStoreOptions +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +const store = createStore({ +>store : void +> : ^^^^ +>createStore({ state() { return { bar2: 1 }; }, mutations: { inc: (state123) => state123.bar2++ }, modules: { foo: { state() { return { bar2: 1 }; }, mutations: { inc: (state) => state.bar2++ }, }, },}) : void +> : ^^^^ +>createStore : , Modules extends Record>>(options: VuexStoreOptions) => void +> : ^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^ +>{ state() { return { bar2: 1 }; }, mutations: { inc: (state123) => state123.bar2++ }, modules: { foo: { state() { return { bar2: 1 }; }, mutations: { inc: (state) => state.bar2++ }, }, },} : { state(): { bar2: number; }; mutations: { inc: (state123: { bar2: number; }) => number; }; modules: { foo: { state(): { bar2: number; }; mutations: { inc: (state: { bar2: number; }) => number; }; }; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + state() { +>state : () => { bar2: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^ + + return { bar2: 1 }; +>{ bar2: 1 } : { bar2: number; } +> : ^^^^^^^^^^^^^^^^^ +>bar2 : number +> : ^^^^^^ +>1 : 1 +> : ^ + + }, + mutations: { inc: (state123) => state123.bar2++ }, +>mutations : { inc: (state123: { bar2: number; }) => number; } +> : ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ inc: (state123) => state123.bar2++ } : { inc: (state123: { bar2: number; }) => number; } +> : ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>inc : (state123: { bar2: number; }) => number +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(state123) => state123.bar2++ : (state123: { bar2: number; }) => number +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>state123 : { bar2: number; } +> : ^^^^^^^^^^^^^^^^^ +>state123.bar2++ : number +> : ^^^^^^ +>state123.bar2 : number +> : ^^^^^^ +>state123 : { bar2: number; } +> : ^^^^^^^^^^^^^^^^^ +>bar2 : number +> : ^^^^^^ + + modules: { +>modules : { foo: { state(): { bar2: number; }; mutations: { inc: (state: { bar2: number; }) => number; }; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ foo: { state() { return { bar2: 1 }; }, mutations: { inc: (state) => state.bar2++ }, }, } : { foo: { state(): { bar2: number; }; mutations: { inc: (state: { bar2: number; }) => number; }; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + foo: { +>foo : { state(): { bar2: number; }; mutations: { inc: (state: { bar2: number; }) => number; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ state() { return { bar2: 1 }; }, mutations: { inc: (state) => state.bar2++ }, } : { state(): { bar2: number; }; mutations: { inc: (state: { bar2: number; }) => number; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + state() { +>state : () => { bar2: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^ + + return { bar2: 1 }; +>{ bar2: 1 } : { bar2: number; } +> : ^^^^^^^^^^^^^^^^^ +>bar2 : number +> : ^^^^^^ +>1 : 1 +> : ^ + + }, + mutations: { inc: (state) => state.bar2++ }, +>mutations : { inc: (state: { bar2: number; }) => number; } +> : ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ inc: (state) => state.bar2++ } : { inc: (state: { bar2: number; }) => number; } +> : ^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>inc : (state: { bar2: number; }) => number +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>(state) => state.bar2++ : (state: { bar2: number; }) => number +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>state : { bar2: number; } +> : ^^^^^^^^^^^^^^^^^ +>state.bar2++ : number +> : ^^^^^^ +>state.bar2 : number +> : ^^^^^^ +>state : { bar2: number; } +> : ^^^^^^^^^^^^^^^^^ +>bar2 : number +> : ^^^^^^ + + }, + }, +}); + +// https://github.com/microsoft/TypeScript/issues/57572 + +type C = void>(options: { +>C : C +> : ^ +>methods : Methods +> : ^^^^^^^ +>options : { methods: Methods; attached: Attached; } +> : ^^^^^^^^^^^ ^^^^^^^^^^^^ ^^^ + + methods: Methods; +>methods : Methods +> : ^^^^^^^ + + attached: Attached; +>attached : Attached +> : ^^^^^^^^ + +}) => any; + +var Component: C = () => {}; +>Component : C +> : ^ +>() => {} : () => void +> : ^^^^^^^^^^ + +Component({ +>Component({ attached(methods) { methods.bbb(); // ok }, methods: { bbb() {}, },}) : any +> : ^^^ +>Component : C +> : ^ +>{ attached(methods) { methods.bbb(); // ok }, methods: { bbb() {}, },} : { attached(methods: { bbb(): void; }): void; methods: { bbb(): void; }; } +> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + attached(methods) { +>attached : (methods: { bbb(): void; }) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>methods : { bbb(): void; } +> : ^^^^^^^^^^^^^^^^ + + methods.bbb(); // ok +>methods.bbb() : void +> : ^^^^ +>methods.bbb : () => void +> : ^^^^^^^^^^ +>methods : { bbb(): void; } +> : ^^^^^^^^^^^^^^^^ +>bbb : () => void +> : ^^^^^^^^^^ + + }, + methods: { +>methods : { bbb(): void; } +> : ^^^^^^^^^^^^^^^^ +>{ bbb() {}, } : { bbb(): void; } +> : ^^^^^^^^^^^^^^^^ + + bbb() {}, +>bbb : () => void +> : ^^^^^^^^^^ + + }, +}); + +Component({ +>Component({ attached(methods) { methods.bbb(); // ok }, methods: { bbb: () => {}, },}) : any +> : ^^^ +>Component : C +> : ^ +>{ attached(methods) { methods.bbb(); // ok }, methods: { bbb: () => {}, },} : { attached(methods: { bbb: () => void; }): void; methods: { bbb: () => void; }; } +> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + attached(methods) { +>attached : (methods: { bbb: () => void; }) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>methods : { bbb: () => void; } +> : ^^^^^^^^^^^^^^^^^^^^ + + methods.bbb(); // ok +>methods.bbb() : void +> : ^^^^ +>methods.bbb : () => void +> : ^^^^^^^^^^ +>methods : { bbb: () => void; } +> : ^^^^^^^^^^^^^^^^^^^^ +>bbb : () => void +> : ^^^^^^^^^^ + + }, + methods: { +>methods : { bbb: () => void; } +> : ^^^^^^^^^^^^^^^^^^^^ +>{ bbb: () => {}, } : { bbb: () => void; } +> : ^^^^^^^^^^^^^^^^^^^^ + + bbb: () => {}, +>bbb : () => void +> : ^^^^^^^^^^ +>() => {} : () => void +> : ^^^^^^^^^^ + + }, +}); + +// https://github.com/microsoft/TypeScript/issues/56067 + +declare function create56067< +>create56067 : , Data extends Record, Actions extends (state: State, data: Data) => Record>(args: { getState: () => State; actions: Actions; getData: () => Data; }) => void +> : ^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^^^^ + + State extends Record, + Data extends Record, + Actions extends (state: State, data: Data) => Record, +>state : State +> : ^^^^^ +>data : Data +> : ^^^^ + +>(args: { getState: () => State; actions: Actions; getData: () => Data }): void; +>args : { getState: () => State; actions: Actions; getData: () => Data; } +> : ^^^^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^ ^^^ +>getState : () => State +> : ^^^^^^ +>actions : Actions +> : ^^^^^^^ +>getData : () => Data +> : ^^^^^^ + +create56067({ +>create56067({ getState() { return { a: 1 }; }, getData: () => { return { b: 2 }; }, actions(state, data) { state // { a: number } data; // { b: number } return { z: 1, }; },}) : void +> : ^^^^ +>create56067 : , Data extends Record, Actions extends (state: State, data: Data) => Record>(args: { getState: () => State; actions: Actions; getData: () => Data; }) => void +> : ^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>{ getState() { return { a: 1 }; }, getData: () => { return { b: 2 }; }, actions(state, data) { state // { a: number } data; // { b: number } return { z: 1, }; },} : { getState(): { a: number; }; getData: () => { b: number; }; actions(state: { a: number; }, data: { b: number; }): { z: number; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + getState() { +>getState : () => { a: number; } +> : ^^^^^^^^^^^^^^^^^^^^ + + return { a: 1 }; +>{ a: 1 } : { a: number; } +> : ^^^^^^^^^^^^^^ +>a : number +> : ^^^^^^ +>1 : 1 +> : ^ + + }, + getData: () => { +>getData : () => { b: number; } +> : ^^^^^^^^^^^^^^^^^^^^ +>() => { return { b: 2 }; } : () => { b: number; } +> : ^^^^^^^^^^^^^^^^^^^^ + + return { b: 2 }; +>{ b: 2 } : { b: number; } +> : ^^^^^^^^^^^^^^ +>b : number +> : ^^^^^^ +>2 : 2 +> : ^ + + }, + actions(state, data) { +>actions : (state: { a: number; }, data: { b: number; }) => { z: number; } +> : ^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>state : { a: number; } +> : ^^^^^^^^^^^^^^ +>data : { b: number; } +> : ^^^^^^^^^^^^^^ + + state // { a: number } +>state : { a: number; } +> : ^^^^^^^^^^^^^^ + + data; // { b: number } +>data : { b: number; } +> : ^^^^^^^^^^^^^^ + + return { +>{ z: 1, } : { z: number; } +> : ^^^^^^^^^^^^^^ + + z: 1, +>z : number +> : ^^^^^^ +>1 : 1 +> : ^ + + }; + }, +}); + +// https://github.com/microsoft/TypeScript/issues/55489 +type NonStringIterable = +>NonStringIterable : NonStringIterable +> : ^^^^^^^^^^^^^^^^^^^^ + + T extends string ? never : T extends Iterable ? T : never; + +declare function doSomething(value: NonStringIterable): T; +>doSomething : (value: NonStringIterable) => T +> : ^ ^^ ^^ ^^^^^ +>value : NonStringIterable +> : ^^^^^^^^^^^^^^^^^^^^ + +const o = { foo() {} }; +>o : { foo(): void; } +> : ^^^^^^^^^^^^^^^^ +>{ foo() {} } : { foo(): void; } +> : ^^^^^^^^^^^^^^^^ +>foo : () => void +> : ^^^^^^^^^^ + +doSomething('value'); // error +>doSomething('value') : "value" +> : ^^^^^^^ +>doSomething : (value: NonStringIterable) => T +> : ^ ^^ ^^ ^^^^^ +>'value' : "value" +> : ^^^^^^^ + +doSomething(['v']); // ok +>doSomething(['v']) : string[] +> : ^^^^^^^^ +>doSomething : (value: NonStringIterable) => T +> : ^ ^^ ^^ ^^^^^ +>['v'] : string[] +> : ^^^^^^^^ +>'v' : "v" +> : ^^^ + +doSomething([o]); // ok +>doSomething([o]) : { foo(): void; }[] +> : ^^^^^^^^^^^^^^^^^^ +>doSomething : (value: NonStringIterable) => T +> : ^ ^^ ^^ ^^^^^ +>[o] : { foo(): void; }[] +> : ^^^^^^^^^^^^^^^^^^ +>o : { foo(): void; } +> : ^^^^^^^^^^^^^^^^ + +doSomething([{ foo() {} }]); // ok +>doSomething([{ foo() {} }]) : { foo(): void; }[] +> : ^^^^^^^^^^^^^^^^^^ +>doSomething : (value: NonStringIterable) => T +> : ^ ^^ ^^ ^^^^^ +>[{ foo() {} }] : { foo(): void; }[] +> : ^^^^^^^^^^^^^^^^^^ +>{ foo() {} } : { foo(): void; } +> : ^^^^^^^^^^^^^^^^ +>foo : () => void +> : ^^^^^^^^^^ + +// https://github.com/microsoft/TypeScript/issues/55124 +type Values = T[keyof T]; +>Values : Values +> : ^^^^^^^^^ + +type ExtractFields = Values<{ +>ExtractFields : ExtractFields +> : ^^^^^^^^^^^^^^^^^^^^^^ + + [K in keyof Options]: Options[K] extends object ? keyof Options[K] : never; +}>; +type SetType = { +>SetType : SetType +> : ^^^^^^^^^^^^^^^^ + + [key: string]: any; +>key : string +> : ^^^^^^ + + target?: ExtractFields; +>target : ExtractFields | undefined +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +}; + +declare function test55124>( +>test55124 : >(options: OptionsData) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ + + options: OptionsData, +>options : OptionsData +> : ^^^^^^^^^^^ + +): void; + +test55124({ +>test55124({ target: "$test4", // ok data1: { $test1: 111, $test2: null, }, data2: { $test3: {}, $test4: () => {}, $test5() {}, },}) : void +> : ^^^^ +>test55124 : >(options: OptionsData) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>{ target: "$test4", // ok data1: { $test1: 111, $test2: null, }, data2: { $test3: {}, $test4: () => {}, $test5() {}, },} : { target: "$test4"; data1: { $test1: number; $test2: null; }; data2: { $test3: {}; $test4: () => void; $test5(): void; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + target: "$test4", // ok +>target : "$test4" +> : ^^^^^^^^ +>"$test4" : "$test4" +> : ^^^^^^^^ + + data1: { +>data1 : { $test1: number; $test2: null; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ $test1: 111, $test2: null, } : { $test1: number; $test2: null; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + $test1: 111, +>$test1 : number +> : ^^^^^^ +>111 : 111 +> : ^^^ + + $test2: null, +>$test2 : null +> : ^^^^ + + }, + data2: { +>data2 : { $test3: {}; $test4: () => void; $test5(): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ $test3: {}, $test4: () => {}, $test5() {}, } : { $test3: {}; $test4: () => void; $test5(): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + $test3: {}, +>$test3 : {} +> : ^^ +>{} : {} +> : ^^ + + $test4: () => {}, +>$test4 : () => void +> : ^^^^^^^^^^ +>() => {} : () => void +> : ^^^^^^^^^^ + + $test5() {}, +>$test5 : () => void +> : ^^^^^^^^^^ + + }, +}); + +test55124({ +>test55124({ target: "$test6", // error data1: { $test1: 111, $test2: null, }, data2: { $test3: {}, $test4: () => {}, $test5() {}, },}) : void +> : ^^^^ +>test55124 : >(options: OptionsData) => void +> : ^ ^^^^^^^^^ ^^ ^^ ^^^^^ +>{ target: "$test6", // error data1: { $test1: 111, $test2: null, }, data2: { $test3: {}, $test4: () => {}, $test5() {}, },} : { target: "$test6"; data1: { $test1: number; $test2: null; }; data2: { $test3: {}; $test4: () => void; $test5(): void; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + target: "$test6", // error +>target : "$test6" +> : ^^^^^^^^ +>"$test6" : "$test6" +> : ^^^^^^^^ + + data1: { +>data1 : { $test1: number; $test2: null; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ $test1: 111, $test2: null, } : { $test1: number; $test2: null; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + $test1: 111, +>$test1 : number +> : ^^^^^^ +>111 : 111 +> : ^^^ + + $test2: null, +>$test2 : null +> : ^^^^ + + }, + data2: { +>data2 : { $test3: {}; $test4: () => void; $test5(): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ $test3: {}, $test4: () => {}, $test5() {}, } : { $test3: {}; $test4: () => void; $test5(): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + $test3: {}, +>$test3 : {} +> : ^^ +>{} : {} +> : ^^ + + $test4: () => {}, +>$test4 : () => void +> : ^^^^^^^^^^ +>() => {} : () => void +> : ^^^^^^^^^^ + + $test5() {}, +>$test5 : () => void +> : ^^^^^^^^^^ + + }, +}); + +// https://github.com/microsoft/TypeScript/issues/53924 +function test53924(options: { a: (c: T) => void; b: () => T }) {} +>test53924 : (options: { a: (c: T) => void; b: () => T; }) => void +> : ^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^ +>options : { a: (c: T) => void; b: () => T; } +> : ^^^^^ ^^^^^ ^^^ +>a : (c: T) => void +> : ^ ^^ ^^^^^ +>c : T +> : ^ +>b : () => T +> : ^^^^^^ + +test53924({ +>test53924({ a: (c) => { c; // number; }, b: () => 123,}) : void +> : ^^^^ +>test53924 : (options: { a: (c: T) => void; b: () => T; }) => void +> : ^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^ +>{ a: (c) => { c; // number; }, b: () => 123,} : { a: (c: number) => void; b: () => number; } +> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + a: (c) => { +>a : (c: number) => void +> : ^ ^^^^^^^^^^^^^^^^^ +>(c) => { c; // number; } : (c: number) => void +> : ^ ^^^^^^^^^^^^^^^^^ +>c : number +> : ^^^^^^ + + c; // number; +>c : number +> : ^^^^^^ + + }, + b: () => 123, +>b : () => number +> : ^^^^^^^^^^^^ +>() => 123 : () => number +> : ^^^^^^^^^^^^ +>123 : 123 +> : ^^^ + +}); + +test53924({ +>test53924({ b: () => 123, a: (c) => { return c; // number },}) : void +> : ^^^^ +>test53924 : (options: { a: (c: T) => void; b: () => T; }) => void +> : ^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^ +>{ b: () => 123, a: (c) => { return c; // number },} : { b: () => number; a: (c: number) => number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ + + b: () => 123, +>b : () => number +> : ^^^^^^^^^^^^ +>() => 123 : () => number +> : ^^^^^^^^^^^^ +>123 : 123 +> : ^^^ + + a: (c) => { +>a : (c: number) => number +> : ^ ^^^^^^^^^^^^^^^^^^^ +>(c) => { return c; // number } : (c: number) => number +> : ^ ^^^^^^^^^^^^^^^^^^^ +>c : number +> : ^^^^^^ + + return c; // number +>c : number +> : ^^^^^^ + + }, +}); + +test53924({ +>test53924({ b() { return 123; }, a(c) { return c; // number },}) : void +> : ^^^^ +>test53924 : (options: { a: (c: T) => void; b: () => T; }) => void +> : ^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^ +>{ b() { return 123; }, a(c) { return c; // number },} : { b(): number; a(c: number): number; } +> : ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ + + b() { +>b : () => number +> : ^^^^^^^^^^^^ + + return 123; +>123 : 123 +> : ^^^ + + }, + a(c) { +>a : (c: number) => number +> : ^ ^^^^^^^^^^^^^^^^^^^ +>c : number +> : ^^^^^^ + + return c; // number +>c : number +> : ^^^^^^ + + }, +}); + +test53924({ +>test53924({ a(c) { return c; // number }, b() { return 123; },}) : void +> : ^^^^ +>test53924 : (options: { a: (c: T) => void; b: () => T; }) => void +> : ^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^ +>{ a(c) { return c; // number }, b() { return 123; },} : { a(c: number): number; b(): number; } +> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + a(c) { +>a : (c: number) => number +> : ^ ^^^^^^^^^^^^^^^^^^^ +>c : number +> : ^^^^^^ + + return c; // number +>c : number +> : ^^^^^^ + + }, + b() { +>b : () => number +> : ^^^^^^^^^^^^ + + return 123; +>123 : 123 +> : ^^^ + + }, +}); + +// https://github.com/microsoft/TypeScript/issues/50258 +declare function monitor any>( +>monitor : any>(extractor: (...args: Parameters) => Record, executor: T) => (...args: Parameters) => ReturnType +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ +>args : any +> : ^^^ + + extractor: (...args: Parameters) => Record, +>extractor : (...args: Parameters) => Record +> : ^^^^ ^^ ^^^^^ +>args : Parameters +> : ^^^^^^^^^^^^^ + + executor: T, +>executor : T +> : ^ + +): (...args: Parameters) => ReturnType; +>args : Parameters +> : ^^^^^^^^^^^^^ + +monitor( +>monitor( (p) => ({ p }), // { p: number } (p: number) => p,) : (p: number) => number +> : ^^^^^^^^^^^^^^^^^^^^^ +>monitor : any>(extractor: (...args: Parameters) => Record, executor: T) => (...args: Parameters) => ReturnType +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ + + (p) => ({ p }), // { p: number } +>(p) => ({ p }) : (p: number) => { p: number; } +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p : number +> : ^^^^^^ +>({ p }) : { p: number; } +> : ^^^^^^^^^^^^^^ +>{ p } : { p: number; } +> : ^^^^^^^^^^^^^^ +>p : number +> : ^^^^^^ + + (p: number) => p, +>(p: number) => p : (p: number) => number +> : ^ ^^ ^^^^^^^^^^^ +>p : number +> : ^^^^^^ +>p : number +> : ^^^^^^ + +); +monitor( +>monitor( (p) => ({ p }), // { p: number } function (p: number) { return p; },) : (p: number) => number +> : ^^^^^^^^^^^^^^^^^^^^^ +>monitor : any>(extractor: (...args: Parameters) => Record, executor: T) => (...args: Parameters) => ReturnType +> : ^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^^^ + + (p) => ({ p }), // { p: number } +>(p) => ({ p }) : (p: number) => { p: number; } +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>p : number +> : ^^^^^^ +>({ p }) : { p: number; } +> : ^^^^^^^^^^^^^^ +>{ p } : { p: number; } +> : ^^^^^^^^^^^^^^ +>p : number +> : ^^^^^^ + + function (p: number) { +>function (p: number) { return p; } : (p: number) => number +> : ^ ^^ ^^^^^^^^^^^ +>p : number +> : ^^^^^^ + + return p; +>p : number +> : ^^^^^^ + + }, +); + diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive2.errors.txt b/tests/baselines/reference/thislessFunctionsNotContextSensitive2.errors.txt new file mode 100644 index 0000000000000..299f833b65a1b --- /dev/null +++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive2.errors.txt @@ -0,0 +1,132 @@ +thislessFunctionsNotContextSensitive2.ts(52,14): error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation. +thislessFunctionsNotContextSensitive2.ts(83,12): error TS7041: The containing arrow function captures the global value of 'this'. + + +==== thislessFunctionsNotContextSensitive2.ts (2 errors) ==== + interface Options { + context: Context; + produce(this: Context): Data; + consume(this: Context, data: Data): void; + } + + declare function defineOptions( + options: Options, + ): [Context, Data]; + + const result1 = defineOptions({ + context: { tag: "A", value: 1 }, + consume(_data) {}, + produce() { + return 42; + }, + }); + + const result2 = defineOptions({ + context: { tag: "B", value: 2 }, + consume(_data) {}, + produce() { + return this.value; + }, + }); + + const result3 = defineOptions({ + context: { tag: "C", value: 3 }, + consume(_data) {}, + produce: () => 123, + }); + + const result4 = defineOptions({ + context: { tag: "D", value: 4 }, + consume(_data) {}, + produce() { + class Local { + value = 'foo'; + get() { + return this.value; + } + } + return new Local().get();; + }, + }); + + const result5 = defineOptions({ + context: { tag: "E", value: 5 }, + consume(_data) {}, + produce() { + function inner() { + return this; + ~~~~ +!!! error TS2683: 'this' implicitly has type 'any' because it does not have a type annotation. +!!! related TS2738 thislessFunctionsNotContextSensitive2.ts:51:14: An outer value of 'this' is shadowed by this container. + } + return inner(); + }, + }); + + const result6 = defineOptions({ + context: { tag: "F", value: 6 }, + consume(_data) {}, + produce() { + const arrow = () => this.value; + return arrow(); + }, + }); + + const result7 = defineOptions({ + context: { tag: "G", value: 7 }, + consume(_data) {}, + produce() { + const self = this; + function inner() { + return self.value; + } + return inner(); + }, + }); + + const result8 = defineOptions({ + context: { tag: "H", value: 8 }, + consume(_data) {}, + produce: () => { + return this; + ~~~~ +!!! error TS7041: The containing arrow function captures the global value of 'this'. + }, + }); + + const result9 = defineOptions({ + context: { tag: "I", value: 9 }, + consume(_data) {}, + produce() { + const obj = { + value: 'foo', + get() { + return this.value; + }, + }; + return obj.get(); + }, + }); + + const result10 = defineOptions({ + context: { tag: "I", value: 9 }, + consume(_data) {}, + produce() { + interface Foo { + prop: this; + } + return {} as Foo; + }, + }); + + const result11 = defineOptions({ + context: { tag: "I", value: 9 }, + consume(_data) {}, + produce() { + function fn(this: { prop: string }) { + return this.prop; + } + return fn; + }, + }); + \ No newline at end of file diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive2.symbols b/tests/baselines/reference/thislessFunctionsNotContextSensitive2.symbols new file mode 100644 index 0000000000000..29d0c190d417f --- /dev/null +++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive2.symbols @@ -0,0 +1,353 @@ +//// [tests/cases/compiler/thislessFunctionsNotContextSensitive2.ts] //// + +=== thislessFunctionsNotContextSensitive2.ts === +interface Options { +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 0)) +>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 18)) +>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 26)) + + context: Context; +>context : Symbol(Options.context, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 34)) +>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 18)) + + produce(this: Context): Data; +>produce : Symbol(Options.produce, Decl(thislessFunctionsNotContextSensitive2.ts, 1, 19)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 2, 10)) +>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 18)) +>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 26)) + + consume(this: Context, data: Data): void; +>consume : Symbol(Options.consume, Decl(thislessFunctionsNotContextSensitive2.ts, 2, 31)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 3, 10)) +>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 18)) +>data : Symbol(data, Decl(thislessFunctionsNotContextSensitive2.ts, 3, 24)) +>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 26)) +} + +declare function defineOptions( +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1)) +>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 31)) +>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 39)) + + options: Options, +>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 46)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive2.ts, 0, 0)) +>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 31)) +>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 39)) + +): [Context, Data]; +>Context : Symbol(Context, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 31)) +>Data : Symbol(Data, Decl(thislessFunctionsNotContextSensitive2.ts, 6, 39)) + +const result1 = defineOptions({ +>result1 : Symbol(result1, Decl(thislessFunctionsNotContextSensitive2.ts, 10, 5)) +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1)) + + context: { tag: "A", value: 1 }, +>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 10, 31)) +>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 11, 12)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 11, 22)) + + consume(_data) {}, +>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 11, 34)) +>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 12, 10)) + + produce() { +>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 12, 20)) + + return 42; + }, +}); + +const result2 = defineOptions({ +>result2 : Symbol(result2, Decl(thislessFunctionsNotContextSensitive2.ts, 18, 5)) +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1)) + + context: { tag: "B", value: 2 }, +>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 18, 31)) +>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 19, 12)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 19, 22)) + + consume(_data) {}, +>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 19, 34)) +>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 20, 10)) + + produce() { +>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 20, 20)) + + return this.value; +>this.value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 19, 22)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 2, 10)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 19, 22)) + + }, +}); + +const result3 = defineOptions({ +>result3 : Symbol(result3, Decl(thislessFunctionsNotContextSensitive2.ts, 26, 5)) +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1)) + + context: { tag: "C", value: 3 }, +>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 26, 31)) +>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 27, 12)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 27, 22)) + + consume(_data) {}, +>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 27, 34)) +>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 28, 10)) + + produce: () => 123, +>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 28, 20)) + +}); + +const result4 = defineOptions({ +>result4 : Symbol(result4, Decl(thislessFunctionsNotContextSensitive2.ts, 32, 5)) +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1)) + + context: { tag: "D", value: 4 }, +>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 32, 31)) +>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 33, 12)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 33, 22)) + + consume(_data) {}, +>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 33, 34)) +>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 34, 10)) + + produce() { +>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 34, 20)) + + class Local { +>Local : Symbol(Local, Decl(thislessFunctionsNotContextSensitive2.ts, 35, 13)) + + value = 'foo'; +>value : Symbol(Local.value, Decl(thislessFunctionsNotContextSensitive2.ts, 36, 17)) + + get() { +>get : Symbol(Local.get, Decl(thislessFunctionsNotContextSensitive2.ts, 37, 20)) + + return this.value; +>this.value : Symbol(Local.value, Decl(thislessFunctionsNotContextSensitive2.ts, 36, 17)) +>this : Symbol(Local, Decl(thislessFunctionsNotContextSensitive2.ts, 35, 13)) +>value : Symbol(Local.value, Decl(thislessFunctionsNotContextSensitive2.ts, 36, 17)) + } + } + return new Local().get();; +>new Local().get : Symbol(Local.get, Decl(thislessFunctionsNotContextSensitive2.ts, 37, 20)) +>Local : Symbol(Local, Decl(thislessFunctionsNotContextSensitive2.ts, 35, 13)) +>get : Symbol(Local.get, Decl(thislessFunctionsNotContextSensitive2.ts, 37, 20)) + + }, +}); + +const result5 = defineOptions({ +>result5 : Symbol(result5, Decl(thislessFunctionsNotContextSensitive2.ts, 46, 5)) +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1)) + + context: { tag: "E", value: 5 }, +>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 46, 31)) +>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 47, 12)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 47, 22)) + + consume(_data) {}, +>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 47, 34)) +>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 48, 10)) + + produce() { +>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 48, 20)) + + function inner() { +>inner : Symbol(inner, Decl(thislessFunctionsNotContextSensitive2.ts, 49, 13)) + + return this; + } + return inner(); +>inner : Symbol(inner, Decl(thislessFunctionsNotContextSensitive2.ts, 49, 13)) + + }, +}); + +const result6 = defineOptions({ +>result6 : Symbol(result6, Decl(thislessFunctionsNotContextSensitive2.ts, 57, 5)) +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1)) + + context: { tag: "F", value: 6 }, +>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 57, 31)) +>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 58, 12)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 58, 22)) + + consume(_data) {}, +>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 58, 34)) +>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 59, 10)) + + produce() { +>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 59, 20)) + + const arrow = () => this.value; +>arrow : Symbol(arrow, Decl(thislessFunctionsNotContextSensitive2.ts, 61, 9)) +>this.value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 58, 22)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 2, 10)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 58, 22)) + + return arrow(); +>arrow : Symbol(arrow, Decl(thislessFunctionsNotContextSensitive2.ts, 61, 9)) + + }, +}); + +const result7 = defineOptions({ +>result7 : Symbol(result7, Decl(thislessFunctionsNotContextSensitive2.ts, 66, 5)) +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1)) + + context: { tag: "G", value: 7 }, +>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 66, 31)) +>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 67, 12)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 67, 22)) + + consume(_data) {}, +>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 67, 34)) +>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 68, 10)) + + produce() { +>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 68, 20)) + + const self = this; +>self : Symbol(self, Decl(thislessFunctionsNotContextSensitive2.ts, 70, 9)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 2, 10)) + + function inner() { +>inner : Symbol(inner, Decl(thislessFunctionsNotContextSensitive2.ts, 70, 22)) + + return self.value; +>self.value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 67, 22)) +>self : Symbol(self, Decl(thislessFunctionsNotContextSensitive2.ts, 70, 9)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 67, 22)) + } + return inner(); +>inner : Symbol(inner, Decl(thislessFunctionsNotContextSensitive2.ts, 70, 22)) + + }, +}); + +const result8 = defineOptions({ +>result8 : Symbol(result8, Decl(thislessFunctionsNotContextSensitive2.ts, 78, 5)) +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1)) + + context: { tag: "H", value: 8 }, +>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 78, 31)) +>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 79, 12)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 79, 22)) + + consume(_data) {}, +>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 79, 34)) +>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 80, 10)) + + produce: () => { +>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 80, 20)) + + return this; +>this : Symbol(globalThis) + + }, +}); + +const result9 = defineOptions({ +>result9 : Symbol(result9, Decl(thislessFunctionsNotContextSensitive2.ts, 86, 5)) +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1)) + + context: { tag: "I", value: 9 }, +>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 86, 31)) +>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 87, 12)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 87, 22)) + + consume(_data) {}, +>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 87, 34)) +>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 88, 10)) + + produce() { +>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 88, 20)) + + const obj = { +>obj : Symbol(obj, Decl(thislessFunctionsNotContextSensitive2.ts, 90, 9)) + + value: 'foo', +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 90, 17)) + + get() { +>get : Symbol(get, Decl(thislessFunctionsNotContextSensitive2.ts, 91, 19)) + + return this.value; +>this.value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 90, 17)) +>this : Symbol(obj, Decl(thislessFunctionsNotContextSensitive2.ts, 90, 15)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 90, 17)) + + }, + }; + return obj.get(); +>obj.get : Symbol(get, Decl(thislessFunctionsNotContextSensitive2.ts, 91, 19)) +>obj : Symbol(obj, Decl(thislessFunctionsNotContextSensitive2.ts, 90, 9)) +>get : Symbol(get, Decl(thislessFunctionsNotContextSensitive2.ts, 91, 19)) + + }, +}); + +const result10 = defineOptions({ +>result10 : Symbol(result10, Decl(thislessFunctionsNotContextSensitive2.ts, 100, 5)) +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1)) + + context: { tag: "I", value: 9 }, +>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 100, 32)) +>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 101, 12)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 101, 22)) + + consume(_data) {}, +>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 101, 34)) +>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 102, 10)) + + produce() { +>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 102, 20)) + + interface Foo { +>Foo : Symbol(Foo, Decl(thislessFunctionsNotContextSensitive2.ts, 103, 13)) + + prop: this; +>prop : Symbol(Foo.prop, Decl(thislessFunctionsNotContextSensitive2.ts, 104, 19)) + } + return {} as Foo; +>Foo : Symbol(Foo, Decl(thislessFunctionsNotContextSensitive2.ts, 103, 13)) + + }, +}); + +const result11 = defineOptions({ +>result11 : Symbol(result11, Decl(thislessFunctionsNotContextSensitive2.ts, 111, 5)) +>defineOptions : Symbol(defineOptions, Decl(thislessFunctionsNotContextSensitive2.ts, 4, 1)) + + context: { tag: "I", value: 9 }, +>context : Symbol(context, Decl(thislessFunctionsNotContextSensitive2.ts, 111, 32)) +>tag : Symbol(tag, Decl(thislessFunctionsNotContextSensitive2.ts, 112, 12)) +>value : Symbol(value, Decl(thislessFunctionsNotContextSensitive2.ts, 112, 22)) + + consume(_data) {}, +>consume : Symbol(consume, Decl(thislessFunctionsNotContextSensitive2.ts, 112, 34)) +>_data : Symbol(_data, Decl(thislessFunctionsNotContextSensitive2.ts, 113, 10)) + + produce() { +>produce : Symbol(produce, Decl(thislessFunctionsNotContextSensitive2.ts, 113, 20)) + + function fn(this: { prop: string }) { +>fn : Symbol(fn, Decl(thislessFunctionsNotContextSensitive2.ts, 114, 13)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 115, 16)) +>prop : Symbol(prop, Decl(thislessFunctionsNotContextSensitive2.ts, 115, 23)) + + return this.prop; +>this.prop : Symbol(prop, Decl(thislessFunctionsNotContextSensitive2.ts, 115, 23)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive2.ts, 115, 16)) +>prop : Symbol(prop, Decl(thislessFunctionsNotContextSensitive2.ts, 115, 23)) + } + return fn; +>fn : Symbol(fn, Decl(thislessFunctionsNotContextSensitive2.ts, 114, 13)) + + }, +}); + diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive2.types b/tests/baselines/reference/thislessFunctionsNotContextSensitive2.types new file mode 100644 index 0000000000000..9d035d78b6451 --- /dev/null +++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive2.types @@ -0,0 +1,619 @@ +//// [tests/cases/compiler/thislessFunctionsNotContextSensitive2.ts] //// + +=== thislessFunctionsNotContextSensitive2.ts === +interface Options { + context: Context; +>context : Context +> : ^^^^^^^ + + produce(this: Context): Data; +>produce : (this: Context) => Data +> : ^ ^^ ^^^^^ +>this : Context +> : ^^^^^^^ + + consume(this: Context, data: Data): void; +>consume : (this: Context, data: Data) => void +> : ^ ^^ ^^ ^^ ^^^^^ +>this : Context +> : ^^^^^^^ +>data : Data +> : ^^^^ +} + +declare function defineOptions( +>defineOptions : (options: Options) => [Context, Data] +> : ^ ^^ ^^ ^^ ^^^^^ + + options: Options, +>options : Options +> : ^^^^^^^^^^^^^^^^^^^^^^ + +): [Context, Data]; + +const result1 = defineOptions({ +>result1 : [{ tag: string; value: number; }, number] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions({ context: { tag: "A", value: 1 }, consume(_data) {}, produce() { return 42; },}) : [{ tag: string; value: number; }, number] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions : (options: Options) => [Context, Data] +> : ^ ^^ ^^ ^^ ^^^^^ +>{ context: { tag: "A", value: 1 }, consume(_data) {}, produce() { return 42; },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: number): void; produce(): number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + context: { tag: "A", value: 1 }, +>context : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ tag: "A", value: 1 } : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>tag : string +> : ^^^^^^ +>"A" : "A" +> : ^^^ +>value : number +> : ^^^^^^ +>1 : 1 +> : ^ + + consume(_data) {}, +>consume : (this: { tag: string; value: number; }, _data: number) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ +>_data : number +> : ^^^^^^ + + produce() { +>produce : () => number +> : ^^^^^^^^^^^^ + + return 42; +>42 : 42 +> : ^^ + + }, +}); + +const result2 = defineOptions({ +>result2 : [{ tag: string; value: number; }, unknown] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions({ context: { tag: "B", value: 2 }, consume(_data) {}, produce() { return this.value; },}) : [{ tag: string; value: number; }, unknown] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions : (options: Options) => [Context, Data] +> : ^ ^^ ^^ ^^ ^^^^^ +>{ context: { tag: "B", value: 2 }, consume(_data) {}, produce() { return this.value; },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: unknown): void; produce(this: { tag: string; value: number; }): number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + context: { tag: "B", value: 2 }, +>context : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ tag: "B", value: 2 } : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>tag : string +> : ^^^^^^ +>"B" : "B" +> : ^^^ +>value : number +> : ^^^^^^ +>2 : 2 +> : ^ + + consume(_data) {}, +>consume : (this: { tag: string; value: number; }, _data: unknown) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ +>_data : unknown +> : ^^^^^^^ + + produce() { +>produce : (this: { tag: string; value: number; }) => number +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + return this.value; +>this.value : number +> : ^^^^^^ +>this : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>value : number +> : ^^^^^^ + + }, +}); + +const result3 = defineOptions({ +>result3 : [{ tag: string; value: number; }, number] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions({ context: { tag: "C", value: 3 }, consume(_data) {}, produce: () => 123,}) : [{ tag: string; value: number; }, number] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions : (options: Options) => [Context, Data] +> : ^ ^^ ^^ ^^ ^^^^^ +>{ context: { tag: "C", value: 3 }, consume(_data) {}, produce: () => 123,} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: number): void; produce: () => number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + context: { tag: "C", value: 3 }, +>context : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ tag: "C", value: 3 } : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>tag : string +> : ^^^^^^ +>"C" : "C" +> : ^^^ +>value : number +> : ^^^^^^ +>3 : 3 +> : ^ + + consume(_data) {}, +>consume : (this: { tag: string; value: number; }, _data: number) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ +>_data : number +> : ^^^^^^ + + produce: () => 123, +>produce : () => number +> : ^^^^^^^^^^^^ +>() => 123 : () => number +> : ^^^^^^^^^^^^ +>123 : 123 +> : ^^^ + +}); + +const result4 = defineOptions({ +>result4 : [{ tag: string; value: number; }, string] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions({ context: { tag: "D", value: 4 }, consume(_data) {}, produce() { class Local { value = 'foo'; get() { return this.value; } } return new Local().get();; },}) : [{ tag: string; value: number; }, string] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions : (options: Options) => [Context, Data] +> : ^ ^^ ^^ ^^ ^^^^^ +>{ context: { tag: "D", value: 4 }, consume(_data) {}, produce() { class Local { value = 'foo'; get() { return this.value; } } return new Local().get();; },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: string): void; produce(): string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + context: { tag: "D", value: 4 }, +>context : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ tag: "D", value: 4 } : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>tag : string +> : ^^^^^^ +>"D" : "D" +> : ^^^ +>value : number +> : ^^^^^^ +>4 : 4 +> : ^ + + consume(_data) {}, +>consume : (this: { tag: string; value: number; }, _data: string) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ +>_data : string +> : ^^^^^^ + + produce() { +>produce : () => string +> : ^^^^^^^^^^^^ + + class Local { +>Local : Local +> : ^^^^^ + + value = 'foo'; +>value : string +> : ^^^^^^ +>'foo' : "foo" +> : ^^^^^ + + get() { +>get : () => string +> : ^^^^^^^^^^^^ + + return this.value; +>this.value : string +> : ^^^^^^ +>this : this +> : ^^^^ +>value : string +> : ^^^^^^ + } + } + return new Local().get();; +>new Local().get() : string +> : ^^^^^^ +>new Local().get : () => string +> : ^^^^^^^^^^^^ +>new Local() : Local +> : ^^^^^ +>Local : typeof Local +> : ^^^^^^^^^^^^ +>get : () => string +> : ^^^^^^^^^^^^ + + }, +}); + +const result5 = defineOptions({ +>result5 : [{ tag: string; value: number; }, any] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions({ context: { tag: "E", value: 5 }, consume(_data) {}, produce() { function inner() { return this; } return inner(); },}) : [{ tag: string; value: number; }, any] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions : (options: Options) => [Context, Data] +> : ^ ^^ ^^ ^^ ^^^^^ +>{ context: { tag: "E", value: 5 }, consume(_data) {}, produce() { function inner() { return this; } return inner(); },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: any): void; produce(): any; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + context: { tag: "E", value: 5 }, +>context : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ tag: "E", value: 5 } : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>tag : string +> : ^^^^^^ +>"E" : "E" +> : ^^^ +>value : number +> : ^^^^^^ +>5 : 5 +> : ^ + + consume(_data) {}, +>consume : (this: { tag: string; value: number; }, _data: any) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ +>_data : any +> : ^^^ + + produce() { +>produce : () => any +> : ^^^^^^^^^ + + function inner() { +>inner : () => any +> : ^^^^^^^^^ + + return this; +>this : any +> : ^^^ + } + return inner(); +>inner() : any +> : ^^^ +>inner : () => any +> : ^^^^^^^^^ + + }, +}); + +const result6 = defineOptions({ +>result6 : [{ tag: string; value: number; }, unknown] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions({ context: { tag: "F", value: 6 }, consume(_data) {}, produce() { const arrow = () => this.value; return arrow(); },}) : [{ tag: string; value: number; }, unknown] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions : (options: Options) => [Context, Data] +> : ^ ^^ ^^ ^^ ^^^^^ +>{ context: { tag: "F", value: 6 }, consume(_data) {}, produce() { const arrow = () => this.value; return arrow(); },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: unknown): void; produce(this: { tag: string; value: number; }): number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + context: { tag: "F", value: 6 }, +>context : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ tag: "F", value: 6 } : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>tag : string +> : ^^^^^^ +>"F" : "F" +> : ^^^ +>value : number +> : ^^^^^^ +>6 : 6 +> : ^ + + consume(_data) {}, +>consume : (this: { tag: string; value: number; }, _data: unknown) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ +>_data : unknown +> : ^^^^^^^ + + produce() { +>produce : (this: { tag: string; value: number; }) => number +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + const arrow = () => this.value; +>arrow : () => number +> : ^^^^^^^^^^^^ +>() => this.value : () => number +> : ^^^^^^^^^^^^ +>this.value : number +> : ^^^^^^ +>this : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>value : number +> : ^^^^^^ + + return arrow(); +>arrow() : number +> : ^^^^^^ +>arrow : () => number +> : ^^^^^^^^^^^^ + + }, +}); + +const result7 = defineOptions({ +>result7 : [{ tag: string; value: number; }, unknown] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions({ context: { tag: "G", value: 7 }, consume(_data) {}, produce() { const self = this; function inner() { return self.value; } return inner(); },}) : [{ tag: string; value: number; }, unknown] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions : (options: Options) => [Context, Data] +> : ^ ^^ ^^ ^^ ^^^^^ +>{ context: { tag: "G", value: 7 }, consume(_data) {}, produce() { const self = this; function inner() { return self.value; } return inner(); },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: unknown): void; produce(this: { tag: string; value: number; }): number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + context: { tag: "G", value: 7 }, +>context : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ tag: "G", value: 7 } : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>tag : string +> : ^^^^^^ +>"G" : "G" +> : ^^^ +>value : number +> : ^^^^^^ +>7 : 7 +> : ^ + + consume(_data) {}, +>consume : (this: { tag: string; value: number; }, _data: unknown) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ +>_data : unknown +> : ^^^^^^^ + + produce() { +>produce : (this: { tag: string; value: number; }) => number +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + const self = this; +>self : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>this : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + function inner() { +>inner : () => number +> : ^^^^^^^^^^^^ + + return self.value; +>self.value : number +> : ^^^^^^ +>self : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>value : number +> : ^^^^^^ + } + return inner(); +>inner() : number +> : ^^^^^^ +>inner : () => number +> : ^^^^^^^^^^^^ + + }, +}); + +const result8 = defineOptions({ +>result8 : [{ tag: string; value: number; }, typeof globalThis] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions({ context: { tag: "H", value: 8 }, consume(_data) {}, produce: () => { return this; },}) : [{ tag: string; value: number; }, typeof globalThis] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions : (options: Options) => [Context, Data] +> : ^ ^^ ^^ ^^ ^^^^^ +>{ context: { tag: "H", value: 8 }, consume(_data) {}, produce: () => { return this; },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: typeof globalThis): void; produce: () => typeof globalThis; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + context: { tag: "H", value: 8 }, +>context : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ tag: "H", value: 8 } : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>tag : string +> : ^^^^^^ +>"H" : "H" +> : ^^^ +>value : number +> : ^^^^^^ +>8 : 8 +> : ^ + + consume(_data) {}, +>consume : (this: { tag: string; value: number; }, _data: typeof globalThis) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>_data : typeof globalThis +> : ^^^^^^^^^^^^^^^^^ + + produce: () => { +>produce : () => typeof globalThis +> : ^^^^^^^^^^^^^^^^^^^^^^^ +>() => { return this; } : () => typeof globalThis +> : ^^^^^^^^^^^^^^^^^^^^^^^ + + return this; +>this : typeof globalThis +> : ^^^^^^^^^^^^^^^^^ + + }, +}); + +const result9 = defineOptions({ +>result9 : [{ tag: string; value: number; }, string] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions({ context: { tag: "I", value: 9 }, consume(_data) {}, produce() { const obj = { value: 'foo', get() { return this.value; }, }; return obj.get(); },}) : [{ tag: string; value: number; }, string] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions : (options: Options) => [Context, Data] +> : ^ ^^ ^^ ^^ ^^^^^ +>{ context: { tag: "I", value: 9 }, consume(_data) {}, produce() { const obj = { value: 'foo', get() { return this.value; }, }; return obj.get(); },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: string): void; produce(): string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + context: { tag: "I", value: 9 }, +>context : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ tag: "I", value: 9 } : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>tag : string +> : ^^^^^^ +>"I" : "I" +> : ^^^ +>value : number +> : ^^^^^^ +>9 : 9 +> : ^ + + consume(_data) {}, +>consume : (this: { tag: string; value: number; }, _data: string) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ +>_data : string +> : ^^^^^^ + + produce() { +>produce : () => string +> : ^^^^^^^^^^^^ + + const obj = { +>obj : { value: string; get(): string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ value: 'foo', get() { return this.value; }, } : { value: string; get(): string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + value: 'foo', +>value : string +> : ^^^^^^ +>'foo' : "foo" +> : ^^^^^ + + get() { +>get : () => string +> : ^^^^^^^^^^^^ + + return this.value; +>this.value : string +> : ^^^^^^ +>this : { value: string; get(): string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>value : string +> : ^^^^^^ + + }, + }; + return obj.get(); +>obj.get() : string +> : ^^^^^^ +>obj.get : () => string +> : ^^^^^^^^^^^^ +>obj : { value: string; get(): string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>get : () => string +> : ^^^^^^^^^^^^ + + }, +}); + +const result10 = defineOptions({ +>result10 : [{ tag: string; value: number; }, Foo] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions({ context: { tag: "I", value: 9 }, consume(_data) {}, produce() { interface Foo { prop: this; } return {} as Foo; },}) : [{ tag: string; value: number; }, Foo] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>defineOptions : (options: Options) => [Context, Data] +> : ^ ^^ ^^ ^^ ^^^^^ +>{ context: { tag: "I", value: 9 }, consume(_data) {}, produce() { interface Foo { prop: this; } return {} as Foo; },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: Foo): void; produce(): Foo; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + context: { tag: "I", value: 9 }, +>context : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ tag: "I", value: 9 } : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>tag : string +> : ^^^^^^ +>"I" : "I" +> : ^^^ +>value : number +> : ^^^^^^ +>9 : 9 +> : ^ + + consume(_data) {}, +>consume : (this: { tag: string; value: number; }, _data: Foo) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ +>_data : Foo +> : ^^^ + + produce() { +>produce : () => Foo +> : ^^^^^^^^^ + + interface Foo { + prop: this; +>prop : this +> : ^^^^ + } + return {} as Foo; +>{} as Foo : Foo +> : ^^^ +>{} : {} +> : ^^ + + }, +}); + +const result11 = defineOptions({ +>result11 : [{ tag: string; value: number; }, (this: { prop: string; }) => string] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^ +>defineOptions({ context: { tag: "I", value: 9 }, consume(_data) {}, produce() { function fn(this: { prop: string }) { return this.prop; } return fn; },}) : [{ tag: string; value: number; }, (this: { prop: string; }) => string] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^ +>defineOptions : (options: Options) => [Context, Data] +> : ^ ^^ ^^ ^^ ^^^^^ +>{ context: { tag: "I", value: 9 }, consume(_data) {}, produce() { function fn(this: { prop: string }) { return this.prop; } return fn; },} : { context: { tag: string; value: number; }; consume(this: { tag: string; value: number; }, _data: (this: { prop: string; }) => string): void; produce(): (this: { prop: string; }) => string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^ + + context: { tag: "I", value: 9 }, +>context : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ tag: "I", value: 9 } : { tag: string; value: number; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>tag : string +> : ^^^^^^ +>"I" : "I" +> : ^^^ +>value : number +> : ^^^^^^ +>9 : 9 +> : ^ + + consume(_data) {}, +>consume : (this: { tag: string; value: number; }, _data: (this: { prop: string; }) => string) => void +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^ ^^^^^^^^^^^^^^^^^^^^ +>_data : (this: { prop: string; }) => string +> : ^ ^^ ^^^^^^^^^^^ + + produce() { +>produce : () => (this: { prop: string; }) => string +> : ^^^^^^^ ^^ ^^^^^^^^^^^ + + function fn(this: { prop: string }) { +>fn : (this: { prop: string; }) => string +> : ^ ^^ ^^^^^^^^^^^ +>this : { prop: string; } +> : ^^^^^^^^ ^^^ +>prop : string +> : ^^^^^^ + + return this.prop; +>this.prop : string +> : ^^^^^^ +>this : { prop: string; } +> : ^^^^^^^^ ^^^ +>prop : string +> : ^^^^^^ + } + return fn; +>fn : (this: { prop: string; }) => string +> : ^ ^^ ^^^^^^^^^^^ + + }, +}); + diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive3.errors.txt b/tests/baselines/reference/thislessFunctionsNotContextSensitive3.errors.txt new file mode 100644 index 0000000000000..7a4df0dd82493 --- /dev/null +++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive3.errors.txt @@ -0,0 +1,130 @@ +thislessFunctionsNotContextSensitive3.ts(62,9): error TS2783: 'editor' is specified more than once, so this usage will be overwritten. +thislessFunctionsNotContextSensitive3.ts(81,9): error TS2783: 'editor' is specified more than once, so this usage will be overwritten. +thislessFunctionsNotContextSensitive3.ts(96,3): error TS2353: Object literal may only specify known properties, and 'child' does not exist in type 'Partial<{ parent: string; overwrite: string; }>'. +thislessFunctionsNotContextSensitive3.ts(108,3): error TS2353: Object literal may only specify known properties, and 'child' does not exist in type 'Partial<{ parent: string; overwrite: string; }>'. + + +==== thislessFunctionsNotContextSensitive3.ts (4 errors) ==== + declare class Editor { + private _editor; + } + + declare class Plugin { + private _plugin; + } + + type ParentConfig = Partial<{ + [P in keyof T]: Required[P] extends (...args: any) => any + ? (...args: Parameters[P]>) => ReturnType[P]> + : T[P]; + }>; + + interface ExtendableConfig< + Options = any, + Config extends + | ExtensionConfig + | ExtendableConfig = ExtendableConfig, + > { + name: string; + addOptions?: (this: { + name: string; + parent: ParentConfig["addOptions"]; + }) => Options; + addProseMirrorPlugins?: (this: { + options: Options; + editor: Editor; + }) => Plugin[]; + } + + interface ExtensionConfig + extends ExtendableConfig> {} + + declare class Extension { + _options: Options; + + static create(config: Partial>): Extension; + + configure(options?: Partial): Extension; + } + + interface SuggestionOptions { + editor: Editor; + char?: string; + } + + declare function Suggestion(options: SuggestionOptions): Plugin; + + Extension.create({ + name: "slash-command", + addOptions() { + return { + suggestion: { + char: "/", + } as SuggestionOptions, + }; + }, + addProseMirrorPlugins() { + return [ + Suggestion({ + editor: this.editor, // error + ~~~~~~~~~~~~~~~~~~~ +!!! error TS2783: 'editor' is specified more than once, so this usage will be overwritten. +!!! related TS2785 thislessFunctionsNotContextSensitive3.ts:63:9: This spread always overwrites this property. + ...this.options.suggestion, + }), + ]; + }, + }); + + Extension.create({ + name: "slash-command", + addOptions: () => { + return { + suggestion: { + char: "/", + } as SuggestionOptions, + }; + }, + addProseMirrorPlugins() { + return [ + Suggestion({ + editor: this.editor, // error + ~~~~~~~~~~~~~~~~~~~ +!!! error TS2783: 'editor' is specified more than once, so this usage will be overwritten. +!!! related TS2785 thislessFunctionsNotContextSensitive3.ts:82:9: This spread always overwrites this property. + ...this.options.suggestion, + }), + ]; + }, + }); + + const parentExtension = Extension.create({ + name: "parentExtension", + addOptions() { + return { parent: "exists", overwrite: "parent" }; + }, + }); + + const childExtension = parentExtension.configure({ + child: "exists-too", // error + ~~~~~ +!!! error TS2353: Object literal may only specify known properties, and 'child' does not exist in type 'Partial<{ parent: string; overwrite: string; }>'. + overwrite: "child", + }); + + const parentExtension2 = Extension.create({ + name: "parentExtension2", + addOptions: () => { + return { parent: "exists", overwrite: "parent" }; + }, + }); + + const childExtension2 = parentExtension2.configure({ + child: "exists-too", // error + ~~~~~ +!!! error TS2353: Object literal may only specify known properties, and 'child' does not exist in type 'Partial<{ parent: string; overwrite: string; }>'. + overwrite: "child", + }); + + export {}; + \ No newline at end of file diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive3.symbols b/tests/baselines/reference/thislessFunctionsNotContextSensitive3.symbols new file mode 100644 index 0000000000000..8bb3cff42e1d1 --- /dev/null +++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive3.symbols @@ -0,0 +1,319 @@ +//// [tests/cases/compiler/thislessFunctionsNotContextSensitive3.ts] //// + +=== thislessFunctionsNotContextSensitive3.ts === +declare class Editor { +>Editor : Symbol(Editor, Decl(thislessFunctionsNotContextSensitive3.ts, 0, 0)) + + private _editor; +>_editor : Symbol(Editor._editor, Decl(thislessFunctionsNotContextSensitive3.ts, 0, 22)) +} + +declare class Plugin { +>Plugin : Symbol(Plugin, Decl(thislessFunctionsNotContextSensitive3.ts, 2, 1)) + + private _plugin; +>_plugin : Symbol(Plugin._plugin, Decl(thislessFunctionsNotContextSensitive3.ts, 4, 22)) +} + +type ParentConfig = Partial<{ +>ParentConfig : Symbol(ParentConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 6, 1)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive3.ts, 8, 18)) +>Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) + + [P in keyof T]: Required[P] extends (...args: any) => any +>P : Symbol(P, Decl(thislessFunctionsNotContextSensitive3.ts, 9, 3)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive3.ts, 8, 18)) +>Required : Symbol(Required, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive3.ts, 8, 18)) +>P : Symbol(P, Decl(thislessFunctionsNotContextSensitive3.ts, 9, 3)) +>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive3.ts, 9, 42)) + + ? (...args: Parameters[P]>) => ReturnType[P]> +>args : Symbol(args, Decl(thislessFunctionsNotContextSensitive3.ts, 10, 7)) +>Parameters : Symbol(Parameters, Decl(lib.es5.d.ts, --, --)) +>Required : Symbol(Required, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive3.ts, 8, 18)) +>P : Symbol(P, Decl(thislessFunctionsNotContextSensitive3.ts, 9, 3)) +>ReturnType : Symbol(ReturnType, Decl(lib.es5.d.ts, --, --)) +>Required : Symbol(Required, Decl(lib.es5.d.ts, --, --)) +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive3.ts, 8, 18)) +>P : Symbol(P, Decl(thislessFunctionsNotContextSensitive3.ts, 9, 3)) + + : T[P]; +>T : Symbol(T, Decl(thislessFunctionsNotContextSensitive3.ts, 8, 18)) +>P : Symbol(P, Decl(thislessFunctionsNotContextSensitive3.ts, 9, 3)) + +}>; + +interface ExtendableConfig< +>ExtendableConfig : Symbol(ExtendableConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 12, 3)) + + Options = any, +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 14, 27)) + + Config extends +>Config : Symbol(Config, Decl(thislessFunctionsNotContextSensitive3.ts, 15, 16)) + + | ExtensionConfig +>ExtensionConfig : Symbol(ExtensionConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 29, 1)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 14, 27)) + + | ExtendableConfig = ExtendableConfig, +>ExtendableConfig : Symbol(ExtendableConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 12, 3)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 14, 27)) +>ExtendableConfig : Symbol(ExtendableConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 12, 3)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 14, 27)) + +> { + name: string; +>name : Symbol(ExtendableConfig.name, Decl(thislessFunctionsNotContextSensitive3.ts, 19, 3)) + + addOptions?: (this: { +>addOptions : Symbol(ExtendableConfig.addOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 20, 15)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive3.ts, 21, 16)) + + name: string; +>name : Symbol(name, Decl(thislessFunctionsNotContextSensitive3.ts, 21, 23)) + + parent: ParentConfig["addOptions"]; +>parent : Symbol(parent, Decl(thislessFunctionsNotContextSensitive3.ts, 22, 17)) +>ParentConfig : Symbol(ParentConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 6, 1)) +>Config : Symbol(Config, Decl(thislessFunctionsNotContextSensitive3.ts, 15, 16)) + + }) => Options; +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 14, 27)) + + addProseMirrorPlugins?: (this: { +>addProseMirrorPlugins : Symbol(ExtendableConfig.addProseMirrorPlugins, Decl(thislessFunctionsNotContextSensitive3.ts, 24, 16)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 27)) + + options: Options; +>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 34)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 14, 27)) + + editor: Editor; +>editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 26, 21)) +>Editor : Symbol(Editor, Decl(thislessFunctionsNotContextSensitive3.ts, 0, 0)) + + }) => Plugin[]; +>Plugin : Symbol(Plugin, Decl(thislessFunctionsNotContextSensitive3.ts, 2, 1)) +} + +interface ExtensionConfig +>ExtensionConfig : Symbol(ExtensionConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 29, 1)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 31, 26)) + + extends ExtendableConfig> {} +>ExtendableConfig : Symbol(ExtendableConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 12, 3)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 31, 26)) +>ExtensionConfig : Symbol(ExtensionConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 29, 1)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 31, 26)) + +declare class Extension { +>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 34, 24)) + + _options: Options; +>_options : Symbol(Extension._options, Decl(thislessFunctionsNotContextSensitive3.ts, 34, 40)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 34, 24)) + + static create(config: Partial>): Extension; +>create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20)) +>O : Symbol(O, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 16)) +>config : Symbol(config, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 25)) +>Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) +>ExtensionConfig : Symbol(ExtensionConfig, Decl(thislessFunctionsNotContextSensitive3.ts, 29, 1)) +>O : Symbol(O, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 16)) +>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64)) +>O : Symbol(O, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 16)) + + configure(options?: Partial): Extension; +>configure : Symbol(Extension.configure, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 76)) +>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 39, 12)) +>Partial : Symbol(Partial, Decl(lib.es5.d.ts, --, --)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 34, 24)) +>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64)) +>Options : Symbol(Options, Decl(thislessFunctionsNotContextSensitive3.ts, 34, 24)) +} + +interface SuggestionOptions { +>SuggestionOptions : Symbol(SuggestionOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 40, 1)) + + editor: Editor; +>editor : Symbol(SuggestionOptions.editor, Decl(thislessFunctionsNotContextSensitive3.ts, 42, 29)) +>Editor : Symbol(Editor, Decl(thislessFunctionsNotContextSensitive3.ts, 0, 0)) + + char?: string; +>char : Symbol(SuggestionOptions.char, Decl(thislessFunctionsNotContextSensitive3.ts, 43, 17)) +} + +declare function Suggestion(options: SuggestionOptions): Plugin; +>Suggestion : Symbol(Suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 45, 1)) +>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 47, 28)) +>SuggestionOptions : Symbol(SuggestionOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 40, 1)) +>Plugin : Symbol(Plugin, Decl(thislessFunctionsNotContextSensitive3.ts, 2, 1)) + +Extension.create({ +>Extension.create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20)) +>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64)) +>create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20)) + + name: "slash-command", +>name : Symbol(name, Decl(thislessFunctionsNotContextSensitive3.ts, 49, 18)) + + addOptions() { +>addOptions : Symbol(addOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 50, 24)) + + return { + suggestion: { +>suggestion : Symbol(suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 52, 12)) + + char: "/", +>char : Symbol(char, Decl(thislessFunctionsNotContextSensitive3.ts, 53, 19)) + + } as SuggestionOptions, +>SuggestionOptions : Symbol(SuggestionOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 40, 1)) + + }; + }, + addProseMirrorPlugins() { +>addProseMirrorPlugins : Symbol(addProseMirrorPlugins, Decl(thislessFunctionsNotContextSensitive3.ts, 57, 4)) + + return [ + Suggestion({ +>Suggestion : Symbol(Suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 45, 1)) + + editor: this.editor, // error +>editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 60, 18)) +>this.editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 26, 21)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 27)) +>editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 26, 21)) + + ...this.options.suggestion, +>this.options.suggestion : Symbol(suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 52, 12)) +>this.options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 34)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 27)) +>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 34)) +>suggestion : Symbol(suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 52, 12)) + + }), + ]; + }, +}); + +Extension.create({ +>Extension.create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20)) +>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64)) +>create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20)) + + name: "slash-command", +>name : Symbol(name, Decl(thislessFunctionsNotContextSensitive3.ts, 68, 18)) + + addOptions: () => { +>addOptions : Symbol(addOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 69, 24)) + + return { + suggestion: { +>suggestion : Symbol(suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 71, 12)) + + char: "/", +>char : Symbol(char, Decl(thislessFunctionsNotContextSensitive3.ts, 72, 19)) + + } as SuggestionOptions, +>SuggestionOptions : Symbol(SuggestionOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 40, 1)) + + }; + }, + addProseMirrorPlugins() { +>addProseMirrorPlugins : Symbol(addProseMirrorPlugins, Decl(thislessFunctionsNotContextSensitive3.ts, 76, 4)) + + return [ + Suggestion({ +>Suggestion : Symbol(Suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 45, 1)) + + editor: this.editor, // error +>editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 79, 18)) +>this.editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 26, 21)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 27)) +>editor : Symbol(editor, Decl(thislessFunctionsNotContextSensitive3.ts, 26, 21)) + + ...this.options.suggestion, +>this.options.suggestion : Symbol(suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 71, 12)) +>this.options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 34)) +>this : Symbol(this, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 27)) +>options : Symbol(options, Decl(thislessFunctionsNotContextSensitive3.ts, 25, 34)) +>suggestion : Symbol(suggestion, Decl(thislessFunctionsNotContextSensitive3.ts, 71, 12)) + + }), + ]; + }, +}); + +const parentExtension = Extension.create({ +>parentExtension : Symbol(parentExtension, Decl(thislessFunctionsNotContextSensitive3.ts, 87, 5)) +>Extension.create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20)) +>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64)) +>create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20)) + + name: "parentExtension", +>name : Symbol(name, Decl(thislessFunctionsNotContextSensitive3.ts, 87, 42)) + + addOptions() { +>addOptions : Symbol(addOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 88, 26)) + + return { parent: "exists", overwrite: "parent" }; +>parent : Symbol(parent, Decl(thislessFunctionsNotContextSensitive3.ts, 90, 12)) +>overwrite : Symbol(overwrite, Decl(thislessFunctionsNotContextSensitive3.ts, 90, 30)) + + }, +}); + +const childExtension = parentExtension.configure({ +>childExtension : Symbol(childExtension, Decl(thislessFunctionsNotContextSensitive3.ts, 94, 5)) +>parentExtension.configure : Symbol(Extension.configure, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 76)) +>parentExtension : Symbol(parentExtension, Decl(thislessFunctionsNotContextSensitive3.ts, 87, 5)) +>configure : Symbol(Extension.configure, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 76)) + + child: "exists-too", // error +>child : Symbol(child, Decl(thislessFunctionsNotContextSensitive3.ts, 94, 50)) + + overwrite: "child", +>overwrite : Symbol(overwrite, Decl(thislessFunctionsNotContextSensitive3.ts, 95, 22)) + +}); + +const parentExtension2 = Extension.create({ +>parentExtension2 : Symbol(parentExtension2, Decl(thislessFunctionsNotContextSensitive3.ts, 99, 5)) +>Extension.create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20)) +>Extension : Symbol(Extension, Decl(thislessFunctionsNotContextSensitive3.ts, 32, 64)) +>create : Symbol(Extension.create, Decl(thislessFunctionsNotContextSensitive3.ts, 35, 20)) + + name: "parentExtension2", +>name : Symbol(name, Decl(thislessFunctionsNotContextSensitive3.ts, 99, 43)) + + addOptions: () => { +>addOptions : Symbol(addOptions, Decl(thislessFunctionsNotContextSensitive3.ts, 100, 27)) + + return { parent: "exists", overwrite: "parent" }; +>parent : Symbol(parent, Decl(thislessFunctionsNotContextSensitive3.ts, 102, 12)) +>overwrite : Symbol(overwrite, Decl(thislessFunctionsNotContextSensitive3.ts, 102, 30)) + + }, +}); + +const childExtension2 = parentExtension2.configure({ +>childExtension2 : Symbol(childExtension2, Decl(thislessFunctionsNotContextSensitive3.ts, 106, 5)) +>parentExtension2.configure : Symbol(Extension.configure, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 76)) +>parentExtension2 : Symbol(parentExtension2, Decl(thislessFunctionsNotContextSensitive3.ts, 99, 5)) +>configure : Symbol(Extension.configure, Decl(thislessFunctionsNotContextSensitive3.ts, 37, 76)) + + child: "exists-too", // error +>child : Symbol(child, Decl(thislessFunctionsNotContextSensitive3.ts, 106, 52)) + + overwrite: "child", +>overwrite : Symbol(overwrite, Decl(thislessFunctionsNotContextSensitive3.ts, 107, 22)) + +}); + +export {}; + diff --git a/tests/baselines/reference/thislessFunctionsNotContextSensitive3.types b/tests/baselines/reference/thislessFunctionsNotContextSensitive3.types new file mode 100644 index 0000000000000..b443986aa7b10 --- /dev/null +++ b/tests/baselines/reference/thislessFunctionsNotContextSensitive3.types @@ -0,0 +1,430 @@ +//// [tests/cases/compiler/thislessFunctionsNotContextSensitive3.ts] //// + +=== thislessFunctionsNotContextSensitive3.ts === +declare class Editor { +>Editor : Editor +> : ^^^^^^ + + private _editor; +>_editor : any +> : ^^^ +} + +declare class Plugin { +>Plugin : Plugin +> : ^^^^^^ + + private _plugin; +>_plugin : any +> : ^^^ +} + +type ParentConfig = Partial<{ +>ParentConfig : Partial<{ [P in keyof T]: Required[P] extends (...args: any) => any ? (...args: Parameters[P]>) => ReturnType[P]> : T[P]; }> +> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^ ^^ ^^^^^ ^^^^^^^^^^^ + + [P in keyof T]: Required[P] extends (...args: any) => any +>args : any +> : ^^^ + + ? (...args: Parameters[P]>) => ReturnType[P]> +>args : Parameters[P]> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^ + + : T[P]; +}>; + +interface ExtendableConfig< + Options = any, + Config extends + | ExtensionConfig + | ExtendableConfig = ExtendableConfig, +> { + name: string; +>name : string +> : ^^^^^^ + + addOptions?: (this: { +>addOptions : ((this: { name: string; parent: ParentConfig["addOptions"]; }) => Options) | undefined +> : ^^ ^^ ^^^^^ ^^^^^^^^^^^^^ +>this : { name: string; parent: ParentConfig["addOptions"]; } +> : ^^^^^^^^ ^^^^^^^^^^ ^^^ + + name: string; +>name : string +> : ^^^^^^ + + parent: ParentConfig["addOptions"]; +>parent : Partial<{ [P in keyof Config]: Required[P] extends (...args: any) => any ? (...args: Parameters[P]>) => ReturnType[P]> : Config[P]; }>["addOptions"] +> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + }) => Options; + addProseMirrorPlugins?: (this: { +>addProseMirrorPlugins : ((this: { options: Options; editor: Editor; }) => Plugin[]) | undefined +> : ^^ ^^ ^^^^^ ^^^^^^^^^^^^^ +>this : { options: Options; editor: Editor; } +> : ^^^^^^^^^^^ ^^^^^^^^^^ ^^^ + + options: Options; +>options : Options +> : ^^^^^^^ + + editor: Editor; +>editor : Editor +> : ^^^^^^ + + }) => Plugin[]; +} + +interface ExtensionConfig + extends ExtendableConfig> {} + +declare class Extension { +>Extension : Extension +> : ^^^^^^^^^^^^^^^^^^ + + _options: Options; +>_options : Options +> : ^^^^^^^ + + static create(config: Partial>): Extension; +>create : (config: Partial>) => Extension +> : ^ ^^^^^^^^ ^^ ^^^^^ +>config : Partial> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + configure(options?: Partial): Extension; +>configure : (options?: Partial) => Extension +> : ^ ^^^ ^^^^^ +>options : Partial | undefined +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +} + +interface SuggestionOptions { + editor: Editor; +>editor : Editor +> : ^^^^^^ + + char?: string; +>char : string | undefined +> : ^^^^^^^^^^^^^^^^^^ +} + +declare function Suggestion(options: SuggestionOptions): Plugin; +>Suggestion : (options: SuggestionOptions) => Plugin +> : ^ ^^ ^^^^^ +>options : SuggestionOptions +> : ^^^^^^^^^^^^^^^^^ + +Extension.create({ +>Extension.create({ name: "slash-command", addOptions() { return { suggestion: { char: "/", } as SuggestionOptions, }; }, addProseMirrorPlugins() { return [ Suggestion({ editor: this.editor, // error ...this.options.suggestion, }), ]; },}) : Extension<{ suggestion: SuggestionOptions; }> +> : ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ +>Extension.create : (config: Partial>) => Extension +> : ^ ^^^^^^^^ ^^ ^^^^^ +>Extension : typeof Extension +> : ^^^^^^^^^^^^^^^^ +>create : (config: Partial>) => Extension +> : ^ ^^^^^^^^ ^^ ^^^^^ +>{ name: "slash-command", addOptions() { return { suggestion: { char: "/", } as SuggestionOptions, }; }, addProseMirrorPlugins() { return [ Suggestion({ editor: this.editor, // error ...this.options.suggestion, }), ]; },} : { name: string; addOptions(): { suggestion: SuggestionOptions; }; addProseMirrorPlugins(this: { options: { suggestion: SuggestionOptions; }; editor: Editor; }): Plugin[]; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ + + name: "slash-command", +>name : string +> : ^^^^^^ +>"slash-command" : "slash-command" +> : ^^^^^^^^^^^^^^^ + + addOptions() { +>addOptions : () => { suggestion: SuggestionOptions; } +> : ^^^^^^^^^^^^^^^^^^^^ ^^^ + + return { +>{ suggestion: { char: "/", } as SuggestionOptions, } : { suggestion: SuggestionOptions; } +> : ^^^^^^^^^^^^^^ ^^^ + + suggestion: { +>suggestion : SuggestionOptions +> : ^^^^^^^^^^^^^^^^^ +>{ char: "/", } as SuggestionOptions : SuggestionOptions +> : ^^^^^^^^^^^^^^^^^ +>{ char: "/", } : { char: string; } +> : ^^^^^^^^^^^^^^^^^ + + char: "/", +>char : string +> : ^^^^^^ +>"/" : "/" +> : ^^^ + + } as SuggestionOptions, + }; + }, + addProseMirrorPlugins() { +>addProseMirrorPlugins : (this: { options: { suggestion: SuggestionOptions; }; editor: Editor; }) => Plugin[] +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ + + return [ +>[ Suggestion({ editor: this.editor, // error ...this.options.suggestion, }), ] : Plugin[] +> : ^^^^^^^^ + + Suggestion({ +>Suggestion({ editor: this.editor, // error ...this.options.suggestion, }) : Plugin +> : ^^^^^^ +>Suggestion : (options: SuggestionOptions) => Plugin +> : ^ ^^ ^^^^^ +>{ editor: this.editor, // error ...this.options.suggestion, } : { editor: Editor; char?: string; } +> : ^^^^^^^^^^ ^^^^^^^^^ ^^^ + + editor: this.editor, // error +>editor : Editor +> : ^^^^^^ +>this.editor : Editor +> : ^^^^^^ +>this : { options: { suggestion: SuggestionOptions; }; editor: Editor; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^ +>editor : Editor +> : ^^^^^^ + + ...this.options.suggestion, +>this.options.suggestion : SuggestionOptions +> : ^^^^^^^^^^^^^^^^^ +>this.options : { suggestion: SuggestionOptions; } +> : ^^^^^^^^^^^^^^ ^^^ +>this : { options: { suggestion: SuggestionOptions; }; editor: Editor; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^ +>options : { suggestion: SuggestionOptions; } +> : ^^^^^^^^^^^^^^ ^^^ +>suggestion : SuggestionOptions +> : ^^^^^^^^^^^^^^^^^ + + }), + ]; + }, +}); + +Extension.create({ +>Extension.create({ name: "slash-command", addOptions: () => { return { suggestion: { char: "/", } as SuggestionOptions, }; }, addProseMirrorPlugins() { return [ Suggestion({ editor: this.editor, // error ...this.options.suggestion, }), ]; },}) : Extension<{ suggestion: SuggestionOptions; }> +> : ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^ +>Extension.create : (config: Partial>) => Extension +> : ^ ^^^^^^^^ ^^ ^^^^^ +>Extension : typeof Extension +> : ^^^^^^^^^^^^^^^^ +>create : (config: Partial>) => Extension +> : ^ ^^^^^^^^ ^^ ^^^^^ +>{ name: "slash-command", addOptions: () => { return { suggestion: { char: "/", } as SuggestionOptions, }; }, addProseMirrorPlugins() { return [ Suggestion({ editor: this.editor, // error ...this.options.suggestion, }), ]; },} : { name: string; addOptions: () => { suggestion: SuggestionOptions; }; addProseMirrorPlugins(this: { options: { suggestion: SuggestionOptions; }; editor: Editor; }): Plugin[]; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ + + name: "slash-command", +>name : string +> : ^^^^^^ +>"slash-command" : "slash-command" +> : ^^^^^^^^^^^^^^^ + + addOptions: () => { +>addOptions : () => { suggestion: SuggestionOptions; } +> : ^^^^^^^^^^^^^^^^^^^^ ^^^ +>() => { return { suggestion: { char: "/", } as SuggestionOptions, }; } : () => { suggestion: SuggestionOptions; } +> : ^^^^^^^^^^^^^^^^^^^^ ^^^ + + return { +>{ suggestion: { char: "/", } as SuggestionOptions, } : { suggestion: SuggestionOptions; } +> : ^^^^^^^^^^^^^^ ^^^ + + suggestion: { +>suggestion : SuggestionOptions +> : ^^^^^^^^^^^^^^^^^ +>{ char: "/", } as SuggestionOptions : SuggestionOptions +> : ^^^^^^^^^^^^^^^^^ +>{ char: "/", } : { char: string; } +> : ^^^^^^^^^^^^^^^^^ + + char: "/", +>char : string +> : ^^^^^^ +>"/" : "/" +> : ^^^ + + } as SuggestionOptions, + }; + }, + addProseMirrorPlugins() { +>addProseMirrorPlugins : (this: { options: { suggestion: SuggestionOptions; }; editor: Editor; }) => Plugin[] +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ + + return [ +>[ Suggestion({ editor: this.editor, // error ...this.options.suggestion, }), ] : Plugin[] +> : ^^^^^^^^ + + Suggestion({ +>Suggestion({ editor: this.editor, // error ...this.options.suggestion, }) : Plugin +> : ^^^^^^ +>Suggestion : (options: SuggestionOptions) => Plugin +> : ^ ^^ ^^^^^ +>{ editor: this.editor, // error ...this.options.suggestion, } : { editor: Editor; char?: string; } +> : ^^^^^^^^^^ ^^^^^^^^^ ^^^ + + editor: this.editor, // error +>editor : Editor +> : ^^^^^^ +>this.editor : Editor +> : ^^^^^^ +>this : { options: { suggestion: SuggestionOptions; }; editor: Editor; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^ +>editor : Editor +> : ^^^^^^ + + ...this.options.suggestion, +>this.options.suggestion : SuggestionOptions +> : ^^^^^^^^^^^^^^^^^ +>this.options : { suggestion: SuggestionOptions; } +> : ^^^^^^^^^^^^^^ ^^^ +>this : { options: { suggestion: SuggestionOptions; }; editor: Editor; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^ +>options : { suggestion: SuggestionOptions; } +> : ^^^^^^^^^^^^^^ ^^^ +>suggestion : SuggestionOptions +> : ^^^^^^^^^^^^^^^^^ + + }), + ]; + }, +}); + +const parentExtension = Extension.create({ +>parentExtension : Extension<{ parent: string; overwrite: string; }> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>Extension.create({ name: "parentExtension", addOptions() { return { parent: "exists", overwrite: "parent" }; },}) : Extension<{ parent: string; overwrite: string; }> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>Extension.create : (config: Partial>) => Extension +> : ^ ^^^^^^^^ ^^ ^^^^^ +>Extension : typeof Extension +> : ^^^^^^^^^^^^^^^^ +>create : (config: Partial>) => Extension +> : ^ ^^^^^^^^ ^^ ^^^^^ +>{ name: "parentExtension", addOptions() { return { parent: "exists", overwrite: "parent" }; },} : { name: string; addOptions(): { parent: string; overwrite: string; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + name: "parentExtension", +>name : string +> : ^^^^^^ +>"parentExtension" : "parentExtension" +> : ^^^^^^^^^^^^^^^^^ + + addOptions() { +>addOptions : () => { parent: string; overwrite: string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + return { parent: "exists", overwrite: "parent" }; +>{ parent: "exists", overwrite: "parent" } : { parent: string; overwrite: string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>parent : string +> : ^^^^^^ +>"exists" : "exists" +> : ^^^^^^^^ +>overwrite : string +> : ^^^^^^ +>"parent" : "parent" +> : ^^^^^^^^ + + }, +}); + +const childExtension = parentExtension.configure({ +>childExtension : Extension<{ parent: string; overwrite: string; }> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>parentExtension.configure({ child: "exists-too", // error overwrite: "child",}) : Extension<{ parent: string; overwrite: string; }> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>parentExtension.configure : (options?: Partial<{ parent: string; overwrite: string; }> | undefined) => Extension<{ parent: string; overwrite: string; }> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>parentExtension : Extension<{ parent: string; overwrite: string; }> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>configure : (options?: Partial<{ parent: string; overwrite: string; }> | undefined) => Extension<{ parent: string; overwrite: string; }> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ child: "exists-too", // error overwrite: "child",} : { child: string; overwrite: string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + child: "exists-too", // error +>child : string +> : ^^^^^^ +>"exists-too" : "exists-too" +> : ^^^^^^^^^^^^ + + overwrite: "child", +>overwrite : string +> : ^^^^^^ +>"child" : "child" +> : ^^^^^^^ + +}); + +const parentExtension2 = Extension.create({ +>parentExtension2 : Extension<{ parent: string; overwrite: string; }> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>Extension.create({ name: "parentExtension2", addOptions: () => { return { parent: "exists", overwrite: "parent" }; },}) : Extension<{ parent: string; overwrite: string; }> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>Extension.create : (config: Partial>) => Extension +> : ^ ^^^^^^^^ ^^ ^^^^^ +>Extension : typeof Extension +> : ^^^^^^^^^^^^^^^^ +>create : (config: Partial>) => Extension +> : ^ ^^^^^^^^ ^^ ^^^^^ +>{ name: "parentExtension2", addOptions: () => { return { parent: "exists", overwrite: "parent" }; },} : { name: string; addOptions: () => { parent: string; overwrite: string; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + name: "parentExtension2", +>name : string +> : ^^^^^^ +>"parentExtension2" : "parentExtension2" +> : ^^^^^^^^^^^^^^^^^^ + + addOptions: () => { +>addOptions : () => { parent: string; overwrite: string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>() => { return { parent: "exists", overwrite: "parent" }; } : () => { parent: string; overwrite: string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + return { parent: "exists", overwrite: "parent" }; +>{ parent: "exists", overwrite: "parent" } : { parent: string; overwrite: string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>parent : string +> : ^^^^^^ +>"exists" : "exists" +> : ^^^^^^^^ +>overwrite : string +> : ^^^^^^ +>"parent" : "parent" +> : ^^^^^^^^ + + }, +}); + +const childExtension2 = parentExtension2.configure({ +>childExtension2 : Extension<{ parent: string; overwrite: string; }> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>parentExtension2.configure({ child: "exists-too", // error overwrite: "child",}) : Extension<{ parent: string; overwrite: string; }> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>parentExtension2.configure : (options?: Partial<{ parent: string; overwrite: string; }> | undefined) => Extension<{ parent: string; overwrite: string; }> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>parentExtension2 : Extension<{ parent: string; overwrite: string; }> +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>configure : (options?: Partial<{ parent: string; overwrite: string; }> | undefined) => Extension<{ parent: string; overwrite: string; }> +> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ child: "exists-too", // error overwrite: "child",} : { child: string; overwrite: string; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + + child: "exists-too", // error +>child : string +> : ^^^^^^ +>"exists-too" : "exists-too" +> : ^^^^^^^^^^^^ + + overwrite: "child", +>overwrite : string +> : ^^^^^^ +>"child" : "child" +> : ^^^^^^^ + +}); + +export {}; + diff --git a/tests/baselines/reference/vueLikeDataAndPropsInference.types b/tests/baselines/reference/vueLikeDataAndPropsInference.types index f71eba5d8bf66..84cb8efb7b79c 100644 --- a/tests/baselines/reference/vueLikeDataAndPropsInference.types +++ b/tests/baselines/reference/vueLikeDataAndPropsInference.types @@ -72,8 +72,8 @@ test({ > : ^^^^ >test : { (fn: ThisTypedOptions): void; (fn: Options): void; } > : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ ->{ props: { foo: '' }, data(): { bar: boolean } { return { bar: true } }, watch: { foo(newVal: string, oldVal: string): void { this.bar = false } }} : { props: { foo: string; }; data(this: Readonly<{ foo: string; }> & Instance): { bar: boolean; }; watch: { foo(newVal: string, oldVal: string): void; }; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^ +>{ props: { foo: '' }, data(): { bar: boolean } { return { bar: true } }, watch: { foo(newVal: string, oldVal: string): void { this.bar = false } }} : { props: { foo: string; }; data(): { bar: boolean; }; watch: { foo(newVal: string, oldVal: string): void; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^ props: { >props : { foo: string; } @@ -90,8 +90,8 @@ test({ }, data(): { bar: boolean } { ->data : (this: Readonly<{ foo: string; }> & Instance) => { bar: boolean; } -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>data : () => { bar: boolean; } +> : ^^^^^^ >bar : boolean > : ^^^^^^^ diff --git a/tests/baselines/reference/vueLikeDataAndPropsInference2.types b/tests/baselines/reference/vueLikeDataAndPropsInference2.types index 206646398de17..ffacfe540217f 100644 --- a/tests/baselines/reference/vueLikeDataAndPropsInference2.types +++ b/tests/baselines/reference/vueLikeDataAndPropsInference2.types @@ -73,8 +73,8 @@ test({ > : ^^^^ >test : { (fn: ThisTypedOptions): void; (fn: Options): void; } > : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^^ ^^^ ->{ props: { foo: '' }, data(): { bar: boolean } { return { bar: true } }, watch: { foo(newVal: string, oldVal: string): void { this.bar = false } }} : { props: { foo: string; }; data(this: Readonly<{ foo: string; }> & Instance): { bar: boolean; }; watch: { foo(newVal: string, oldVal: string): void; }; } -> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^ +>{ props: { foo: '' }, data(): { bar: boolean } { return { bar: true } }, watch: { foo(newVal: string, oldVal: string): void { this.bar = false } }} : { props: { foo: string; }; data(): { bar: boolean; }; watch: { foo(newVal: string, oldVal: string): void; }; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^^^^ props: { >props : { foo: string; } @@ -91,8 +91,8 @@ test({ }, data(): { bar: boolean } { ->data : (this: Readonly<{ foo: string; }> & Instance) => { bar: boolean; } -> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>data : () => { bar: boolean; } +> : ^^^^^^ >bar : boolean > : ^^^^^^^ diff --git a/tests/cases/compiler/genericCallAtYieldExpressionInGenericCall3.ts b/tests/cases/compiler/genericCallAtYieldExpressionInGenericCall3.ts new file mode 100644 index 0000000000000..571ecce45f79e --- /dev/null +++ b/tests/cases/compiler/genericCallAtYieldExpressionInGenericCall3.ts @@ -0,0 +1,49 @@ +// @strict: true +// @target: esnext +// @lib: esnext +// @noEmit: true + +type ReadonlyRecord = { + readonly [P in K]: A; +}; + +type Success = T extends Micro ? _A : never; + +interface MicroIterator> { + next(...args: ReadonlyArray): IteratorResult>; +} + +interface Micro { + _A: A; + _E: E; + _R: R; + [Symbol.iterator](): MicroIterator>; +} + +declare function runPromise(effect: Micro): Promise; + +declare function gen, AEff>( + body: () => Generator, +): Micro; + +declare const traverse: { + ( + f: (a: A) => Micro, + ): ( + self: ReadonlyRecord, + ) => Micro, E, O>; + ( + self: ReadonlyRecord, + f: (a: A) => Micro, + ): Micro, E, O>; +}; + +runPromise( + gen(function* () { + yield* traverse({ a: 1, b: 2 }, (n) => + gen(function* () { + return n + 1; + }), + ); + }), +); diff --git a/tests/cases/compiler/returnTypeInferenceContextualParameterTypesInGenerator1.ts b/tests/cases/compiler/returnTypeInferenceContextualParameterTypesInGenerator1.ts new file mode 100644 index 0000000000000..35db556e9d221 --- /dev/null +++ b/tests/cases/compiler/returnTypeInferenceContextualParameterTypesInGenerator1.ts @@ -0,0 +1,59 @@ +// @strict: true +// @target: esnext +// @noEmit: true + +interface Effect { + readonly _A: A; +} + +declare function gen, AEff>( + f: () => Generator +): Effect; + +interface Rpc< + in out Tag extends string, + out Payload = unknown, + out Success = unknown +> { + readonly _tag: Tag; + readonly payloadSchema: Payload; + readonly successSchema: Success; +} + +interface RpcAny { + readonly _tag: string; +} + +type Payload = R extends Rpc + ? _Payload + : never; + +type ResultFrom = R extends Rpc< + infer _Tag, + infer _Payload, + infer _Success +> + ? _Success + : never; + +type ToHandlerFn = ( + payload: Payload +) => ResultFrom; + +type HandlersFrom = { + readonly [Current in Rpc as Current["_tag"]]: ToHandlerFn; +}; + +interface RpcGroup { + toLayer>(build: Effect): unknown; +} + +declare const Rpcs: RpcGroup>; + +export const layerServerHandlers = Rpcs.toLayer( + gen(function* () { + return { + Register: (id) => String(id), + }; + }) +); diff --git a/tests/cases/compiler/returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts b/tests/cases/compiler/returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts new file mode 100644 index 0000000000000..d33fe8517bcd3 --- /dev/null +++ b/tests/cases/compiler/returnTypeInferenceContextualTypeIgnoreAnyUnknown1.ts @@ -0,0 +1,29 @@ +// @strict: true +// @noEmit: true + +declare function outer1(arg: { prop: any }): void; +declare function outer2(arg: { prop: unknown }): void; + +declare function inner1 any>(arg: T): T; + +const result1 = inner1((arg) => arg); + +outer1({ + prop: inner1((arg) => arg), +}); + +outer2({ + prop: inner1((arg) => arg), +}); + +declare function inner2(arg: T & ((arg: string) => any)): T; + +const result2 = inner2((arg) => arg); + +outer1({ + prop: inner2((arg) => arg), +}); + +outer2({ + prop: inner2((arg) => arg), +}); diff --git a/tests/cases/compiler/thislessFunctionsNotContextSensitive1.ts b/tests/cases/compiler/thislessFunctionsNotContextSensitive1.ts new file mode 100644 index 0000000000000..e1c340544e72c --- /dev/null +++ b/tests/cases/compiler/thislessFunctionsNotContextSensitive1.ts @@ -0,0 +1,242 @@ +// @strict: true +// @target: esnext +// @noEmit: true + +// https://github.com/microsoft/TypeScript/issues/62204 + +declare function TestConfig( + config: TConfig, + test: keyof Omit extends never ? true : false, +): void; + +TestConfig( + { + a: "hello", + b: function () { + return 123; + }, + }, + true, +); + +TestConfig( + { + a: "hello", + b: function () { + return 123; + }, + }, + false, // error +); + +// https://github.com/microsoft/TypeScript/issues/60986 +interface SubscribeFieldOptions { + subscribe: () => Event; + resolve: (event: Event) => number; +} + +declare function defineOptions( + options: SubscribeFieldOptions, +): void; + +defineOptions({ + resolve: (event) => event, // number + subscribe() { + return 123; + }, +}); + +defineOptions({ + resolve: (event) => event, // number + subscribe: function () { + return 123; + }, +}); + +// https://github.com/microsoft/TypeScript/issues/58630 + +export type StateFunction = (s: State, ...args: any[]) => any; + +export type VuexStoreOptions = { + state?: State | (() => State) | { (): State }; + mutations?: Record>; + modules?: { + [k in keyof Modules]: VuexStoreOptions; + }; +}; + +export function createStore< + State extends Record, + Modules extends Record>, +>(options: VuexStoreOptions) {} + +const store = createStore({ + state() { + return { bar2: 1 }; + }, + mutations: { inc: (state123) => state123.bar2++ }, + modules: { + foo: { + state() { + return { bar2: 1 }; + }, + mutations: { inc: (state) => state.bar2++ }, + }, + }, +}); + +// https://github.com/microsoft/TypeScript/issues/57572 + +type C = void>(options: { + methods: Methods; + attached: Attached; +}) => any; + +var Component: C = () => {}; + +Component({ + attached(methods) { + methods.bbb(); // ok + }, + methods: { + bbb() {}, + }, +}); + +Component({ + attached(methods) { + methods.bbb(); // ok + }, + methods: { + bbb: () => {}, + }, +}); + +// https://github.com/microsoft/TypeScript/issues/56067 + +declare function create56067< + State extends Record, + Data extends Record, + Actions extends (state: State, data: Data) => Record, +>(args: { getState: () => State; actions: Actions; getData: () => Data }): void; + +create56067({ + getState() { + return { a: 1 }; + }, + getData: () => { + return { b: 2 }; + }, + actions(state, data) { + state // { a: number } + data; // { b: number } + return { + z: 1, + }; + }, +}); + +// https://github.com/microsoft/TypeScript/issues/55489 +type NonStringIterable = + T extends string ? never : T extends Iterable ? T : never; + +declare function doSomething(value: NonStringIterable): T; + +const o = { foo() {} }; + +doSomething('value'); // error +doSomething(['v']); // ok +doSomething([o]); // ok +doSomething([{ foo() {} }]); // ok + +// https://github.com/microsoft/TypeScript/issues/55124 +type Values = T[keyof T]; +type ExtractFields = Values<{ + [K in keyof Options]: Options[K] extends object ? keyof Options[K] : never; +}>; +type SetType = { + [key: string]: any; + target?: ExtractFields; +}; + +declare function test55124>( + options: OptionsData, +): void; + +test55124({ + target: "$test4", // ok + data1: { + $test1: 111, + $test2: null, + }, + data2: { + $test3: {}, + $test4: () => {}, + $test5() {}, + }, +}); + +test55124({ + target: "$test6", // error + data1: { + $test1: 111, + $test2: null, + }, + data2: { + $test3: {}, + $test4: () => {}, + $test5() {}, + }, +}); + +// https://github.com/microsoft/TypeScript/issues/53924 +function test53924(options: { a: (c: T) => void; b: () => T }) {} + +test53924({ + a: (c) => { + c; // number; + }, + b: () => 123, +}); + +test53924({ + b: () => 123, + a: (c) => { + return c; // number + }, +}); + +test53924({ + b() { + return 123; + }, + a(c) { + return c; // number + }, +}); + +test53924({ + a(c) { + return c; // number + }, + b() { + return 123; + }, +}); + +// https://github.com/microsoft/TypeScript/issues/50258 +declare function monitor any>( + extractor: (...args: Parameters) => Record, + executor: T, +): (...args: Parameters) => ReturnType; + +monitor( + (p) => ({ p }), // { p: number } + (p: number) => p, +); +monitor( + (p) => ({ p }), // { p: number } + function (p: number) { + return p; + }, +); diff --git a/tests/cases/compiler/thislessFunctionsNotContextSensitive2.ts b/tests/cases/compiler/thislessFunctionsNotContextSensitive2.ts new file mode 100644 index 0000000000000..946dfc69179a7 --- /dev/null +++ b/tests/cases/compiler/thislessFunctionsNotContextSensitive2.ts @@ -0,0 +1,125 @@ +// @strict: true +// @target: esnext +// @noEmit: true + +interface Options { + context: Context; + produce(this: Context): Data; + consume(this: Context, data: Data): void; +} + +declare function defineOptions( + options: Options, +): [Context, Data]; + +const result1 = defineOptions({ + context: { tag: "A", value: 1 }, + consume(_data) {}, + produce() { + return 42; + }, +}); + +const result2 = defineOptions({ + context: { tag: "B", value: 2 }, + consume(_data) {}, + produce() { + return this.value; + }, +}); + +const result3 = defineOptions({ + context: { tag: "C", value: 3 }, + consume(_data) {}, + produce: () => 123, +}); + +const result4 = defineOptions({ + context: { tag: "D", value: 4 }, + consume(_data) {}, + produce() { + class Local { + value = 'foo'; + get() { + return this.value; + } + } + return new Local().get();; + }, +}); + +const result5 = defineOptions({ + context: { tag: "E", value: 5 }, + consume(_data) {}, + produce() { + function inner() { + return this; + } + return inner(); + }, +}); + +const result6 = defineOptions({ + context: { tag: "F", value: 6 }, + consume(_data) {}, + produce() { + const arrow = () => this.value; + return arrow(); + }, +}); + +const result7 = defineOptions({ + context: { tag: "G", value: 7 }, + consume(_data) {}, + produce() { + const self = this; + function inner() { + return self.value; + } + return inner(); + }, +}); + +const result8 = defineOptions({ + context: { tag: "H", value: 8 }, + consume(_data) {}, + produce: () => { + return this; + }, +}); + +const result9 = defineOptions({ + context: { tag: "I", value: 9 }, + consume(_data) {}, + produce() { + const obj = { + value: 'foo', + get() { + return this.value; + }, + }; + return obj.get(); + }, +}); + +const result10 = defineOptions({ + context: { tag: "I", value: 9 }, + consume(_data) {}, + produce() { + interface Foo { + prop: this; + } + return {} as Foo; + }, +}); + +const result11 = defineOptions({ + context: { tag: "I", value: 9 }, + consume(_data) {}, + produce() { + function fn(this: { prop: string }) { + return this.prop; + } + return fn; + }, +}); diff --git a/tests/cases/compiler/thislessFunctionsNotContextSensitive3.ts b/tests/cases/compiler/thislessFunctionsNotContextSensitive3.ts new file mode 100644 index 0000000000000..d730208cce63e --- /dev/null +++ b/tests/cases/compiler/thislessFunctionsNotContextSensitive3.ts @@ -0,0 +1,116 @@ +// @strict: true +// @target: esnext +// @noEmit: true + +declare class Editor { + private _editor; +} + +declare class Plugin { + private _plugin; +} + +type ParentConfig = Partial<{ + [P in keyof T]: Required[P] extends (...args: any) => any + ? (...args: Parameters[P]>) => ReturnType[P]> + : T[P]; +}>; + +interface ExtendableConfig< + Options = any, + Config extends + | ExtensionConfig + | ExtendableConfig = ExtendableConfig, +> { + name: string; + addOptions?: (this: { + name: string; + parent: ParentConfig["addOptions"]; + }) => Options; + addProseMirrorPlugins?: (this: { + options: Options; + editor: Editor; + }) => Plugin[]; +} + +interface ExtensionConfig + extends ExtendableConfig> {} + +declare class Extension { + _options: Options; + + static create(config: Partial>): Extension; + + configure(options?: Partial): Extension; +} + +interface SuggestionOptions { + editor: Editor; + char?: string; +} + +declare function Suggestion(options: SuggestionOptions): Plugin; + +Extension.create({ + name: "slash-command", + addOptions() { + return { + suggestion: { + char: "/", + } as SuggestionOptions, + }; + }, + addProseMirrorPlugins() { + return [ + Suggestion({ + editor: this.editor, // error + ...this.options.suggestion, + }), + ]; + }, +}); + +Extension.create({ + name: "slash-command", + addOptions: () => { + return { + suggestion: { + char: "/", + } as SuggestionOptions, + }; + }, + addProseMirrorPlugins() { + return [ + Suggestion({ + editor: this.editor, // error + ...this.options.suggestion, + }), + ]; + }, +}); + +const parentExtension = Extension.create({ + name: "parentExtension", + addOptions() { + return { parent: "exists", overwrite: "parent" }; + }, +}); + +const childExtension = parentExtension.configure({ + child: "exists-too", // error + overwrite: "child", +}); + +const parentExtension2 = Extension.create({ + name: "parentExtension2", + addOptions: () => { + return { parent: "exists", overwrite: "parent" }; + }, +}); + +const childExtension2 = parentExtension2.configure({ + child: "exists-too", // error + overwrite: "child", +}); + +export {};