Microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-11-18 17:21:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Replace addUndefined in serializeTypeForDeclaration with the actual declaration (#58085)

Browse Source
This commit is contained in:
Wesley Wigham
2024-04-08 21:42:50 -07:00
committed by GitHub
parent 066773b99b
commit f89a5fd674
2867 changed files with 31191 additions and 31066 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/checker.ts
+93 -35
View File
@@ -964,7 +964,7 @@ import {
setOriginalNode,
setParent,
setSyntheticLeadingComments,
setTextRange,
setTextRange as setTextRangeWorker,
setTextRangePosEnd,
setValueDeclaration,
ShorthandPropertyAssignment,
@@ -6475,7 +6475,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
typeToTypeNode: (type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => typeToTypeNodeHelper(type, context)),
typePredicateToTypePredicateNode: (typePredicate: TypePredicate, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => typePredicateToTypePredicateNodeHelper(typePredicate, context)),
expressionOrTypeToTypeNode: (expr: Expression | JsxAttributeValue | undefined, type: Type, addUndefined?: boolean, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => expressionOrTypeToTypeNode(context, expr, type, addUndefined)),
serializeTypeForDeclaration: (type: Type, symbol: Symbol, addUndefined?: boolean, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, addUndefined)),
serializeTypeForDeclaration: (declaration: Declaration, type: Type, symbol: Symbol, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => serializeTypeForDeclaration(context, declaration, type, symbol)),
serializeReturnTypeForSignature: (signature: Signature, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => serializeReturnTypeForSignature(context, signature)),
indexInfoToIndexSignatureDeclaration: (indexInfo: IndexInfo, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => indexInfoToIndexSignatureDeclarationHelper(indexInfo, context, /*typeNode*/ undefined)),
signatureToSignatureDeclaration: (signature: Signature, kind: SignatureDeclaration["kind"], enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => signatureToSignatureDeclarationHelper(signature, kind, context)),
@@ -6488,6 +6488,28 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
symbolToNode: (symbol: Symbol, meaning: SymbolFlags, enclosingDeclaration?: Node, flags?: NodeBuilderFlags, tracker?: SymbolTracker) => withContext(enclosingDeclaration, flags, tracker, context => symbolToNode(symbol, context, meaning)),
};
/**
* Unlike the utilities `setTextRange`, this checks if the `location` we're trying to set on `range` is within the
* same file as the active context. If not, the range is not applied. This prevents us from copying ranges across files,
* which will confuse the node printer (as it assumes all node ranges are within the current file).
* Additionally, if `range` _isn't synthetic_, and isn't in the current file, it will _copy_ it to _remove_ its' position
* information.
*
* It also calls `setOriginalNode` to setup a `.original` pointer, since you basically *always* want these in the node builder.
*/
function setTextRange<T extends Node>(context: NodeBuilderContext, range: T, location: Node | undefined): T {
if (!nodeIsSynthesized(range) && !(range.flags & NodeFlags.Synthesized) && (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(range))) {
range = factory.cloneNode(range);
}
if (!location) {
return range;
}
if (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(getOriginalNode(location))) {
return setOriginalNode(range, location);
}
return setTextRangeWorker(setOriginalNode(range, location), location);
}
function expressionOrTypeToTypeNode(context: NodeBuilderContext, expr: Expression | JsxAttributeValue | undefined, type: Type, addUndefined?: boolean) {
if (expr) {
const typeNode = isAssertionExpression(expr) ? expr.type
@@ -6573,6 +6595,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
undefined;
const context: NodeBuilderContext = {
enclosingDeclaration,
enclosingFile: enclosingDeclaration && getSourceFileOfNode(enclosingDeclaration),
flags: flags || NodeBuilderFlags.None,
tracker: undefined!,
encounteredError: false,
@@ -7132,7 +7155,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
if (!nodeIsSynthesized(node) && getParseTreeNode(node) === node) {
return node;
}
return setTextRange(factory.cloneNode(visitEachChild(node, deepCloneOrReuseNode, /*context*/ undefined, deepCloneOrReuseNodes)), node);
return setTextRange(context, factory.cloneNode(visitEachChild(node, deepCloneOrReuseNode, /*context*/ undefined, deepCloneOrReuseNodes)), node);
}
function deepCloneOrReuseNodes(
@@ -7145,7 +7168,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
if (nodes && nodes.length === 0) {
// Ensure we explicitly make a copy of an empty array; visitNodes will not do this unless the array has elements,
// which can lead to us reusing the same empty NodeArray more than once within the same AST during type noding.
return setTextRange(factory.createNodeArray(/*elements*/ undefined, nodes.hasTrailingComma), nodes);
return setTextRangeWorker(factory.createNodeArray(/*elements*/ undefined, nodes.hasTrailingComma), nodes);
}
return visitNodes(nodes, visitor, test, start, count);
}
@@ -7515,7 +7538,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
context.reverseMappedStack ||= [];
context.reverseMappedStack.push(propertySymbol as ReverseMappedSymbol);
}
propertyTypeNode = propertyType ? serializeTypeForDeclaration(context, propertyType, propertySymbol, saveEnclosingDeclaration) : factory.createKeywordTypeNode(SyntaxKind.AnyKeyword);
propertyTypeNode = propertyType ? serializeTypeForDeclaration(context, /*declaration*/ undefined, propertyType, propertySymbol) : factory.createKeywordTypeNode(SyntaxKind.AnyKeyword);
if (propertyIsReverseMapped) {
context.reverseMappedStack!.pop();
}
@@ -7932,8 +7955,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
const parameterDeclaration = getEffectiveParameterDeclaration(parameterSymbol);
const parameterType = getTypeOfSymbol(parameterSymbol);
const addUndefined = parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration);
const parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, addUndefined);
const parameterTypeNode = serializeTypeForDeclaration(context, parameterDeclaration, parameterType, parameterSymbol);
const modifiers = !(context.flags & NodeBuilderFlags.OmitParameterModifiers) && preserveModifierFlags && parameterDeclaration && canHaveModifiers(parameterDeclaration) ? map(getModifiers(parameterDeclaration), factory.cloneNode) : undefined;
const isRest = parameterDeclaration && isRestParameter(parameterDeclaration) || getCheckFlags(parameterSymbol) & CheckFlags.RestParameter;
@@ -8589,10 +8611,18 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
/**
* Unlike `typeToTypeNodeHelper`, this handles setting up the `AllowUniqueESSymbolType` flag
* so a `unique symbol` is returned when appropriate for the input symbol, rather than `typeof sym`
* @param context - The node builder context. Any reused nodes are checked to be pulled from within the scope of the context's enclosingDeclaration.
* @param declaration - The preferred declaration to pull existing type nodes from (the symbol will be used as a fallback to find any annotated declaration)
* @param type - The type to write; an existing annotation must match this type if it's used, otherwise this is the type serialized as a new type node
* @param symbol - The symbol is used both to find an existing annotation if declaration is not provided, and to determine if `unique symbol` should be printed
*/
function serializeTypeForDeclaration(context: NodeBuilderContext, type: Type, symbol: Symbol, enclosingDeclaration: Node | undefined, addUndefined?: boolean) {
function serializeTypeForDeclaration(context: NodeBuilderContext, declaration: Declaration | undefined, type: Type, symbol: Symbol) {
const addUndefined = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration);
const enclosingDeclaration = context.enclosingDeclaration;
if (!isErrorType(type) && enclosingDeclaration) {
const declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
const declWithExistingAnnotation = declaration && getNonlocalEffectiveTypeAnnotationNode(declaration)
? declaration
: getDeclarationWithTypeAnnotation(symbol, getEnclosingDeclarationIgnoringFakeScope(enclosingDeclaration));
if (declWithExistingAnnotation && !isFunctionLikeDeclaration(declWithExistingAnnotation) && !isGetAccessorDeclaration(declWithExistingAnnotation)) {
// try to reuse the existing annotation
const existing = getNonlocalEffectiveTypeAnnotationNode(declWithExistingAnnotation)!;
@@ -8610,7 +8640,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
context.flags |= NodeBuilderFlags.AllowUniqueESSymbolType;
}
const decl = symbol.valueDeclaration ?? symbol.declarations?.[0];
const decl = declaration ?? symbol.valueDeclaration ?? symbol.declarations?.[0];
const expr = decl && isDeclarationWithPossibleInnerTypeNodeReuse(decl) ? getPossibleTypeNodeReuseExpression(decl) : undefined;
const result = expressionOrTypeToTypeNode(context, expr, type, addUndefined);
@@ -8719,11 +8749,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
const type = getDeclaredTypeOfSymbol(sym!);
const name = sym!.flags & SymbolFlags.TypeParameter ? typeParameterToName(type, context) : factory.cloneNode(node as Identifier);
name.symbol = sym!; // for quickinfo, which uses identifier symbol information
return setTextRange(setEmitFlags(setOriginalNode(name, node), EmitFlags.NoAsciiEscaping), node);
return setTextRange(context, setEmitFlags(name, EmitFlags.NoAsciiEscaping), node);
}
const updated = visitEachChild(node, c => attachSymbolToLeftmostIdentifier(c), /*context*/ undefined);
if (updated !== node) {
setTextRange(updated, node);
setTextRange(context, updated, node);
}
return updated;
}
@@ -8742,13 +8772,19 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
if (hadError) {
return undefined;
}
return transformed === existing ? setTextRange(factory.cloneNode(existing), existing) : transformed;
return transformed;
function visitExistingNodeTreeSymbols(node: Node): Node | undefined {
const onExitNewScope = isNewScopeNode(node) ? onEnterNewScope(node) : undefined;
const result = visitExistingNodeTreeSymbolsWorker(node);
onExitNewScope?.();
return result;
// We want to clone the subtree, so when we mark it up with __pos and __end in quickfixes,
// we don't get odd behavior because of reused nodes. We also need to clone to _remove_
// the position information if the node comes from a different file than the one the node builder
// is set to build for (even though we are reusing the node structure, the position information
// would make the printer print invalid spans for literals and identifiers, and the formatter would
// choke on the mismatched positonal spans between a parent and an injected child from another file).
return result === node ? setTextRange(context, factory.cloneNode(result), node) : result;
}
function onEnterNewScope(node: IntroducesNewScopeNode | ConditionalTypeNode) {
@@ -8885,7 +8921,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
) {
let visited = visitEachChild(node, visitExistingNodeTreeSymbols, /*context*/ undefined);
if (visited === node) {
visited = setTextRange(factory.cloneNode(node), node);
visited = setTextRange(context, factory.cloneNode(node), node);
}
(visited as Mutable<typeof visited>).type = factory.createKeywordTypeNode(SyntaxKind.AnyKeyword);
if (isParameter(node)) {
@@ -8906,11 +8942,16 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(node)) {
const visited = visitEachChild(node, visitExistingNodeTreeSymbols, /*context*/ undefined);
const clone = setTextRange(visited === node ? factory.cloneNode(node) : visited, node);
const clone = setTextRange(context, visited === node ? factory.cloneNode(node) : visited, node);
const flags = getEmitFlags(clone);
setEmitFlags(clone, flags | (context.flags & NodeBuilderFlags.MultilineObjectLiterals && isTypeLiteralNode(node) ? 0 : EmitFlags.SingleLine));
return clone;
}
if (isStringLiteral(node) && !!(context.flags & NodeBuilderFlags.UseSingleQuotesForStringLiteralType) && !node.singleQuote) {
const clone = factory.cloneNode(node);
(clone as Mutable<typeof clone>).singleQuote = true;
return clone;
}
if (isConditionalTypeNode(node)) {
const checkType = visitNode(node.checkType, visitExistingNodeTreeSymbols, isTypeNode)!;
@@ -9341,10 +9382,11 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
else {
const statement = setTextRange(
context,
factory.createVariableStatement(
/*modifiers*/ undefined,
factory.createVariableDeclarationList([
factory.createVariableDeclaration(name, /*exclamationToken*/ undefined, serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration)),
factory.createVariableDeclaration(name, /*exclamationToken*/ undefined, serializeTypeForDeclaration(context, /*declaration*/ undefined, type, symbol)),
], flags),
),
textRange,
@@ -9639,7 +9681,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
for (const sig of signatures) {
// Each overload becomes a separate function declaration, in order
const decl = signatureToSignatureDeclarationHelper(sig, SyntaxKind.FunctionDeclaration, context, { name: factory.createIdentifier(localName) }) as FunctionDeclaration;
addResult(setTextRange(decl, getSignatureTextRangeLocation(sig)), modifierFlags);
addResult(setTextRange(context, decl, getSignatureTextRangeLocation(sig)), modifierFlags);
}
// Module symbol emit will take care of module-y members, provided it has exports
if (!(symbol.flags & (SymbolFlags.ValueModule | SymbolFlags.NamespaceModule) && !!symbol.exports && !!symbol.exports.size)) {
@@ -9821,6 +9863,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
context.enclosingDeclaration = oldEnclosing;
addResult(
setTextRange(
context,
factory.createClassDeclaration(
/*modifiers*/ undefined,
localName,
@@ -10169,7 +10212,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
const statement = factory.createVariableStatement(
/*modifiers*/ undefined,
factory.createVariableDeclarationList([
factory.createVariableDeclaration(varName, /*exclamationToken*/ undefined, serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration)),
factory.createVariableDeclaration(varName, /*exclamationToken*/ undefined, serializeTypeForDeclaration(context, /*declaration*/ undefined, typeToSerialize, symbol)),
], flags),
);
// Inlined JSON types exported with [module.]exports= will already emit an export=, so should use `declare`.
@@ -10297,6 +10340,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
const paramSymbol = isFunctionLikeDeclaration(setter) ? getSignatureFromDeclaration(setter).parameters[0] : undefined;
result.push(setTextRange(
context,
factory.createSetAccessorDeclaration(
factory.createModifiersFromModifierFlags(flag),
name,
@@ -10305,7 +10349,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
/*dotDotDotToken*/ undefined,
paramSymbol ? parameterToParameterDeclarationName(paramSymbol, getEffectiveParameterDeclaration(paramSymbol), context) : "value",
/*questionToken*/ undefined,
isPrivate ? undefined : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration),
isPrivate ? undefined : serializeTypeForDeclaration(context, /*declaration*/ undefined, getTypeOfSymbol(p), p),
)],
/*body*/ undefined,
),
@@ -10315,11 +10359,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
if (p.flags & SymbolFlags.GetAccessor) {
const isPrivate = modifierFlags & ModifierFlags.Private;
result.push(setTextRange(
context,
factory.createGetAccessorDeclaration(
factory.createModifiersFromModifierFlags(flag),
name,
[],
isPrivate ? undefined : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration),
isPrivate ? undefined : serializeTypeForDeclaration(context, /*declaration*/ undefined, getTypeOfSymbol(p), p),
/*body*/ undefined,
),
p.declarations?.find(isGetAccessor) || firstPropertyLikeDecl,
@@ -10331,11 +10376,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
// If this happens, we assume the accessor takes priority, as it imposes more constraints
else if (p.flags & (SymbolFlags.Property | SymbolFlags.Variable | SymbolFlags.Accessor)) {
return setTextRange(
context,
createProperty(
factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? ModifierFlags.Readonly : 0) | flag),
name,
p.flags & SymbolFlags.Optional ? factory.createToken(SyntaxKind.QuestionToken) : undefined,
isPrivate ? undefined : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration),
isPrivate ? undefined : serializeTypeForDeclaration(context, /*declaration*/ undefined, getWriteTypeOfSymbol(p), p),
// TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357
// interface members can't have initializers, however class members _can_
/*initializer*/ undefined,
@@ -10348,6 +10394,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
const signatures = getSignaturesOfType(type, SignatureKind.Call);
if (flag & ModifierFlags.Private) {
return setTextRange(
context,
createProperty(
factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? ModifierFlags.Readonly : 0) | flag),
name,
@@ -10373,7 +10420,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
},
);
const location = sig.declaration && isPrototypePropertyAssignment(sig.declaration.parent) ? sig.declaration.parent : sig.declaration;
results.push(setTextRange(decl, location));
results.push(setTextRange(context, decl, location));
}
return results as unknown as T[];
}
@@ -10419,6 +10466,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
if (privateProtected) {
return [setTextRange(
context,
factory.createConstructorDeclaration(
factory.createModifiersFromModifierFlags(privateProtected),
/*parameters*/ [],
@@ -10433,7 +10481,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
for (const sig of signatures) {
// Each overload becomes a separate constructor declaration, in order
const decl = signatureToSignatureDeclarationHelper(sig, outputKind, context);
results.push(setTextRange(decl, sig.declaration));
results.push(setTextRange(context, decl, sig.declaration));
}
return results;
}
@@ -11073,9 +11121,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
if (parentAccess && canHaveFlowNode(parentAccess) && parentAccess.flowNode) {
const propName = getDestructuringPropertyName(node);
if (propName) {
const literal = setTextRange(parseNodeFactory.createStringLiteral(propName), node);
const literal = setTextRangeWorker(parseNodeFactory.createStringLiteral(propName), node);
const lhsExpr = isLeftHandSideExpression(parentAccess) ? parentAccess : parseNodeFactory.createParenthesizedExpression(parentAccess);
const result = setTextRange(parseNodeFactory.createElementAccessExpression(lhsExpr, literal), node);
const result = setTextRangeWorker(parseNodeFactory.createElementAccessExpression(lhsExpr, literal), node);
setParent(literal, result);
setParent(result, node);
if (lhsExpr !== parentAccess) {
@@ -34724,7 +34772,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
function createSyntheticExpression(parent: Node, type: Type, isSpread?: boolean, tupleNameSource?: ParameterDeclaration | NamedTupleMember) {
const result = parseNodeFactory.createSyntheticExpression(type, isSpread, tupleNameSource);
setTextRange(result, parent);
setTextRangeWorker(result, parent);
setParent(result, parent);
return result;
}
@@ -48648,12 +48696,13 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
return false;
}
function declaredParameterTypeContainsUndefined(parameter: ParameterDeclaration) {
if (!parameter.type) return false;
const type = getTypeFromTypeNode(parameter.type);
function declaredParameterTypeContainsUndefined(parameter: ParameterDeclaration | JSDocParameterTag) {
const typeNode = getNonlocalEffectiveTypeAnnotationNode(parameter);
if (!typeNode) return false;
const type = getTypeFromTypeNode(typeNode);
return containsUndefinedType(type);
}
function requiresAddingImplicitUndefined(parameter: ParameterDeclaration) {
function requiresAddingImplicitUndefined(parameter: ParameterDeclaration | JSDocParameterTag) {
return (isRequiredInitializedParameter(parameter) || isOptionalUninitializedParameterProperty(parameter)) && !declaredParameterTypeContainsUndefined(parameter);
}
@@ -48665,10 +48714,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
!hasSyntacticModifier(parameter, ModifierFlags.ParameterPropertyModifier);
}
function isOptionalUninitializedParameterProperty(parameter: ParameterDeclaration) {
function isOptionalUninitializedParameterProperty(parameter: ParameterDeclaration | JSDocParameterTag) {
return strictNullChecks &&
isOptionalParameter(parameter) &&
!parameter.initializer &&
(isJSDocParameterTag(parameter) || !parameter.initializer) &&
hasSyntacticModifier(parameter, ModifierFlags.ParameterPropertyModifier);
}
@@ -48819,7 +48868,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
}
}
function createTypeOfDeclaration(declarationIn: AccessorDeclaration | VariableLikeDeclaration | PropertyAccessExpression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker, addUndefined?: boolean) {
function createTypeOfDeclaration(declarationIn: AccessorDeclaration | VariableLikeDeclaration | PropertyAccessExpression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker) {
const declaration = getParseTreeNode(declarationIn, isVariableLikeOrAccessor);
if (!declaration) {
return factory.createToken(SyntaxKind.AnyKeyword) as KeywordTypeNode;
@@ -48830,7 +48879,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
? getWidenedLiteralType(getTypeOfSymbol(symbol))
: errorType;
return nodeBuilder.serializeTypeForDeclaration(type, symbol, addUndefined, enclosingDeclaration, flags | NodeBuilderFlags.MultilineObjectLiterals, tracker);
return nodeBuilder.serializeTypeForDeclaration(declaration, type, symbol, enclosingDeclaration, flags | NodeBuilderFlags.MultilineObjectLiterals, tracker);
}
type DeclarationWithPotentialInnerNodeReuse =
@@ -51454,6 +51503,15 @@ function createBasicNodeBuilderModuleSpecifierResolutionHost(host: TypeCheckerHo
interface NodeBuilderContext {
enclosingDeclaration: Node | undefined;
/**
* `enclosingFile` is generated from the initial `enclosingDeclaration` and
* is used to ensure text ranges for generated nodes are not set based on nodes from outside
* the original input's containing file. Checking the `enclosingDeclaration` at the time of
* `setTextRange` is not sufficient, as the `enclosingDeclaration` is modified by the node builder
* as it decends into some types as a shortcut to making certain scopes visible, and may be modified
* into a declaration in a different file from the original input `enclosingDeclaration`!
*/
enclosingFile: SourceFile | undefined;
flags: NodeBuilderFlags;
tracker: SymbolTrackerImpl;
src/compiler/transformers/declarations.ts
+1 -1
View File
@@ -638,7 +638,7 @@ export function transformDeclarations(context: TransformationContext) {
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.BindingElement:
case SyntaxKind.VariableDeclaration:
typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldAddImplicitUndefined);
typeNode = resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker);
break;
case SyntaxKind.FunctionDeclaration:
case SyntaxKind.ConstructSignature:
src/compiler/types.ts
+1 -1
View File
@@ -5653,7 +5653,7 @@ export interface EmitResolver {
requiresAddingImplicitUndefined(node: ParameterDeclaration): boolean;
isExpandoFunctionDeclaration(node: FunctionDeclaration): boolean;
getPropertiesOfContainerFunction(node: Declaration): Symbol[];
createTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration | PropertyAccessExpression | ElementAccessExpression | BinaryExpression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker, addUndefined?: boolean): TypeNode | undefined;
createTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration | PropertyAccessExpression | ElementAccessExpression | BinaryExpression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
createReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
createTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: NodeBuilderFlags, tracker: SymbolTracker): TypeNode | undefined;
createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration, tracker: SymbolTracker): Expression;
tests/baselines/reference/1.0lib-noErrors.types
+25 -25
View File
@@ -532,7 +532,7 @@ interface String {
*/
match(regexp: string): string[];
>match : { (regexp: string): string[]; (regexp: RegExp): string[]; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^^^^^^
>regexp : string
> : ^^^^^^
@@ -542,7 +542,7 @@ interface String {
*/
match(regexp: RegExp): string[];
>match : { (regexp: string): string[]; (regexp: RegExp): string[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^
>regexp : RegExp
> : ^^^^^^
@@ -553,7 +553,7 @@ interface String {
*/
replace(searchValue: string, replaceValue: string): string;
>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
> : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>searchValue : string
> : ^^^^^^
>replaceValue : string
@@ -566,7 +566,7 @@ interface String {
*/
replace(searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string;
>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>searchValue : string
> : ^^^^^^
>replaceValue : (substring: string, ...args: any[]) => string
@@ -583,7 +583,7 @@ interface String {
*/
replace(searchValue: RegExp, replaceValue: string): string;
>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>searchValue : RegExp
> : ^^^^^^
>replaceValue : string
@@ -596,7 +596,7 @@ interface String {
*/
replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string;
>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>searchValue : RegExp
> : ^^^^^^
>replaceValue : (substring: string, ...args: any[]) => string
@@ -612,7 +612,7 @@ interface String {
*/
search(regexp: string): number;
>search : { (regexp: string): number; (regexp: RegExp): number; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^^^^
>regexp : string
> : ^^^^^^
@@ -622,7 +622,7 @@ interface String {
*/
search(regexp: RegExp): number;
>search : { (regexp: string): number; (regexp: RegExp): number; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
>regexp : RegExp
> : ^^^^^^
@@ -647,7 +647,7 @@ interface String {
*/
split(separator: string, limit?: number): string[];
>split : { (separator: string, limit?: number): string[]; (separator: RegExp, limit?: number): string[]; }
> : ^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^
>separator : string
> : ^^^^^^
>limit : number
@@ -660,7 +660,7 @@ interface String {
*/
split(separator: RegExp, limit?: number): string[];
>split : { (separator: string, limit?: number): string[]; (separator: RegExp, limit?: number): string[]; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^
>separator : RegExp
> : ^^^^^^
>limit : number
@@ -1590,13 +1590,13 @@ interface RegExpExecArray {
splice(start: number): string[];
>splice : { (start: number): string[]; (start: number, deleteCount: number, ...items: string[]): string[]; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^^^^^^^^^^^^
>start : number
> : ^^^^^^
splice(start: number, deleteCount: number, ...items: string[]): string[];
>splice : { (start: number): string[]; (start: number, deleteCount: number, ...items: string[]): string[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
>start : number
> : ^^^^^^
>deleteCount : number
@@ -1990,7 +1990,7 @@ interface JSON {
*/
stringify(value: any): string;
>stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>value : any
/**
@@ -2000,7 +2000,7 @@ interface JSON {
*/
stringify(value: any, replacer: (key: string, value: any) => any): string;
>stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>value : any
>replacer : (key: string, value: any) => any
> : ^ ^^ ^^ ^^ ^^^^^
@@ -2015,7 +2015,7 @@ interface JSON {
*/
stringify(value: any, replacer: any[]): string;
>stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>value : any
>replacer : any[]
> : ^^^^^
@@ -2028,7 +2028,7 @@ interface JSON {
*/
stringify(value: any, replacer: (key: string, value: any) => any, space: any): string;
>stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^ ^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>value : any
>replacer : (key: string, value: any) => any
> : ^ ^^ ^^ ^^ ^^^^^
@@ -2045,7 +2045,7 @@ interface JSON {
*/
stringify(value: any, replacer: any[], space: any): string;
>stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>value : any
>replacer : any[]
> : ^^^^^
@@ -2081,7 +2081,7 @@ interface Array<T> {
*/
concat<U extends T[]>(...items: U[]): T[];
>concat : { <U extends T[]>(...items: U[]): T[]; (...items: T[]): T[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^^^^ ^^ ^^^^^^^^^
>items : U[]
> : ^^^
@@ -2091,7 +2091,7 @@ interface Array<T> {
*/
concat(...items: T[]): T[];
>concat : { <U extends T[]>(...items: U[]): T[]; (...items: T[]): T[]; }
> : ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
>items : T[]
> : ^^^
@@ -2169,7 +2169,7 @@ interface Array<T> {
*/
splice(start: number): T[];
>splice : { (start: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^^^^^^^
>start : number
> : ^^^^^^
@@ -2181,7 +2181,7 @@ interface Array<T> {
*/
splice(start: number, deleteCount: number, ...items: T[]): T[];
>splice : { (start: number): T[]; (start: number, deleteCount: number, ...items: T[]): T[]; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^ ^^^ ^^^
>start : number
> : ^^^^^^
>deleteCount : number
@@ -2322,7 +2322,7 @@ interface Array<T> {
*/
reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
>reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
> : ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^ ^^^ ^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^^^^^
>callbackfn : (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>previousValue : T
@@ -2343,7 +2343,7 @@ interface Array<T> {
*/
reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
>reduce : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>callbackfn : (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>previousValue : U
@@ -2364,7 +2364,7 @@ interface Array<T> {
*/
reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
>reduceRight : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
> : ^^^ ^^ ^^ ^^^ ^^^ ^^^^^^ ^^^ ^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^ ^^ ^^^^^^^
>callbackfn : (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>previousValue : T
@@ -2385,7 +2385,7 @@ interface Array<T> {
*/
reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
>reduceRight : { (callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T; <U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^ ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^ ^^ ^^ ^^ ^^ ^^^ ^^^
>callbackfn : (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^
>previousValue : U
tests/baselines/reference/2dArrays.types
+2 -2
View File
@@ -35,7 +35,7 @@ class Board {
>this.ships.every(function (val) { return val.isSunk; }) : boolean
> : ^^^^^^^
>this.ships.every : { <S extends Ship>(predicate: (value: Ship, index: number, array: Ship[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: Ship, index: number, array: Ship[]) => unknown, thisArg?: any): boolean; }
> : ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^
>this.ships : Ship[]
> : ^^^^^^
>this : this
@@ -43,7 +43,7 @@ class Board {
>ships : Ship[]
> : ^^^^^^
>every : { <S extends Ship>(predicate: (value: Ship, index: number, array: Ship[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: Ship, index: number, array: Ship[]) => unknown, thisArg?: any): boolean; }
> : ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^
>function (val) { return val.isSunk; } : (val: Ship) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^
>val : Ship
tests/baselines/reference/ClassAndModuleThatMergeWithModulesExportedStaticFunctionUsingClassPrivateStatics.types
+2 -2
View File
@@ -39,11 +39,11 @@ module clodule {
>clodule.sfn('a') : number
> : ^^^^^^
>clodule.sfn : (id: string) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>clodule : typeof clodule
> : ^^^^^^^^^^^^^^
>sfn : (id: string) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>'a' : "a"
> : ^^^
}
tests/baselines/reference/ES5For-of1.types
+2 -2
View File
@@ -17,11 +17,11 @@ for (var v of ['a', 'b', 'c']) {
>console.log(v) : void
> : ^^^^
>console.log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>console : Console
> : ^^^^^^^
>log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>v : string
> : ^^^^^^
}
tests/baselines/reference/ES5For-of22.types
+2 -2
View File
@@ -23,11 +23,11 @@ for (var x of [1, 2, 3]) {
>console.log(x) : void
> : ^^^^
>console.log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>console : Console
> : ^^^^^^^
>log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>x : number
> : ^^^^^^
}
tests/baselines/reference/ES5For-of23.types
+2 -2
View File
@@ -23,11 +23,11 @@ for (var x of [1, 2, 3]) {
>console.log(x) : void
> : ^^^^
>console.log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>console : Console
> : ^^^^^^^
>log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>x : number
> : ^^^^^^
}
tests/baselines/reference/ES5For-of33.types
+2 -2
View File
@@ -17,11 +17,11 @@ for (var v of ['a', 'b', 'c']) {
>console.log(v) : void
> : ^^^^
>console.log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>console : Console
> : ^^^^^^^
>log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>v : string
> : ^^^^^^
}
tests/baselines/reference/ES5For-of37.types
+4 -4
View File
@@ -54,11 +54,11 @@ for (const i of [0, 1, 2, 3, 4]) {
>console.log(i) : void
> : ^^^^
>console.log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>console : Console
> : ^^^^^^^
>log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>i : number
> : ^^^^^^
@@ -69,11 +69,11 @@ for (const i of [0, 1, 2, 3, 4]) {
>console.log('E %s %s', i, err) : void
> : ^^^^
>console.log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>console : Console
> : ^^^^^^^
>log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>'E %s %s' : "E %s %s"
> : ^^^^^^^^^
>i : number
tests/baselines/reference/ModuleWithExportedAndNonExportedFunctions.types
+6 -6
View File
@@ -55,13 +55,13 @@ var fn: (s: string) => boolean;
var fn = A.fn;
>fn : (s: string) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^
>A.fn : (s: string) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^
>A : typeof A
> : ^^^^^^^^
>fn : (s: string) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^
var fng: <T, U>(s: T) => U;
>fng : <T, U>(s: T) => U
@@ -71,13 +71,13 @@ var fng: <T, U>(s: T) => U;
var fng = A.fng; // bug 838015
>fng : <T, U>(s: T) => U
> : ^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^ ^^ ^^^^^^
>A.fng : <T, U>(s: T) => U
> : ^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^ ^^ ^^^^^^
>A : typeof A
> : ^^^^^^^^
>fng : <T, U>(s: T) => U
> : ^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^ ^^ ^^^^^^
// these should be errors since the functions are not exported
var fn2 = A.fn2;
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedInterfacesOfTheSameName.types
+1 -1
View File
@@ -91,7 +91,7 @@ var l: { new (s: A.Point, e: A.Point); }
var l: X.Y.Z.Line;
>l : new (s: A.Point, e: A.Point) => any
> : ^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^^^ ^^ ^^ ^^ ^^^^^^^^
>X : any
> : ^^^
>Y : any
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedAndNonExportedLocalVarsOfTheSameName.types
+2 -2
View File
@@ -123,7 +123,7 @@ var o = A.Utils.mirror(o);
>A.Utils.mirror(o) : { x: number; y: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>A.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
> : ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>A.Utils : typeof A.Utils
> : ^^^^^^^^^^^^^^
>A : typeof A
@@ -131,7 +131,7 @@ var o = A.Utils.mirror(o);
>Utils : typeof A.Utils
> : ^^^^^^^^^^^^^^
>mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
> : ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : { x: number; y: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/TwoInternalModulesThatMergeEachWithExportedInterfacesOfTheSameName.types
+1 -1
View File
@@ -103,7 +103,7 @@ var l: { start: A.Point; end: A.Point; new (s: A.Point, e: A.Point); }
var l: X.Y.Z.Line;
>l : { new (s: A.Point, e: A.Point): any; start: A.Point; end: A.Point; }
> : ^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>X : any
> : ^^^
>Y : any
tests/baselines/reference/TwoInternalModulesWithTheSameNameAndSameCommonRoot.types
+2 -2
View File
@@ -117,7 +117,7 @@ var o = A.Utils.mirror(o);
>A.Utils.mirror(o) : { x: number; y: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>A.Utils.mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
> : ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>A.Utils : typeof A.Utils
> : ^^^^^^^^^^^^^^
>A : typeof A
@@ -125,7 +125,7 @@ var o = A.Utils.mirror(o);
>Utils : typeof A.Utils
> : ^^^^^^^^^^^^^^
>mirror : <T extends A.Point>(p: T) => { x: number; y: number; }
> : ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>o : { x: number; y: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/abstractClassUnionInstantiation.types
+8 -8
View File
@@ -75,7 +75,7 @@ new cls3(); // should work
>[ConcreteA, AbstractA, AbstractB].map(cls => new cls()) : any[]
> : ^^^^^
>[ConcreteA, AbstractA, AbstractB].map : <U>(callbackfn: (value: typeof ConcreteA | typeof AbstractA | typeof AbstractB, index: number, array: (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[ConcreteA, AbstractA, AbstractB] : (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>ConcreteA : typeof ConcreteA
@@ -85,7 +85,7 @@ new cls3(); // should work
>AbstractB : typeof AbstractB
> : ^^^^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: typeof ConcreteA | typeof AbstractA | typeof AbstractB, index: number, array: (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>cls => new cls() : (cls: typeof ConcreteA | typeof AbstractA | typeof AbstractB) => any
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>cls : typeof ConcreteA | typeof AbstractA | typeof AbstractB
@@ -99,7 +99,7 @@ new cls3(); // should work
>[AbstractA, AbstractB, ConcreteA].map(cls => new cls()) : any[]
> : ^^^^^
>[AbstractA, AbstractB, ConcreteA].map : <U>(callbackfn: (value: typeof ConcreteA | typeof AbstractA | typeof AbstractB, index: number, array: (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[AbstractA, AbstractB, ConcreteA] : (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>AbstractA : typeof AbstractA
@@ -109,7 +109,7 @@ new cls3(); // should work
>ConcreteA : typeof ConcreteA
> : ^^^^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: typeof ConcreteA | typeof AbstractA | typeof AbstractB, index: number, array: (typeof ConcreteA | typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>cls => new cls() : (cls: typeof ConcreteA | typeof AbstractA | typeof AbstractB) => any
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>cls : typeof ConcreteA | typeof AbstractA | typeof AbstractB
@@ -123,7 +123,7 @@ new cls3(); // should work
>[ConcreteA, ConcreteB].map(cls => new cls()) : ConcreteA[]
> : ^^^^^^^^^^^
>[ConcreteA, ConcreteB].map : <U>(callbackfn: (value: typeof ConcreteA, index: number, array: (typeof ConcreteA)[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[ConcreteA, ConcreteB] : (typeof ConcreteA)[]
> : ^^^^^^^^^^^^^^^^^^^^
>ConcreteA : typeof ConcreteA
@@ -131,7 +131,7 @@ new cls3(); // should work
>ConcreteB : typeof ConcreteB
> : ^^^^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: typeof ConcreteA, index: number, array: (typeof ConcreteA)[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>cls => new cls() : (cls: typeof ConcreteA) => ConcreteA
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>cls : typeof ConcreteA
@@ -145,7 +145,7 @@ new cls3(); // should work
>[AbstractA, AbstractB].map(cls => new cls()) : any[]
> : ^^^^^
>[AbstractA, AbstractB].map : <U>(callbackfn: (value: typeof AbstractA | typeof AbstractB, index: number, array: (typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[AbstractA, AbstractB] : (typeof AbstractA | typeof AbstractB)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>AbstractA : typeof AbstractA
@@ -153,7 +153,7 @@ new cls3(); // should work
>AbstractB : typeof AbstractB
> : ^^^^^^^^^^^^^^^^
>map : <U>(callbackfn: (value: typeof AbstractA | typeof AbstractB, index: number, array: (typeof AbstractA | typeof AbstractB)[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>cls => new cls() : (cls: typeof AbstractA | typeof AbstractB) => any
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>cls : typeof AbstractA | typeof AbstractB
tests/baselines/reference/abstractProperty(target=es2015).types
+2 -2
View File
@@ -17,11 +17,11 @@ abstract class A {
>console.log(this.x) : void
> : ^^^^
>console.log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>console : Console
> : ^^^^^^^
>log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>this.x : string
> : ^^^^^^
>this : this
tests/baselines/reference/abstractProperty(target=esnext).types
+2 -2
View File
@@ -17,11 +17,11 @@ abstract class A {
>console.log(this.x) : void
> : ^^^^
>console.log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>console : Console
> : ^^^^^^^
>log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>this.x : string
> : ^^^^^^
>this : this
tests/baselines/reference/abstractPropertyInConstructor.types
+23 -23
View File
@@ -15,15 +15,15 @@ abstract class AbstractClass {
>this.method(parseInt(str)) : void
> : ^^^^
>this.method : (num: number) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>this : this
> : ^^^^
>method : (num: number) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>parseInt(str) : number
> : ^^^^^^
>parseInt : (string: string, radix?: number) => number
> : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^ ^^^^^^^^^^^
>str : string
> : ^^^^^^
@@ -65,11 +65,11 @@ abstract class AbstractClass {
>this.cb(str) : void
> : ^^^^
>this.cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>this : this
> : ^^^^
>cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>str : string
> : ^^^^^^
@@ -94,11 +94,11 @@ abstract class AbstractClass {
>other.cb(other.prop) : void
> : ^^^^
>other.cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>other : AbstractClass
> : ^^^^^^^^^^^^^
>cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>other.prop : string
> : ^^^^^^
>other : AbstractClass
@@ -208,11 +208,11 @@ abstract class DerivedAbstractClass extends AbstractClass {
>this.cb(this.prop.toLowerCase()) : void
> : ^^^^
>this.cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>this : this
> : ^^^^
>cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>this.prop.toLowerCase() : string
> : ^^^^^^
>this.prop.toLowerCase : () => string
@@ -230,11 +230,11 @@ abstract class DerivedAbstractClass extends AbstractClass {
>this.method(1) : void
> : ^^^^
>this.method : (num: number) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>this : this
> : ^^^^
>method : (num: number) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>1 : 1
> : ^
@@ -243,11 +243,11 @@ abstract class DerivedAbstractClass extends AbstractClass {
>other.cb(other.prop) : void
> : ^^^^
>other.cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>other : AbstractClass
> : ^^^^^^^^^^^^^
>cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>other.prop : string
> : ^^^^^^
>other : AbstractClass
@@ -259,11 +259,11 @@ abstract class DerivedAbstractClass extends AbstractClass {
>yetAnother.cb(yetAnother.prop) : void
> : ^^^^
>yetAnother.cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>yetAnother : DerivedAbstractClass
> : ^^^^^^^^^^^^^^^^^^^^
>cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>yetAnother.prop : string
> : ^^^^^^
>yetAnother : DerivedAbstractClass
@@ -317,11 +317,11 @@ class Implementation extends DerivedAbstractClass {
>this.cb(this.prop) : void
> : ^^^^
>this.cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>this : this
> : ^^^^
>cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>this.prop : string
> : ^^^^^^
>this : this
@@ -340,11 +340,11 @@ class Implementation extends DerivedAbstractClass {
>this.cb(this.prop + n) : void
> : ^^^^
>this.cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>this : this
> : ^^^^
>cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>this.prop + n : string
> : ^^^^^^
>this.prop : string
@@ -378,11 +378,11 @@ class User {
>a.cb("hi") : void
> : ^^^^
>a.cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>a : AbstractClass
> : ^^^^^^^^^^^^^
>cb : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>"hi" : "hi"
> : ^^^^
@@ -390,11 +390,11 @@ class User {
>a.method(12) : void
> : ^^^^
>a.method : (num: number) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>a : AbstractClass
> : ^^^^^^^^^^^^^
>method : (num: number) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>12 : 12
> : ^^
tests/baselines/reference/acceptSymbolAsWeakType.types
+6 -6
View File
@@ -158,12 +158,12 @@ const f = new FinalizationRegistry(() => {});
f.register(s, null);
>f.register(s, null) : void
> : ^^^^
>f.register : (target: WeakKey, heldValue: unknown, unregisterToken?: WeakKey | undefined) => void
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>f.register : (target: WeakKey, heldValue: unknown, unregisterToken?: WeakKey) => void
> : ^ ^^ ^^ ^^^^^^^^^^^ ^^^ ^^^^^^^^^
>f : FinalizationRegistry<unknown>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>register : (target: WeakKey, heldValue: unknown, unregisterToken?: WeakKey | undefined) => void
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>register : (target: WeakKey, heldValue: unknown, unregisterToken?: WeakKey) => void
> : ^ ^^ ^^ ^^^^^^^^^^^ ^^^ ^^^^^^^^^
>s : symbol
> : ^^^^^^
@@ -171,11 +171,11 @@ f.unregister(s);
>f.unregister(s) : void
> : ^^^^
>f.unregister : (unregisterToken: WeakKey) => void
> : ^ ^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>f : FinalizationRegistry<unknown>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>unregister : (unregisterToken: WeakKey) => void
> : ^ ^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>s : symbol
> : ^^^^^^
tests/baselines/reference/accessorsAreNotContextuallyTyped.types
+3 -3
View File
@@ -18,7 +18,7 @@ class C {
get x() {
>x : (a: string) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
return (x: string) => "";
>(x: string) => "" : (x: string) => string
@@ -40,11 +40,11 @@ var r = c.x(''); // string
>c.x('') : string
> : ^^^^^^
>c.x : (a: string) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>c : C
> : ^
>x : (a: string) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>'' : ""
> : ^^
tests/baselines/reference/accessorsOverrideProperty2.types
+4 -4
View File
@@ -32,11 +32,11 @@ class Derived extends Base {
>console.log(`x was set to ${value}`) : void
> : ^^^^
>console.log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>console : Console
> : ^^^^^^^
>log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>`x was set to ${value}` : string
> : ^^^^^^
>value : number
@@ -55,11 +55,11 @@ console.log(obj.x); // number
>console.log(obj.x) : void
> : ^^^^
>console.log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>console : Console
> : ^^^^^^^
>log : (...data: any[]) => void
> : ^^^^ ^^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^
>obj.x : number
> : ^^^^^^
>obj : Derived
tests/baselines/reference/accessorsOverrideProperty8.types
+1 -1
View File
@@ -43,7 +43,7 @@ const Base = classWithProperties({
>classWithProperties({ get x() { return 'boolean' as const }, y: 'string',}, class Base {}) : { new (): Base & Properties<{ readonly x: "boolean"; y: "string"; }>; prototype: Base & Properties<{ readonly x: "boolean"; y: "string"; }>; }
> :
>classWithProperties : <T extends { [key: string]: Types; }, P extends object>(properties: T, klass: AnyCtor<P>) => { new (): P & Properties<T>; prototype: P & Properties<T>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>{ get x() { return 'boolean' as const }, y: 'string',} : { readonly x: "boolean"; y: "string"; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/accessorsOverrideProperty9.types
+2 -2
View File
@@ -92,7 +92,7 @@ function ApiItemContainerMixin<TBaseClass extends IApiItemConstructor>(
return MixedClass;
>MixedClass : ((abstract new (...args: any[]) => MixedClass) & { prototype: ApiItemContainerMixin<any>.MixedClass; }) & TBaseClass
> : ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
}
// Subclass inheriting from mixin
@@ -102,7 +102,7 @@ export class ApiEnum extends ApiItemContainerMixin(ApiItem) {
>ApiItemContainerMixin(ApiItem) : ApiItem & ApiItemContainerMixin
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>ApiItemContainerMixin : <TBaseClass extends IApiItemConstructor>(baseClass: TBaseClass) => TBaseClass & (new (...args: any[]) => ApiItemContainerMixin)
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>ApiItem : typeof ApiItem
> : ^^^^^^^^^^^^^^
tests/baselines/reference/aliasOnMergedModuleInterface.types
+2 -2
View File
@@ -14,11 +14,11 @@ z.bar("hello"); // This should be ok
>z.bar("hello") : foo.A
> : ^^^^^
>z.bar : (name: string) => foo.A
> : ^ ^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^
>z : foo
> : ^^^
>bar : (name: string) => foo.A
> : ^ ^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^
>"hello" : "hello"
> : ^^^^^^^
tests/baselines/reference/aliasUsageInFunctionExpression.types
+1 -1
View File
@@ -34,7 +34,7 @@ f = (x) => moduleA;
>f = (x) => moduleA : (x: IHasVisualizationModel) => typeof moduleA
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>f : (x: IHasVisualizationModel) => IHasVisualizationModel
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>(x) => moduleA : (x: IHasVisualizationModel) => typeof moduleA
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : IHasVisualizationModel
tests/baselines/reference/aliasUsageInGenericFunction.types
+2 -2
View File
@@ -38,7 +38,7 @@ var r = foo({ a: moduleA });
>foo({ a: moduleA }) : { a: typeof moduleA; }
> :
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>{ a: moduleA } : { a: typeof moduleA; }
> : ^^^^^^^^^^^^^^^^^^^^^^
>a : typeof moduleA
@@ -52,7 +52,7 @@ var r2 = foo({ a: <IHasVisualizationModel>null });
>foo({ a: <IHasVisualizationModel>null }) : { a: IHasVisualizationModel; }
> :
>foo : <T extends { a: IHasVisualizationModel; }>(x: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>{ a: <IHasVisualizationModel>null } : { a: IHasVisualizationModel; }
> : ^^^^^ ^^^
>a : IHasVisualizationModel
tests/baselines/reference/aliasUsedAsNameValue.types
+2 -2
View File
@@ -21,11 +21,11 @@ export var a = function () {
b.b(mod);
>b.b(mod) : any
>b.b : (a: any) => any
> : ^ ^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^
>b : typeof b
> : ^^^^^^^^
>b : (a: any) => any
> : ^ ^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^
>mod : typeof mod
> : ^^^^^^^^^^
}
tests/baselines/reference/allowJscheckJsTypeParameterNoCrash.types
+1 -1
View File
@@ -20,7 +20,7 @@ declare function extend(options: ComponentOptions<{}>): void;
export var vextend = extend;
>vextend : (options: ComponentOptions<{}>) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>extend : (options: ComponentOptions<{}>) => void
> :
tests/baselines/reference/ambientClassMergesOverloadsWithInterface.types
+2 -2
View File
@@ -11,14 +11,14 @@ declare class C {
foo(n: number): any;
>foo : { (n: number): any; (n: number): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>n : number
> : ^^^^^^
}
interface C {
foo(n: number): any;
>foo : { (n: number): any; (n: number): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^^ ^^^
>n : number
> : ^^^^^^
tests/baselines/reference/ambientConstLiterals.types
+2 -2
View File
@@ -54,7 +54,7 @@ const c5 = f(123);
>f(123) : 123
> : ^^^
>f : <T>(x: T) => T
> : ^^^^ ^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^
>123 : 123
> : ^^^
@@ -64,7 +64,7 @@ const c6 = f(-123);
>f(-123) : -123
> : ^^^^
>f : <T>(x: T) => T
> : ^^^^ ^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^
>-123 : -123
> : ^^^^
>123 : 123
tests/baselines/reference/ambientDeclarationsPatterns.types
+4 -4
View File
@@ -4,7 +4,7 @@
///<reference path="declarations.d.ts" />
import {foo, baz} from "foobarbaz";
>foo : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>baz : string
> : ^^^^^^
@@ -12,7 +12,7 @@ foo(baz);
>foo(baz) : void
> : ^^^^
>foo : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>baz : string
> : ^^^^^^
@@ -24,7 +24,7 @@ foo(foos);
>foo(foos) : void
> : ^^^^
>foo : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>foos : string
> : ^^^^^^
@@ -37,7 +37,7 @@ foo(fileText);
>foo(fileText) : void
> : ^^^^
>foo : (s: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>fileText : string
> : ^^^^^^
tests/baselines/reference/ambientErrors.types
+7 -7
View File
@@ -11,39 +11,39 @@ declare var x = 4;
// Ambient functions with invalid overloads
declare function fn(x: number): string;
>fn : { (x: number): string; (x: "foo"): number; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^^^^
>x : number
> : ^^^^^^
declare function fn(x: 'foo'): number;
>fn : { (x: number): string; (x: 'foo'): number; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
>fn : { (x: number): string; (x: "foo"): number; }
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : "foo"
> : ^^^^^
// Ambient functions with duplicate signatures
declare function fn1(x: number): string;
>fn1 : { (x: number): string; (x: number): string; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^^^^
>x : number
> : ^^^^^^
declare function fn1(x: number): string;
>fn1 : { (x: number): string; (x: number): string; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : number
> : ^^^^^^
// Ambient function overloads that differ only by return type
declare function fn2(x: number): string;
>fn2 : { (x: number): string; (x: number): number; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^^^^
>x : number
> : ^^^^^^
declare function fn2(x: number): number;
>fn2 : { (x: number): string; (x: number): number; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : number
> : ^^^^^^
tests/baselines/reference/ambientRequireFunction(module=commonjs).types
+3 -3
View File
@@ -9,7 +9,7 @@ const fs = require("fs");
>require("fs") : typeof fs
> : ^^^^^^^^^
>require : (moduleName: string) => any
> : ^ ^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^
>"fs" : "fs"
> : ^^^^
@@ -19,11 +19,11 @@ const text = fs.readFileSync("/a/b/c");
>fs.readFileSync("/a/b/c") : string
> : ^^^^^^
>fs.readFileSync : (s: string) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>fs : typeof fs
> : ^^^^^^^^^
>readFileSync : (s: string) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>"/a/b/c" : "/a/b/c"
> : ^^^^^^^^
tests/baselines/reference/ambientRequireFunction(module=preserve).types
+3 -3
View File
@@ -9,7 +9,7 @@ const fs = require("fs");
>require("fs") : typeof fs
> : ^^^^^^^^^
>require : (moduleName: string) => any
> : ^ ^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^
>"fs" : "fs"
> : ^^^^
@@ -19,11 +19,11 @@ const text = fs.readFileSync("/a/b/c");
>fs.readFileSync("/a/b/c") : string
> : ^^^^^^
>fs.readFileSync : (s: string) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>fs : typeof fs
> : ^^^^^^^^^
>readFileSync : (s: string) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>"/a/b/c" : "/a/b/c"
> : ^^^^^^^^
tests/baselines/reference/ambiguousCallsWhereReturnTypesAgree.types
+16 -16
View File
@@ -7,49 +7,49 @@ class TestClass {
public bar(x: string): void;
>bar : { (x: string): void; (x: string[]): void; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^^
>x : string
> : ^^^^^^
public bar(x: string[]): void;
>bar : { (x: string): void; (x: string[]): void; }
> : ^^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^ ^^ ^^^ ^^^
>x : string[]
> : ^^^^^^^^
public bar(x: any): void {
>bar : { (x: string): void; (x: string[]): void; }
> : ^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^ ^^ ^^^^^^^^^^
>x : any
}
public foo(x: string): void;
>foo : { (x: string): void; (x: string[]): void; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^^
>x : string
> : ^^^^^^
public foo(x: string[]): void;
>foo : { (x: string): void; (x: string[]): void; }
> : ^^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^ ^^ ^^^ ^^^
>x : string[]
> : ^^^^^^^^
public foo(x: any): void {
>foo : { (x: string): void; (x: string[]): void; }
> : ^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^ ^^ ^^^^^^^^^^
>x : any
this.bar(x); // should not error
>this.bar(x) : void
> : ^^^^
>this.bar : { (x: string): void; (x: string[]): void; }
> : ^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^ ^^ ^^^^^^^^^^
>this : this
> : ^^^^
>bar : { (x: string): void; (x: string[]): void; }
> : ^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^ ^^ ^^^^^^^^^^
>x : any
}
}
@@ -60,19 +60,19 @@ class TestClass2 {
public bar(x: string): number;
>bar : { (x: string): number; (x: string[]): number; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^^^^
>x : string
> : ^^^^^^
public bar(x: string[]): number;
>bar : { (x: string): number; (x: string[]): number; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : string[]
> : ^^^^^^^^
public bar(x: any): number {
>bar : { (x: string): number; (x: string[]): number; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^
>x : any
return 0;
@@ -82,30 +82,30 @@ class TestClass2 {
public foo(x: string): number;
>foo : { (x: string): number; (x: string[]): number; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^^^^
>x : string
> : ^^^^^^
public foo(x: string[]): number;
>foo : { (x: string): number; (x: string[]): number; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : string[]
> : ^^^^^^^^
public foo(x: any): number {
>foo : { (x: string): number; (x: string[]): number; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^
>x : any
return this.bar(x); // should not error
>this.bar(x) : number
> : ^^^^^^
>this.bar : { (x: string): number; (x: string[]): number; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>bar : { (x: string): number; (x: string[]): number; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^
>x : any
}
}
tests/baselines/reference/ambiguousGenericAssertion1.types
+2 -2
View File
@@ -25,7 +25,7 @@ var r2 = < <T>(x: T) => T>f; // valid
>x : T
> : ^
>f : <T>(x: T) => T
> : ^^^^ ^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^
var r3 = <<T>(x: T) => T>f; // ambiguous, appears to the parser as a << operation
>r3 : boolean
@@ -49,5 +49,5 @@ var r3 = <<T>(x: T) => T>f; // ambiguous, appears to the parser as a << operatio
>T : any
> : ^^^
>f : <T>(x: T) => T
> : ^^^^ ^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^
tests/baselines/reference/ambiguousOverload.types
+10 -10
View File
@@ -3,7 +3,7 @@
=== ambiguousOverload.ts ===
function foof(bar: string, y): number;
>foof : { (bar: string, y: any): number; (bar: string, x: any): string; }
> : ^^^ ^^ ^^ ^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^ ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^
>bar : string
> : ^^^^^^
>y : any
@@ -11,7 +11,7 @@ function foof(bar: string, y): number;
function foof(bar: string, x): string;
>foof : { (bar: string, y: any): number; (bar: string, x: any): string; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^ ^^^
>bar : string
> : ^^^^^^
>x : any
@@ -19,7 +19,7 @@ function foof(bar: string, x): string;
function foof(bar: any): any { return bar };
>foof : { (bar: string, y: any): number; (bar: string, x: any): string; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^
>bar : any
> : ^^^
>bar : any
@@ -31,7 +31,7 @@ var x: number = foof("s", null);
>foof("s", null) : number
> : ^^^^^^
>foof : { (bar: string, y: any): number; (bar: string, x: any): string; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^
>"s" : "s"
> : ^^^
@@ -41,13 +41,13 @@ var y: string = foof("s", null);
>foof("s", null) : number
> : ^^^^^^
>foof : { (bar: string, y: any): number; (bar: string, x: any): string; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^
>"s" : "s"
> : ^^^
function foof2(bar: string, x): string;
>foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; }
> : ^^^ ^^ ^^ ^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^ ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^
>bar : string
> : ^^^^^^
>x : any
@@ -55,7 +55,7 @@ function foof2(bar: string, x): string;
function foof2(bar: string, y): number;
>foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^ ^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^ ^^^
>bar : string
> : ^^^^^^
>y : any
@@ -63,7 +63,7 @@ function foof2(bar: string, y): number;
function foof2(bar: any): any { return bar };
>foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^
>bar : any
> : ^^^
>bar : any
@@ -75,7 +75,7 @@ var x2: string = foof2("s", null);
>foof2("s", null) : string
> : ^^^^^^
>foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^
>"s" : "s"
> : ^^^
@@ -85,7 +85,7 @@ var y2: number = foof2("s", null);
>foof2("s", null) : string
> : ^^^^^^
>foof2 : { (bar: string, x: any): string; (bar: string, y: any): number; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^
>"s" : "s"
> : ^^^
tests/baselines/reference/ambiguousOverloadResolution.types
+3 -3
View File
@@ -15,7 +15,7 @@ class B extends A { x: number; }
declare function f(p: A, q: B): number;
>f : { (p: A, q: B): number; (p: B, q: A): string; }
> : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^ ^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>p : A
> : ^
>q : B
@@ -23,7 +23,7 @@ declare function f(p: A, q: B): number;
declare function f(p: B, q: A): string;
>f : { (p: A, q: B): number; (p: B, q: A): string; }
> : ^^^ ^^^^^ ^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>p : B
> : ^
>q : A
@@ -39,7 +39,7 @@ var t: number = f(x, x); // Not an error
>f(x, x) : number
> : ^^^^^^
>f : { (p: A, q: B): number; (p: B, q: A): string; }
> : ^^^ ^^^^^ ^^^^^^^^^^^^^^^ ^^^^^ ^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>x : B
> : ^
>x : B
tests/baselines/reference/amdDeclarationEmitNoExtraDeclare.types
+2 -2
View File
@@ -3,7 +3,7 @@
=== Class.ts ===
import { Configurable } from "./Configurable"
>Configurable : <T extends import("Configurable").Constructor<{}>>(base: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
export class HiddenClass {}
>HiddenClass : HiddenClass
@@ -15,7 +15,7 @@ export class ActualClass extends Configurable(HiddenClass) {}
>Configurable(HiddenClass) : HiddenClass
> : ^^^^^^^^^^^
>Configurable : <T extends import("Configurable").Constructor<{}>>(base: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>HiddenClass : typeof HiddenClass
> : ^^^^^^^^^^^^^^^^^^
tests/baselines/reference/amdLikeInputDeclarationEmit.types
+3 -3
View File
@@ -36,7 +36,7 @@ declare module "deps/BaseClass" {
define("lib/ExtendedClass", ["deps/BaseClass"],
>define("lib/ExtendedClass", ["deps/BaseClass"], /** * {typeof import("deps/BaseClass")} * @param {typeof import("deps/BaseClass")} BaseClass * @returns */(BaseClass) => { const ExtendedClass = BaseClass.extends({ f: function() { return "something"; } }); // Exports the module in a way tsc recognize class export const module = {}; module.exports = ExtendedClass return module.exports;}) : any
>define : <T = unknown>(name: string, modules: string[], ready: (...modules: unknown[]) => T) => any
> : ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^
>"lib/ExtendedClass" : "lib/ExtendedClass"
> : ^^^^^^^^^^^^^^^^^^^
>["deps/BaseClass"] : string[]
@@ -61,11 +61,11 @@ define("lib/ExtendedClass", ["deps/BaseClass"],
>BaseClass.extends({ f: function() { return "something"; } }) : new () => { f: () => "something"; } & import("deps/BaseClass")
> :
>BaseClass.extends : <A>(a: A) => new () => A & import("deps/BaseClass")
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>BaseClass : typeof import("deps/BaseClass")
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>extends : <A>(a: A) => new () => A & import("deps/BaseClass")
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>{ f: function() { return "something"; } } : { f: () => "something"; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/annotatedThisPropertyInitializerDoesntNarrow.types
+1 -1
View File
@@ -35,7 +35,7 @@ export class C {
>mappy(this.assets) : void
> : ^^^^
>mappy : (map: { [s: string]: number; }) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>this.assets : { [assetName: string]: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>this : this
tests/baselines/reference/anonClassDeclarationEmitIsAnon.types
+7 -7
View File
@@ -30,13 +30,13 @@ export type Constructor<T = {}> = new (...args: any[]) => T;
export function Timestamped<TBase extends Constructor>(Base: TBase) {
>Timestamped : <TBase extends Constructor<{}>>(Base: TBase) => { new (...args: any[]): (Anonymous class); prototype: Timestamped<any>.(Anonymous class); } & TBase
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Base : TBase
> : ^^^^^
return class extends Base {
>class extends Base { timestamp = Date.now(); } : { new (...args: any[]): (Anonymous class); prototype: Timestamped<any>.(Anonymous class); } & TBase
> : ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Base : {}
> : ^^
@@ -58,15 +58,15 @@ export function Timestamped<TBase extends Constructor>(Base: TBase) {
=== index.ts ===
import { wrapClass, Timestamped } from "./wrapClass";
>wrapClass : (param: any) => typeof Wrapped
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^
>Timestamped : <TBase extends import("wrapClass").Constructor<{}>>(Base: TBase) => { new (...args: any[]): (Anonymous class); prototype: Timestamped<any>.(Anonymous class); } & TBase
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
export default wrapClass(0);
>wrapClass(0) : typeof Wrapped
> : ^^^^^^^^^^^^^^
>wrapClass : (param: any) => typeof Wrapped
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^
>0 : 0
> : ^
@@ -89,7 +89,7 @@ export class TimestampedUser extends Timestamped(User) {
>Timestamped(User) : Timestamped<typeof User>.(Anonymous class) & User
> : ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>Timestamped : <TBase extends import("wrapClass").Constructor<{}>>(Base: TBase) => { new (...args: any[]): (Anonymous class); prototype: Timestamped<any>.(Anonymous class); } & TBase
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>User : typeof User
> : ^^^^^^^^^^^
@@ -98,6 +98,6 @@ export class TimestampedUser extends Timestamped(User) {
>super() : void
> : ^^^^
>super : { new (...args: any[]): Timestamped<typeof User>.(Anonymous class); prototype: Timestamped<any>.(Anonymous class); } & typeof User
> : ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^ ^^ ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
}
}
tests/baselines/reference/anonterface.types
+5 -5
View File
@@ -23,7 +23,7 @@ module M {
>fn(n2) : string
> : ^^^^^^
>fn : (n: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>n2 : number
> : ^^^^^^
}
@@ -45,12 +45,12 @@ var c=new M.C();
c.m(function(n) { return "hello: "+n; },18);
>c.m(function(n) { return "hello: "+n; },18) : string
> : ^^^^^^
>c.m : (fn: (n: number) => string, n2: number) => string
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
>c.m : (fn: { (n: number): string; }, n2: number) => string
> : ^ ^^ ^^ ^^ ^^^^^^^^^^^
>c : M.C
> : ^^^
>m : (fn: (n: number) => string, n2: number) => string
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
>m : (fn: { (n: number): string; }, n2: number) => string
> : ^ ^^ ^^ ^^ ^^^^^^^^^^^
>function(n) { return "hello: "+n; } : (n: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
>n : number
tests/baselines/reference/anyAssignabilityInInheritance.types
+52 -52
View File
@@ -17,97 +17,97 @@ var a: any;
declare function foo2(x: number): number;
>foo2 : { (x: number): number; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : number
> : ^^^^^^
declare function foo2(x: any): any;
>foo2 : { (x: number): number; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo2(a); // any, not a subtype of number so it skips that overload, is a subtype of itself so it picks second (if truly ambiguous it would pick first overload)
>r3 : any
>foo2(a) : any
>foo2 : { (x: number): number; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
declare function foo3(x: string): string;
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : string
> : ^^^^^^
declare function foo3(x: any): any;
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
declare function foo4(x: boolean): boolean;
>foo4 : { (x: boolean): boolean; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : boolean
> : ^^^^^^^
declare function foo4(x: any): any;
>foo4 : { (x: boolean): boolean; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
declare function foo5(x: Date): Date;
>foo5 : { (x: Date): Date; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : Date
> : ^^^^
declare function foo5(x: any): any;
>foo5 : { (x: Date): Date; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
declare function foo6(x: RegExp): RegExp;
>foo6 : { (x: RegExp): RegExp; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : RegExp
> : ^^^^^^
declare function foo6(x: any): any;
>foo6 : { (x: RegExp): RegExp; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
declare function foo7(x: { bar: number }): { bar: number };
>foo7 : { (x: { bar: number; }): { bar: number; }; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : { bar: number; }
> : ^^^^^^^ ^^^
>bar : number
@@ -117,32 +117,32 @@ declare function foo7(x: { bar: number }): { bar: number };
declare function foo7(x: any): any;
>foo7 : { (x: { bar: number; }): { bar: number; }; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
declare function foo8(x: number[]): number[];
>foo8 : { (x: number[]): number[]; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : number[]
> : ^^^^^^^^
declare function foo8(x: any): any;
>foo8 : { (x: number[]): number[]; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
interface I8 { foo: string }
@@ -151,20 +151,20 @@ interface I8 { foo: string }
declare function foo9(x: I8): I8;
>foo9 : { (x: I8): I8; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : I8
> : ^^
declare function foo9(x: any): any;
>foo9 : { (x: I8): I8; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
class A { foo: number; }
@@ -175,20 +175,20 @@ class A { foo: number; }
declare function foo10(x: A): A;
>foo10 : { (x: A): A; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : A
> : ^
declare function foo10(x: any): any;
>foo10 : { (x: A): A; (x: any): any; }
> : ^^^ ^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
class A2<T> { foo: T; }
@@ -199,25 +199,25 @@ class A2<T> { foo: T; }
declare function foo11(x: A2<string>): A2<string>;
>foo11 : { (x: A2<string>): A2<string>; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : A2<string>
> : ^^^^^^^^^^
declare function foo11(x: any): any;
>foo11 : { (x: A2<string>): A2<string>; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
declare function foo12(x: (x) => number): (x) => number;
>foo12 : { (x: (x: any) => number): (x: any) => number; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : (x: any) => number
> : ^ ^^^^^^^^^^
>x : any
@@ -225,19 +225,19 @@ declare function foo12(x: (x) => number): (x) => number;
declare function foo12(x: any): any;
>foo12 : { (x: (x: any) => number): (x: any) => number; (x: any): any; }
> : ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^ ^^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
declare function foo13(x: <T>(x: T) => T): <T>(x: T) => T;
>foo13 : { (x: <T>(x: T) => T): <T>(x: T) => T; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : <T>(x: T) => T
> : ^ ^^ ^^ ^^^^^
>x : T
@@ -246,15 +246,15 @@ declare function foo13(x: <T>(x: T) => T): <T>(x: T) => T;
> : ^
declare function foo13(x: any): any;
>foo13 : { (x: <T>(x: T) => T): <T_1>(x: T_1) => T_1; (x: any): any; }
> : ^^^ ^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
>foo13 : { (x: <T>(x: T) => T): <T>(x: T) => T; (x: any): any; }
> : ^^^ ^^ ^^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
enum E { A }
@@ -265,20 +265,20 @@ enum E { A }
declare function foo14(x: E): E;
>foo14 : { (x: E): E; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : E
> : ^
declare function foo14(x: any): any;
>foo14 : { (x: E): E; (x: any): any; }
> : ^^^ ^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
function f() { }
@@ -297,7 +297,7 @@ module f {
}
declare function foo15(x: typeof f): typeof f;
>foo15 : { (x: typeof f): typeof f; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : typeof f
> : ^^^^^^^^
>f : typeof f
@@ -307,14 +307,14 @@ declare function foo15(x: typeof f): typeof f;
declare function foo15(x: any): any;
>foo15 : { (x: typeof f): typeof f; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
class CC { baz: string }
@@ -335,55 +335,55 @@ module CC {
}
declare function foo16(x: CC): CC;
>foo16 : { (x: CC): CC; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : CC
> : ^^
declare function foo16(x: any): any;
>foo16 : { (x: CC): CC; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
declare function foo17(x: Object): Object;
>foo17 : { (x: Object): Object; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : Object
> : ^^^^^^
declare function foo17(x: any): any;
>foo17 : { (x: Object): Object; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
declare function foo18(x: {}): {};
>foo18 : { (x: {}): {}; (x: any): any; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^
>x : {}
> : ^^
declare function foo18(x: any): any;
>foo18 : { (x: {}): {}; (x: any): any; }
> : ^^^ ^^^^^^^ ^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^ ^^ ^^^ ^^^
>x : any
var r3 = foo3(a); // any
>r3 : any
>foo3(a) : any
>foo3 : { (x: string): string; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>a : any
tests/baselines/reference/anyIdenticalToItself.types
+3 -3
View File
@@ -3,19 +3,19 @@
=== anyIdenticalToItself.ts ===
function foo(x: any);
>foo : { (x: any): any; (x: any): any; }
> : ^^^ ^^ ^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^^^^^^^^
>x : any
> : ^^^
function foo(x: any);
>foo : { (x: any): any; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^ ^^ ^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^^^^^^^^
>x : any
> : ^^^
function foo(x: any, y: number) { }
>foo : { (x: any): any; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^^^^^^^^
>x : any
> : ^^^
>y : number
tests/baselines/reference/anyInferenceAnonymousFunctions.types
+10 -10
View File
@@ -8,11 +8,11 @@ var paired: any[];
paired.reduce(function (a1, a2) {
>paired.reduce(function (a1, a2) { return a1.concat({});} , []) : any
>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
>paired : any[]
> : ^^^^^
>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
>function (a1, a2) { return a1.concat({});} : (a1: any, a2: any) => any
> : ^ ^^^^^^^ ^^^^^^^^^^^^^
>a1 : any
@@ -35,11 +35,11 @@ paired.reduce(function (a1, a2) {
paired.reduce((b1, b2) => {
>paired.reduce((b1, b2) => { return b1.concat({});} , []) : any
>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
>paired : any[]
> : ^^^^^
>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
>(b1, b2) => { return b1.concat({});} : (b1: any, b2: any) => any
> : ^ ^^^^^^^ ^^^^^^^^^^^^^
>b1 : any
@@ -62,11 +62,11 @@ paired.reduce((b1, b2) => {
paired.reduce((b3, b4) => b3.concat({}), []);
>paired.reduce((b3, b4) => b3.concat({}), []) : any
>paired.reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
>paired : any[]
> : ^^^^^
>reduce : { (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any): any; (callbackfn: (previousValue: any, currentValue: any, currentIndex: number, array: any[]) => any, initialValue: any): any; <U>(callbackfn: (previousValue: U, currentValue: any, currentIndex: number, array: any[]) => U, initialValue: U): U; }
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
> : ^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^
>(b3, b4) => b3.concat({}) : (b3: any, b4: any) => any
> : ^ ^^^^^^^ ^^^^^^^^^^^^^
>b3 : any
@@ -86,11 +86,11 @@ paired.map((c1) => c1.count);
>paired.map((c1) => c1.count) : any[]
> : ^^^^^
>paired.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>paired : any[]
> : ^^^^^
>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>(c1) => c1.count : (c1: any) => any
> : ^ ^^^^^^^^^^^^^
>c1 : any
@@ -104,11 +104,11 @@ paired.map(function (c2) { return c2.count; });
>paired.map(function (c2) { return c2.count; }) : any[]
> : ^^^^^
>paired.map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>paired : any[]
> : ^^^^^
>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>function (c2) { return c2.count; } : (c2: any) => any
> : ^ ^^^^^^^^^^^^^
>c2 : any
tests/baselines/reference/argsInScope.types
+2 -2
View File
@@ -52,11 +52,11 @@ c.P(1,2,3);
>c.P(1,2,3) : void
> : ^^^^
>c.P : (ii: number, j: number, k: number) => void
> : ^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
>c : C
> : ^
>P : (ii: number, j: number, k: number) => void
> : ^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
>1 : 1
> : ^
>2 : 2
tests/baselines/reference/argumentExpressionContextualTyping.types
+4 -4
View File
@@ -190,7 +190,7 @@ baz(tuple);
>baz(tuple) : void
> : ^^^^
>baz : (x: [string, number, boolean]) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>tuple : [string, number, boolean]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -198,7 +198,7 @@ baz(["string", 1, true]);
>baz(["string", 1, true]) : void
> : ^^^^
>baz : (x: [string, number, boolean]) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>["string", 1, true] : [string, number, true]
> : ^^^^^^^^^^^^^^^^^^^^^^
>"string" : "string"
@@ -212,7 +212,7 @@ baz(array); // Error
>baz(array) : void
> : ^^^^
>baz : (x: [string, number, boolean]) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>array : (string | number | boolean)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -220,7 +220,7 @@ baz(["string", 1, true, ...array]); // Error
>baz(["string", 1, true, ...array]) : void
> : ^^^^
>baz : (x: [string, number, boolean]) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>["string", 1, true, ...array] : [string, number, true, ...(string | number | boolean)[]]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>"string" : "string"
tests/baselines/reference/argumentsAsPropertyName.types
+4 -4
View File
@@ -41,7 +41,7 @@ function myFunction(myType: MyType) {
use(myType.arguments[i]);
>use(myType.arguments[i]) : any
>use : (s: any) => any
> : ^ ^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^
>myType.arguments[i] : string
> : ^^^^^^
>myType.arguments : string[]
@@ -64,7 +64,7 @@ function myFunction(myType: MyType) {
>[1, 2, 3].forEach(function(j) { use(x); }) : void
> : ^^^^
>[1, 2, 3].forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
> : ^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>[1, 2, 3] : number[]
> : ^^^^^^^^
>1 : 1
@@ -74,14 +74,14 @@ function myFunction(myType: MyType) {
>3 : 3
> : ^
>forEach : (callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void
> : ^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>function(j) { use(x); } : (j: number) => void
> : ^ ^^^^^^^^^^^^^^^^^
>j : number
> : ^^^^^^
>use(x) : any
>use : (s: any) => any
> : ^ ^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^
>x : 5
> : ^
}
tests/baselines/reference/argumentsAsPropertyName2.types
+2 -2
View File
@@ -31,11 +31,11 @@ function foo() {
>[].forEach(function () { i }) : void
> : ^^^^
>[].forEach : (callbackfn: (value: any, index: number, array: any[]) => void, thisArg?: any) => void
> : ^ ^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>[] : undefined[]
> : ^^^^^^^^^^^
>forEach : (callbackfn: (value: any, index: number, array: any[]) => void, thisArg?: any) => void
> : ^ ^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^
>function () { i } : () => void
> : ^^^^^^^^^^
>i : number
tests/baselines/reference/argumentsObjectCreatesRestForJs.types
+1 -1
View File
@@ -66,7 +66,7 @@ jsdocced(1);
>jsdocced(1) : void
> : ^^^^
>jsdocced : (x: number, ...args: any[]) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
>1 : 1
> : ^
tests/baselines/reference/argumentsReferenceInFunction1_Js.types
+2 -2
View File
@@ -93,11 +93,11 @@ const debuglog = function() {
>format.apply(null, arguments) : string
> : ^^^^^^
>format.apply : { <T, R>(this: (this: T) => R, thisArg: T): R; <T_1, A extends any[], R_1>(this: (this: T_1, ...args: A) => R_1, thisArg: T_1, args: A): R_1; }
> : ^^^^^^^^^ ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^ ^^ ^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
>format : (f: any, ...args: any[]) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>apply : { <T, R>(this: (this: T) => R, thisArg: T): R; <T_1, A extends any[], R_1>(this: (this: T_1, ...args: A) => R_1, thisArg: T_1, args: A): R_1; }
> : ^^^^^^^^^ ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^ ^^ ^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
>arguments : IArguments
> : ^^^^^^^^^^
tests/baselines/reference/argumentsSpreadRestIterables(target=es5).types
+8 -8
View File
@@ -69,7 +69,7 @@ const res1 = fn1(..."hello");
>fn1(..."hello") : readonly any[]
> : ^^^^^^^^^^^^^^
>fn1 : <const T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>..."hello" : any
> : ^^^
>"hello" : "hello"
@@ -81,7 +81,7 @@ const res2 = fn1(...itNum);
>fn1(...itNum) : Iterable<number>
> : ^^^^^^^^^^^^^^^^
>fn1 : <const T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>...itNum : Iterable<number>
> : ^^^^^^^^^^^^^^^^
>itNum : Iterable<number>
@@ -93,7 +93,7 @@ const res3 = fn1(true, ..."hello");
>fn1(true, ..."hello") : readonly [true, ...any[]]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>fn1 : <const T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>..."hello" : any
@@ -107,7 +107,7 @@ const res4 = fn1(true, ...itNum);
>fn1(true, ...itNum) : readonly [true, ...Iterable<number>[]]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>fn1 : <const T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>...itNum : Iterable<number>
@@ -128,7 +128,7 @@ const p1 = foo(..."hello");
>foo(..."hello") : any[]
> : ^^^^^
>foo : <T extends unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>..."hello" : any
> : ^^^
>"hello" : "hello"
@@ -140,7 +140,7 @@ const p2 = foo(...itNum);
>foo(...itNum) : Iterable<number>
> : ^^^^^^^^^^^^^^^^
>foo : <T extends unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>...itNum : Iterable<number>
> : ^^^^^^^^^^^^^^^^
>itNum : Iterable<number>
@@ -152,7 +152,7 @@ const p3 = foo(true, ..."hello");
>foo(true, ..."hello") : [boolean, ...any[]]
> : ^^^^^^^^^^^^^^^^^^^
>foo : <T extends unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>..."hello" : any
@@ -166,7 +166,7 @@ const p4 = foo(true, ...itNum);
>foo(true, ...itNum) : [boolean, ...Iterable<number>[]]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>foo : <T extends unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>...itNum : Iterable<number>
tests/baselines/reference/argumentsSpreadRestIterables(target=esnext).types
+8 -8
View File
@@ -69,7 +69,7 @@ const res1 = fn1(..."hello");
>fn1(..."hello") : readonly string[]
> : ^^^^^^^^^^^^^^^^^
>fn1 : <const T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>..."hello" : string
> : ^^^^^^
>"hello" : "hello"
@@ -81,7 +81,7 @@ const res2 = fn1(...itNum);
>fn1(...itNum) : readonly number[]
> : ^^^^^^^^^^^^^^^^^
>fn1 : <const T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>...itNum : number
> : ^^^^^^
>itNum : Iterable<number>
@@ -93,7 +93,7 @@ const res3 = fn1(true, ..."hello");
>fn1(true, ..."hello") : readonly [true, ...string[]]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>fn1 : <const T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>..."hello" : string
@@ -107,7 +107,7 @@ const res4 = fn1(true, ...itNum);
>fn1(true, ...itNum) : readonly [true, ...number[]]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>fn1 : <const T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>...itNum : number
@@ -128,7 +128,7 @@ const p1 = foo(..."hello");
>foo(..."hello") : string[]
> : ^^^^^^^^
>foo : <T extends unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>..."hello" : string
> : ^^^^^^
>"hello" : "hello"
@@ -140,7 +140,7 @@ const p2 = foo(...itNum);
>foo(...itNum) : number[]
> : ^^^^^^^^
>foo : <T extends unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>...itNum : number
> : ^^^^^^
>itNum : Iterable<number>
@@ -152,7 +152,7 @@ const p3 = foo(true, ..."hello");
>foo(true, ..."hello") : [boolean, ...string[]]
> : ^^^^^^^^^^^^^^^^^^^^^^
>foo : <T extends unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>..."hello" : string
@@ -166,7 +166,7 @@ const p4 = foo(true, ...itNum);
>foo(true, ...itNum) : [boolean, ...number[]]
> : ^^^^^^^^^^^^^^^^^^^^^^
>foo : <T extends unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>...itNum : number
tests/baselines/reference/arrayAssignmentTest5.types
+4 -4
View File
@@ -69,11 +69,11 @@ module Test {
>this.tokenize(line, state, true) : ILineTokens
> : ^^^^^^^^^^^
>this.tokenize : (line: string, state: IState, includeStates: boolean) => ILineTokens
> : ^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^
>this : this
> : ^^^^
>tokenize : (line: string, state: IState, includeStates: boolean) => ILineTokens
> : ^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^
>line : string
> : ^^^^^^
>state : IState
@@ -107,11 +107,11 @@ module Test {
>this.onEnter(line, tokens, offset) : IAction
> : ^^^^^^^
>this.onEnter : (line: string, state: IState, offset: number) => IAction
> : ^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>onEnter : (line: string, state: IState, offset: number) => IAction
> : ^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>line : string
> : ^^^^^^
>tokens : IStateToken[]
tests/baselines/reference/arrayAugment.types
+2 -2
View File
@@ -23,11 +23,11 @@ var y = x.split(4);
>x.split(4) : string[][]
> : ^^^^^^^^^^
>x.split : (parts: number) => string[][]
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^
>x : string[]
> : ^^^^^^^^
>split : (parts: number) => string[][]
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^
>4 : 4
> : ^
tests/baselines/reference/arrayBestCommonTypes.types
+60 -60
View File
@@ -27,7 +27,7 @@ module EmptyTypes {
public voidIfAny(x: boolean, y?: boolean): number;
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>x : boolean
> : ^^^^^^^
>y : boolean
@@ -35,7 +35,7 @@ module EmptyTypes {
public voidIfAny(x: string, y?: boolean): number;
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>x : string
> : ^^^^^^
>y : boolean
@@ -43,7 +43,7 @@ module EmptyTypes {
public voidIfAny(x: number, y?: boolean): number;
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^
>x : number
> : ^^^^^^
>y : boolean
@@ -51,7 +51,7 @@ module EmptyTypes {
public voidIfAny(x: any, y = false): any { return null; }
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>x : any
>y : boolean
> : ^^^^^^^
@@ -70,11 +70,11 @@ module EmptyTypes {
>this.voidIfAny([4, 2][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[4, 2][0] : number
> : ^^^^^^
>[4, 2] : number[]
@@ -94,11 +94,11 @@ module EmptyTypes {
>this.voidIfAny([4, 2, undefined][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[4, 2, undefined][0] : number
> : ^^^^^^
>[4, 2, undefined] : number[]
@@ -120,11 +120,11 @@ module EmptyTypes {
>this.voidIfAny([undefined, 2, 4][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[undefined, 2, 4][0] : number
> : ^^^^^^
>[undefined, 2, 4] : number[]
@@ -146,11 +146,11 @@ module EmptyTypes {
>this.voidIfAny([null, 2, 4][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[null, 2, 4][0] : number
> : ^^^^^^
>[null, 2, 4] : number[]
@@ -170,11 +170,11 @@ module EmptyTypes {
>this.voidIfAny([2, 4, null][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[2, 4, null][0] : number
> : ^^^^^^
>[2, 4, null] : number[]
@@ -194,11 +194,11 @@ module EmptyTypes {
>this.voidIfAny([undefined, 4, null][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[undefined, 4, null][0] : number
> : ^^^^^^
>[undefined, 4, null] : number[]
@@ -218,11 +218,11 @@ module EmptyTypes {
>this.voidIfAny(['', "q"][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>['', "q"][0] : string
> : ^^^^^^
>['', "q"] : string[]
@@ -242,11 +242,11 @@ module EmptyTypes {
>this.voidIfAny(['', "q", undefined][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>['', "q", undefined][0] : string
> : ^^^^^^
>['', "q", undefined] : string[]
@@ -268,11 +268,11 @@ module EmptyTypes {
>this.voidIfAny([undefined, "q", ''][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[undefined, "q", ''][0] : string
> : ^^^^^^
>[undefined, "q", ''] : string[]
@@ -294,11 +294,11 @@ module EmptyTypes {
>this.voidIfAny([null, "q", ''][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[null, "q", ''][0] : string
> : ^^^^^^
>[null, "q", ''] : string[]
@@ -318,11 +318,11 @@ module EmptyTypes {
>this.voidIfAny(["q", '', null][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>["q", '', null][0] : string
> : ^^^^^^
>["q", '', null] : string[]
@@ -342,11 +342,11 @@ module EmptyTypes {
>this.voidIfAny([undefined, '', null][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[undefined, '', null][0] : string
> : ^^^^^^
>[undefined, '', null] : string[]
@@ -366,11 +366,11 @@ module EmptyTypes {
>this.voidIfAny([[3, 4], [null]][0][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[[3, 4], [null]][0][0] : number
> : ^^^^^^
>[[3, 4], [null]][0] : number[]
@@ -709,7 +709,7 @@ module NonEmptyTypes {
public voidIfAny(x: boolean, y?: boolean): number;
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>x : boolean
> : ^^^^^^^
>y : boolean
@@ -717,7 +717,7 @@ module NonEmptyTypes {
public voidIfAny(x: string, y?: boolean): number;
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>x : string
> : ^^^^^^
>y : boolean
@@ -725,7 +725,7 @@ module NonEmptyTypes {
public voidIfAny(x: number, y?: boolean): number;
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^
>x : number
> : ^^^^^^
>y : boolean
@@ -733,7 +733,7 @@ module NonEmptyTypes {
public voidIfAny(x: any, y = false): any { return null; }
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>x : any
>y : boolean
> : ^^^^^^^
@@ -752,11 +752,11 @@ module NonEmptyTypes {
>this.voidIfAny([4, 2][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[4, 2][0] : number
> : ^^^^^^
>[4, 2] : number[]
@@ -776,11 +776,11 @@ module NonEmptyTypes {
>this.voidIfAny([4, 2, undefined][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[4, 2, undefined][0] : number
> : ^^^^^^
>[4, 2, undefined] : number[]
@@ -802,11 +802,11 @@ module NonEmptyTypes {
>this.voidIfAny([undefined, 2, 4][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[undefined, 2, 4][0] : number
> : ^^^^^^
>[undefined, 2, 4] : number[]
@@ -828,11 +828,11 @@ module NonEmptyTypes {
>this.voidIfAny([null, 2, 4][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[null, 2, 4][0] : number
> : ^^^^^^
>[null, 2, 4] : number[]
@@ -852,11 +852,11 @@ module NonEmptyTypes {
>this.voidIfAny([2, 4, null][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[2, 4, null][0] : number
> : ^^^^^^
>[2, 4, null] : number[]
@@ -876,11 +876,11 @@ module NonEmptyTypes {
>this.voidIfAny([undefined, 4, null][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[undefined, 4, null][0] : number
> : ^^^^^^
>[undefined, 4, null] : number[]
@@ -900,11 +900,11 @@ module NonEmptyTypes {
>this.voidIfAny(['', "q"][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>['', "q"][0] : string
> : ^^^^^^
>['', "q"] : string[]
@@ -924,11 +924,11 @@ module NonEmptyTypes {
>this.voidIfAny(['', "q", undefined][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>['', "q", undefined][0] : string
> : ^^^^^^
>['', "q", undefined] : string[]
@@ -950,11 +950,11 @@ module NonEmptyTypes {
>this.voidIfAny([undefined, "q", ''][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[undefined, "q", ''][0] : string
> : ^^^^^^
>[undefined, "q", ''] : string[]
@@ -976,11 +976,11 @@ module NonEmptyTypes {
>this.voidIfAny([null, "q", ''][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[null, "q", ''][0] : string
> : ^^^^^^
>[null, "q", ''] : string[]
@@ -1000,11 +1000,11 @@ module NonEmptyTypes {
>this.voidIfAny(["q", '', null][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>["q", '', null][0] : string
> : ^^^^^^
>["q", '', null] : string[]
@@ -1024,11 +1024,11 @@ module NonEmptyTypes {
>this.voidIfAny([undefined, '', null][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[undefined, '', null][0] : string
> : ^^^^^^
>[undefined, '', null] : string[]
@@ -1048,11 +1048,11 @@ module NonEmptyTypes {
>this.voidIfAny([[3, 4], [null]][0][0]) : number
> : ^^^^^^
>this.voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>this : this
> : ^^^^
>voidIfAny : { (x: boolean, y?: boolean): number; (x: string, y?: boolean): number; (x: number, y?: boolean): number; }
> : ^^^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>[[3, 4], [null]][0][0] : number
> : ^^^^^^
>[[3, 4], [null]][0] : number[]
tests/baselines/reference/arrayBufferIsViewNarrowsType.types
+2 -2
View File
@@ -9,11 +9,11 @@ if (ArrayBuffer.isView(obj)) {
>ArrayBuffer.isView(obj) : boolean
> : ^^^^^^^
>ArrayBuffer.isView : (arg: any) => arg is ArrayBufferView
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>ArrayBuffer : ArrayBufferConstructor
> : ^^^^^^^^^^^^^^^^^^^^^^
>isView : (arg: any) => arg is ArrayBufferView
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>obj : Object
> : ^^^^^^
tests/baselines/reference/arrayConcatMap.types
+2 -2
View File
@@ -7,7 +7,7 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }])
>[].concat([{ a: 1 }], [{ a: 2 }]) .map(b => b.a) : any[]
> : ^^^^^
>[].concat([{ a: 1 }], [{ a: 2 }]) .map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>[].concat([{ a: 1 }], [{ a: 2 }]) : any[]
> : ^^^^^
>[].concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
@@ -35,7 +35,7 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }])
.map(b => b.a);
>map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
> : ^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^^ ^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^
>b => b.a : (b: any) => any
> : ^ ^^^^^^^^^^^^^
>b : any
tests/baselines/reference/arrayDestructuringInSwitch1.types
+6 -6
View File
@@ -19,11 +19,11 @@ export function evaluate(expression: Expression): boolean {
>Array.isArray(expression) : boolean
> : ^^^^^^^
>Array.isArray : (arg: any) => arg is any[]
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>isArray : (arg: any) => arg is any[]
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^
>expression : Expression
> : ^^^^^^^^^^
@@ -47,11 +47,11 @@ export function evaluate(expression: Expression): boolean {
>operands.every((child) => evaluate(child)) : boolean
> : ^^^^^^^
>operands.every : { <S extends Expression>(predicate: (value: Expression, index: number, array: Expression[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: Expression, index: number, array: Expression[]) => unknown, thisArg?: any): boolean; } | { <S_1 extends Expression>(predicate: (value: Expression, index: number, array: Expression[]) => value is S_1, thisArg?: any): this is S_1[]; (predicate: (value: Expression, index: number, array: Expression[]) => unknown, thisArg?: any): boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^
>operands : Expression[] | [Expression]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>every : { <S extends Expression>(predicate: (value: Expression, index: number, array: Expression[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: Expression, index: number, array: Expression[]) => unknown, thisArg?: any): boolean; } | { <S_1 extends Expression>(predicate: (value: Expression, index: number, array: Expression[]) => value is S_1, thisArg?: any): this is S_1[]; (predicate: (value: Expression, index: number, array: Expression[]) => unknown, thisArg?: any): boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^
>(child) => evaluate(child) : (child: Expression) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
>child : Expression
@@ -59,7 +59,7 @@ export function evaluate(expression: Expression): boolean {
>evaluate(child) : boolean
> : ^^^^^^^
>evaluate : (expression: Expression) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^
>child : Expression
> : ^^^^^^^^^^
}
@@ -73,7 +73,7 @@ export function evaluate(expression: Expression): boolean {
>evaluate(operands[0]) : boolean
> : ^^^^^^^
>evaluate : (expression: Expression) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^
>operands[0] : Expression
> : ^^^^^^^^^^
>operands : Expression[] | [Expression]
tests/baselines/reference/arrayEvery.types
+5 -5
View File
@@ -29,19 +29,19 @@ if (foo.every(isString)) {
>foo.every(isString) : boolean
> : ^^^^^^^
>foo.every : { <S extends string | number>(predicate: (value: string | number, index: number, array: (string | number)[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: string | number, index: number, array: (string | number)[]) => unknown, thisArg?: any): boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^
>foo : (string | number)[]
> : ^^^^^^^^^^^^^^^^^^^
>every : { <S extends string | number>(predicate: (value: string | number, index: number, array: (string | number)[]) => value is S, thisArg?: any): this is S[]; (predicate: (value: string | number, index: number, array: (string | number)[]) => unknown, thisArg?: any): boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^
>isString : (x: unknown) => x is string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^
foo[0].slice(0);
>foo[0].slice(0) : string
> : ^^^^^^
>foo[0].slice : (start?: number, end?: number) => string
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
>foo[0] : string
> : ^^^^^^
>foo : string[]
@@ -49,7 +49,7 @@ if (foo.every(isString)) {
>0 : 0
> : ^
>slice : (start?: number, end?: number) => string
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
>0 : 0
> : ^
}
tests/baselines/reference/arrayFakeFlatNoCrashInferenceDeclarations.types
+2 -2
View File
File diff suppressed because one or more lines are too long
tests/baselines/reference/arrayFilter.types
+2 -2
View File
@@ -35,11 +35,11 @@ foo.filter(x => x.name); //should accepted all possible types not only boolean!
>foo.filter(x => x.name) : { name: string; }[]
> : ^^^^^^^^^^^^^^^^^^^
>foo.filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^ ^^^^^
>foo : { name: string; }[]
> : ^^^^^^^^^^^^^^^^^^^
>filter : { <S extends { name: string; }>(predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => value is S, thisArg?: any): S[]; (predicate: (value: { name: string; }, index: number, array: { name: string; }[]) => unknown, thisArg?: any): { name: string; }[]; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^ ^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^ ^^^ ^^^ ^^^^^
>x => x.name : (x: { name: string; }) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : { name: string; }
tests/baselines/reference/arrayFind.types
+6 -6
View File
@@ -41,13 +41,13 @@ const foundNumber: number | undefined = arrayOfStringsNumbersAndBooleans.find(is
>arrayOfStringsNumbersAndBooleans.find(isNumber) : number
> : ^^^^^^
>arrayOfStringsNumbersAndBooleans.find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => unknown, thisArg?: any): string | number | boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>arrayOfStringsNumbersAndBooleans : (string | number | boolean)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: (string | number | boolean)[]) => unknown, thisArg?: any): string | number | boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>isNumber : (x: any) => x is number
> : ^ ^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^
const readonlyArrayOfStringsNumbersAndBooleans = arrayOfStringsNumbersAndBooleans as ReadonlyArray<string | number | boolean>;
>readonlyArrayOfStringsNumbersAndBooleans : readonly (string | number | boolean)[]
@@ -63,11 +63,11 @@ const readonlyFoundNumber: number | undefined = readonlyArrayOfStringsNumbersAnd
>readonlyArrayOfStringsNumbersAndBooleans.find(isNumber) : number
> : ^^^^^^
>readonlyArrayOfStringsNumbersAndBooleans.find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => unknown, thisArg?: any): string | number | boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>readonlyArrayOfStringsNumbersAndBooleans : readonly (string | number | boolean)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>find : { <S extends string | number | boolean>(predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => value is S, thisArg?: any): S; (predicate: (value: string | number | boolean, index: number, obj: readonly (string | number | boolean)[]) => unknown, thisArg?: any): string | number | boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>isNumber : (x: any) => x is number
> : ^ ^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^
tests/baselines/reference/arrayFlatMap.types
+4 -4
View File
@@ -17,11 +17,11 @@ array.flatMap((): ReadonlyArray<number> => []); // ok
>array.flatMap((): ReadonlyArray<number> => []) : number[]
> : ^^^^^^^^
>array.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
>array : number[]
> : ^^^^^^^^
>flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
>(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
> : ^^^^^^
>[] : undefined[]
@@ -31,11 +31,11 @@ readonlyArray.flatMap((): ReadonlyArray<number> => []); // ok
>readonlyArray.flatMap((): ReadonlyArray<number> => []) : number[]
> : ^^^^^^^^
>readonlyArray.flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
>readonlyArray : readonly number[]
> : ^^^^^^^^^^^^^^^^^
>flatMap : <U, This = undefined>(callback: (this: This, value: number, index: number, array: number[]) => U | readonly U[], thisArg?: This) => U[]
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^ ^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^
>(): ReadonlyArray<number> => [] : () => ReadonlyArray<number>
> : ^^^^^^
>[] : undefined[]
tests/baselines/reference/arrayFrom.types
+23 -23
View File
@@ -44,7 +44,7 @@ const inputARand = getEither(inputA, inputALike);
>getEither(inputA, inputALike) : ArrayLike<A> | Iterable<A>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
>getEither : <T>(in1: Iterable<T>, in2: ArrayLike<T>) => ArrayLike<T> | Iterable<T>
> : ^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>inputA : A[]
> : ^^^
>inputALike : ArrayLike<A>
@@ -64,11 +64,11 @@ const result1: A[] = Array.from(inputA);
>Array.from(inputA) : A[]
> : ^^^
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>inputA : A[]
> : ^^^
@@ -78,11 +78,11 @@ const result2: A[] = Array.from(inputA.values());
>Array.from(inputA.values()) : A[]
> : ^^^
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>inputA.values() : IterableIterator<A>
> : ^^^^^^^^^^^^^^^^^^^
>inputA.values : () => IterableIterator<A>
@@ -98,11 +98,11 @@ const result3: B[] = Array.from(inputA.values()); // expect error
>Array.from(inputA.values()) : A[]
> : ^^^
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>inputA.values() : IterableIterator<A>
> : ^^^^^^^^^^^^^^^^^^^
>inputA.values : () => IterableIterator<A>
@@ -118,11 +118,11 @@ const result4: A[] = Array.from(inputB, ({ b }): A => ({ a: b }));
>Array.from(inputB, ({ b }): A => ({ a: b })) : A[]
> : ^^^
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>inputB : B[]
> : ^^^
>({ b }): A => ({ a: b }) : ({ b }: B) => A
@@ -144,11 +144,11 @@ const result5: A[] = Array.from(inputALike);
>Array.from(inputALike) : A[]
> : ^^^
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>inputALike : ArrayLike<A>
> : ^^^^^^^^^^^^
@@ -158,11 +158,11 @@ const result6: B[] = Array.from(inputALike); // expect error
>Array.from(inputALike) : A[]
> : ^^^
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>inputALike : ArrayLike<A>
> : ^^^^^^^^^^^^
@@ -172,11 +172,11 @@ const result7: B[] = Array.from(inputALike, ({ a }): B => ({ b: a }));
>Array.from(inputALike, ({ a }): B => ({ b: a })) : B[]
> : ^^^
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>inputALike : ArrayLike<A>
> : ^^^^^^^^^^^^
>({ a }): B => ({ b: a }) : ({ a }: A) => B
@@ -198,11 +198,11 @@ const result8: A[] = Array.from(inputARand);
>Array.from(inputARand) : A[]
> : ^^^
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>inputARand : ArrayLike<A> | Iterable<A>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -212,11 +212,11 @@ const result9: B[] = Array.from(inputARand, ({ a }): B => ({ b: a }));
>Array.from(inputARand, ({ a }): B => ({ b: a })) : B[]
> : ^^^
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>inputARand : ArrayLike<A> | Iterable<A>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
>({ a }): B => ({ b: a }) : ({ a }: A) => B
@@ -238,11 +238,11 @@ const result10: A[] = Array.from(new Set<A>());
>Array.from(new Set<A>()) : A[]
> : ^^^
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>new Set<A>() : Set<A>
> : ^^^^^^
>Set : SetConstructor
@@ -254,11 +254,11 @@ const result11: B[] = Array.from(inputASet, ({ a }): B => ({ b: a }));
>Array.from(inputASet, ({ a }): B => ({ b: a })) : B[]
> : ^^^
>Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>from : { <T>(arrayLike: ArrayLike<T>): T[]; <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[]; <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[]; <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[]; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^
>inputASet : Set<A>
> : ^^^^^^
>({ a }): B => ({ b: a }) : ({ a }: A) => B
tests/baselines/reference/arrayFromAsync.types
+42 -42
View File
@@ -57,11 +57,11 @@ function * genPromises (n) {
>Promise.resolve(i * 2) : Promise<number>
> : ^^^^^^^^^^^^^^^
>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Promise : PromiseConstructor
> : ^^^^^^^^^^^^^^^^^^
>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>i * 2 : number
> : ^^^^^^
>i : number
@@ -83,11 +83,11 @@ const arrLike = {
>Promise.resolve(0) : Promise<number>
> : ^^^^^^^^^^^^^^^
>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Promise : PromiseConstructor
> : ^^^^^^^^^^^^^^^^^^
>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>0 : 0
> : ^
@@ -97,11 +97,11 @@ const arrLike = {
>Promise.resolve(2) : Promise<number>
> : ^^^^^^^^^^^^^^^
>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Promise : PromiseConstructor
> : ^^^^^^^^^^^^^^^^^^
>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>2 : 2
> : ^
@@ -111,11 +111,11 @@ const arrLike = {
>Promise.resolve(4) : Promise<number>
> : ^^^^^^^^^^^^^^^
>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Promise : PromiseConstructor
> : ^^^^^^^^^^^^^^^^^^
>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>4 : 4
> : ^
@@ -125,11 +125,11 @@ const arrLike = {
>Promise.resolve(6) : Promise<number>
> : ^^^^^^^^^^^^^^^
>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Promise : PromiseConstructor
> : ^^^^^^^^^^^^^^^^^^
>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>6 : 6
> : ^
@@ -177,11 +177,11 @@ const sameArr1 = await Array.fromAsync(arrLike);
>Array.fromAsync(arrLike) : Promise<number[]>
> : ^^^^^^^^^^^^^^^^^
>Array.fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>arrLike : { 0: Promise<number>; 1: Promise<number>; 2: Promise<number>; 3: Promise<number>; length: number; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,51 +193,51 @@ const sameArr2 = await Array.fromAsync([Promise.resolve(0), Promise.resolve(2),
>Array.fromAsync([Promise.resolve(0), Promise.resolve(2), Promise.resolve(4), Promise.resolve(6)]) : Promise<number[]>
> : ^^^^^^^^^^^^^^^^^
>Array.fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>[Promise.resolve(0), Promise.resolve(2), Promise.resolve(4), Promise.resolve(6)] : Promise<number>[]
> : ^^^^^^^^^^^^^^^^^
>Promise.resolve(0) : Promise<number>
> : ^^^^^^^^^^^^^^^
>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Promise : PromiseConstructor
> : ^^^^^^^^^^^^^^^^^^
>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>0 : 0
> : ^
>Promise.resolve(2) : Promise<number>
> : ^^^^^^^^^^^^^^^
>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Promise : PromiseConstructor
> : ^^^^^^^^^^^^^^^^^^
>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>2 : 2
> : ^
>Promise.resolve(4) : Promise<number>
> : ^^^^^^^^^^^^^^^
>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Promise : PromiseConstructor
> : ^^^^^^^^^^^^^^^^^^
>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>4 : 4
> : ^
>Promise.resolve(6) : Promise<number>
> : ^^^^^^^^^^^^^^^
>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Promise : PromiseConstructor
> : ^^^^^^^^^^^^^^^^^^
>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>6 : 6
> : ^
@@ -249,11 +249,11 @@ const sameArr3 = await Array.fromAsync(genPromises(4));
>Array.fromAsync(genPromises(4)) : Promise<number[]>
> : ^^^^^^^^^^^^^^^^^
>Array.fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>genPromises(4) : Generator<Promise<number>, void, unknown>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>genPromises : (n: any) => Generator<Promise<number>, void, unknown>
@@ -269,11 +269,11 @@ const sameArr4 = await Array.fromAsync(asyncGen(4));
>Array.fromAsync(asyncGen(4)) : Promise<number[]>
> : ^^^^^^^^^^^^^^^^^
>Array.fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>asyncGen(4) : AsyncGenerator<number, void, unknown>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>asyncGen : (n: any) => AsyncGenerator<number, void, unknown>
@@ -288,19 +288,19 @@ function Data (n) {}
Data.fromAsync = Array.fromAsync;
>Data.fromAsync = Array.fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Data.fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Data : typeof Data
> : ^^^^^^^^^^^
>fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Array.fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
const sameArr5 = await Data.fromAsync(asyncGen(4));
>sameArr5 : number[]
@@ -310,11 +310,11 @@ const sameArr5 = await Data.fromAsync(asyncGen(4));
>Data.fromAsync(asyncGen(4)) : Promise<number[]>
> : ^^^^^^^^^^^^^^^^^
>Data.fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Data : typeof Data
> : ^^^^^^^^^^^
>fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>asyncGen(4) : AsyncGenerator<number, void, unknown>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>asyncGen : (n: any) => AsyncGenerator<number, void, unknown>
@@ -330,11 +330,11 @@ const mapArr1 = await Array.fromAsync(asyncGen(4), v => v ** 2);
>Array.fromAsync(asyncGen(4), v => v ** 2) : Promise<number[]>
> : ^^^^^^^^^^^^^^^^^
>Array.fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>asyncGen(4) : AsyncGenerator<number, void, unknown>
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>asyncGen : (n: any) => AsyncGenerator<number, void, unknown>
@@ -360,11 +360,11 @@ const mapArr2 = await Array.fromAsync([0,2,4,6], v => Promise.resolve(v ** 2));
>Array.fromAsync([0,2,4,6], v => Promise.resolve(v ** 2)) : Promise<number[]>
> : ^^^^^^^^^^^^^^^^^
>Array.fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>[0,2,4,6] : number[]
> : ^^^^^^^^
>0 : 0
@@ -382,11 +382,11 @@ const mapArr2 = await Array.fromAsync([0,2,4,6], v => Promise.resolve(v ** 2));
>Promise.resolve(v ** 2) : Promise<number>
> : ^^^^^^^^^^^^^^^
>Promise.resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Promise : PromiseConstructor
> : ^^^^^^^^^^^^^^^^^^
>resolve : { (): Promise<void>; <T>(value: T): Promise<Awaited<T>>; <T_1>(value: T_1 | PromiseLike<T_1>): Promise<Awaited<T_1>>; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>v ** 2 : number
> : ^^^^^^
>v : number
@@ -402,11 +402,11 @@ const mapArr3 = await Array.fromAsync([0,2,4,6], v => v ** 2);
>Array.fromAsync([0,2,4,6], v => v ** 2) : Promise<number[]>
> : ^^^^^^^^^^^^^^^^^
>Array.fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>[0,2,4,6] : number[]
> : ^^^^^^^^
>0 : 0
@@ -461,11 +461,11 @@ const badArray = await Array.fromAsync(badIterable);
>Array.fromAsync(badIterable) : Promise<unknown[]>
> : ^^^^^^^^^^^^^^^^^^
>Array.fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Array : ArrayConstructor
> : ^^^^^^^^^^^^^^^^
>fromAsync : { <T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>; <T_1, U>(iterableOrArrayLike: AsyncIterable<T_1> | Iterable<T_1> | ArrayLike<T_1>, mapFn: (value: Awaited<T_1>) => U, thisArg?: any): Promise<Awaited<U>[]>; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
>badIterable : { [Symbol.iterator](): never; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/arrayLiteralContextualType.types
+4 -4
View File
@@ -59,7 +59,7 @@ foo([
>foo([ new Giraffe(), new Elephant()]) : void
> : ^^^^
>foo : (animals: IAnimal[]) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>[ new Giraffe(), new Elephant()] : (Giraffe | Elephant)[]
> : ^^^^^^^^^^^^^^^^^^^^^^
@@ -80,7 +80,7 @@ bar([
>bar([ new Giraffe(), new Elephant()]) : void
> : ^^^^
>bar : (animals: { [n: number]: IAnimal; }) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>[ new Giraffe(), new Elephant()] : (Giraffe | Elephant)[]
> : ^^^^^^^^^^^^^^^^^^^^^^
@@ -116,7 +116,7 @@ foo(arr); // ok because arr is Array<Giraffe|Elephant> not {}[]
>foo(arr) : void
> : ^^^^
>foo : (animals: IAnimal[]) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>arr : (Giraffe | Elephant)[]
> : ^^^^^^^^^^^^^^^^^^^^^^
@@ -124,7 +124,7 @@ bar(arr); // ok because arr is Array<Giraffe|Elephant> not {}[]
>bar(arr) : void
> : ^^^^
>bar : (animals: { [n: number]: IAnimal; }) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>arr : (Giraffe | Elephant)[]
> : ^^^^^^^^^^^^^^^^^^^^^^
tests/baselines/reference/arrayLiteralInNonVarArgParameter.types
+1 -1
View File
@@ -13,7 +13,7 @@ panic([], 'one', 'two');
>panic([], 'one', 'two') : void
> : ^^^^
>panic : (val: string[], ...opt: string[]) => void
> : ^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^ ^^ ^^^^^^^^^
>[] : undefined[]
> : ^^^^^^^^^^^
>'one' : "one"
tests/baselines/reference/arrayLiteralInference.types
+2 -2
View File
@@ -193,7 +193,7 @@ let b1: { x: boolean }[] = foo({ x: true }, { x: false });
>foo({ x: true }, { x: false }) : ({ x: true; } | { x: false; })[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>foo : <T>(...args: T[]) => T[]
> : ^^^^^^^ ^^^^^^^^^^^^^
> : ^ ^^^^^ ^^ ^^^^^^^^
>{ x: true } : { x: true; }
> : ^^^^^^^^^^^^
>x : true
@@ -213,7 +213,7 @@ let b2: boolean[][] = foo([true], [false]);
>foo([true], [false]) : (true[] | false[])[]
> : ^^^^^^^^^^^^^^^^^^^^
>foo : <T>(...args: T[]) => T[]
> : ^^^^^^^ ^^^^^^^^^^^^^
> : ^ ^^^^^ ^^ ^^^^^^^^
>[true] : true[]
> : ^^^^^^
>true : true
tests/baselines/reference/arrayOfFunctionTypes3.types
+15 -15
View File
@@ -82,23 +82,23 @@ var c: { (x: number): number; (x: any): any; };
var z = [a, b, c];
>z : { (x: number): number; (x: any): any; }[]
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^
>[a, b, c] : { (x: number): number; (x: any): any; }[]
> : ^^
>a : { (x: number): number; (x: string): string; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^
>b : { (x: number): number; (x: string): string; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^
>c : { (x: number): number; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
var r4 = z[0];
>r4 : { (x: number): number; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>z[0] : { (x: number): number; (x: any): any; }
> :
>z : { (x: number): number; (x: any): any; }[]
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^
>0 : 0
> : ^
@@ -106,7 +106,7 @@ var r5 = r4(''); // any not string
>r5 : any
>r4('') : any
>r4 : { (x: number): number; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>'' : ""
> : ^^
@@ -116,7 +116,7 @@ var r5b = r4(1);
>r4(1) : number
> : ^^^^^^
>r4 : { (x: number): number; (x: any): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^
>1 : 1
> : ^
@@ -146,23 +146,23 @@ var c2: { (x: number): number; <T>(x: T): any; };
var z2 = [a2, b2, c2];
>z2 : { (x: number): number; <T>(x: T): any; }[]
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^
>[a2, b2, c2] : { (x: number): number; <T>(x: T): any; }[]
> : ^^
>a2 : { <T>(x: T): number; (x: string): string; }
> : ^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^
>b2 : { <T>(x: T): number; (x: string): string; }
> : ^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^
>c2 : { (x: number): number; <T>(x: T): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^
var r6 = z2[0];
>r6 : { (x: number): number; <T>(x: T): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^
>z2[0] : { (x: number): number; <T>(x: T): any; }
> :
>z2 : { (x: number): number; <T>(x: T): any; }[]
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^^^
>0 : 0
> : ^
@@ -170,7 +170,7 @@ var r7 = r6(''); // any not string
>r7 : any
>r6('') : any
>r6 : { (x: number): number; <T>(x: T): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^^^^^^^^
>'' : ""
> : ^^
tests/baselines/reference/arraySigChecking.types
+4 -4
View File
@@ -98,7 +98,7 @@ isEmpty([]);
>isEmpty([]) : boolean
> : ^^^^^^^
>isEmpty : (l: { length: number; }) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^
>[] : undefined[]
> : ^^^^^^^^^^^
@@ -106,7 +106,7 @@ isEmpty(new Array(3));
>isEmpty(new Array(3)) : boolean
> : ^^^^^^^
>isEmpty : (l: { length: number; }) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^
>new Array(3) : any[]
> : ^^^^^
>Array : ArrayConstructor
@@ -118,7 +118,7 @@ isEmpty(new Array<string>(3));
>isEmpty(new Array<string>(3)) : boolean
> : ^^^^^^^
>isEmpty : (l: { length: number; }) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^
>new Array<string>(3) : string[]
> : ^^^^^^^^
>Array : ArrayConstructor
@@ -130,7 +130,7 @@ isEmpty(['a']);
>isEmpty(['a']) : boolean
> : ^^^^^^^
>isEmpty : (l: { length: number; }) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^
>['a'] : string[]
> : ^^^^^^^^
>'a' : "a"
tests/baselines/reference/arraySlice.types
+2 -2
View File
@@ -9,11 +9,11 @@ arr.splice(1, 1);
>arr.splice(1, 1) : string[] | number[]
> : ^^^^^^^^^^^^^^^^^^^
>arr.splice : { (start: number, deleteCount?: number): string[]; (start: number, deleteCount: number, ...items: string[]): string[]; } | { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>arr : string[] | number[]
> : ^^^^^^^^^^^^^^^^^^^
>splice : { (start: number, deleteCount?: number): string[]; (start: number, deleteCount: number, ...items: string[]): string[]; } | { (start: number, deleteCount?: number): number[]; (start: number, deleteCount: number, ...items: number[]): number[]; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>1 : 1
> : ^
>1 : 1
tests/baselines/reference/arraySpreadInCall.types
+20 -20
View File
@@ -21,7 +21,7 @@ f1(1, 2, 3, 4, ...[5, 6]);
>f1(1, 2, 3, 4, ...[5, 6]) : void
> : ^^^^
>f1 : (a: number, b: number, c: number, d: number, e: number, f: number) => void
> : ^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
>1 : 1
> : ^
>2 : 2
@@ -43,7 +43,7 @@ f1(...[1], 2, 3, 4, 5, 6);
>f1(...[1], 2, 3, 4, 5, 6) : void
> : ^^^^
>f1 : (a: number, b: number, c: number, d: number, e: number, f: number) => void
> : ^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
>...[1] : number
> : ^^^^^^
>[1] : [number]
@@ -65,7 +65,7 @@ f1(1, 2, ...[3, 4], 5, 6);
>f1(1, 2, ...[3, 4], 5, 6) : void
> : ^^^^
>f1 : (a: number, b: number, c: number, d: number, e: number, f: number) => void
> : ^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
>1 : 1
> : ^
>2 : 2
@@ -87,7 +87,7 @@ f1(1, 2, ...[3], 4, ...[5, 6]);
>f1(1, 2, ...[3], 4, ...[5, 6]) : void
> : ^^^^
>f1 : (a: number, b: number, c: number, d: number, e: number, f: number) => void
> : ^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
>1 : 1
> : ^
>2 : 2
@@ -113,7 +113,7 @@ f1(...[1, 2], ...[3, 4], ...[5, 6]);
>f1(...[1, 2], ...[3, 4], ...[5, 6]) : void
> : ^^^^
>f1 : (a: number, b: number, c: number, d: number, e: number, f: number) => void
> : ^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
>...[1, 2] : number
> : ^^^^^^
>[1, 2] : [number, number]
@@ -143,7 +143,7 @@ f1(...(([1, 2])), ...(((([3, 4])))), ...([5, 6]));
>f1(...(([1, 2])), ...(((([3, 4])))), ...([5, 6])) : void
> : ^^^^
>f1 : (a: number, b: number, c: number, d: number, e: number, f: number) => void
> : ^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^ ^^^^^^^^^
>...(([1, 2])) : number
> : ^^^^^^
>(([1, 2])) : [number, number]
@@ -195,7 +195,7 @@ const x21 = f2(...[1, 'foo'])
>f2(...[1, 'foo']) : [number, string]
> : ^^^^^^^^^^^^^^^^
>f2 : <T extends unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>...[1, 'foo'] : string | number
> : ^^^^^^^^^^^^^^^
>[1, 'foo'] : [number, string]
@@ -211,7 +211,7 @@ const x22 = f2(true, ...[1, 'foo'])
>f2(true, ...[1, 'foo']) : [boolean, number, string]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>f2 : <T extends unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>...[1, 'foo'] : string | number
@@ -229,7 +229,7 @@ const x23 = f2(...([1, 'foo']))
>f2(...([1, 'foo'])) : [number, string]
> : ^^^^^^^^^^^^^^^^
>f2 : <T extends unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>...([1, 'foo']) : string | number
> : ^^^^^^^^^^^^^^^
>([1, 'foo']) : [number, string]
@@ -247,7 +247,7 @@ const x24 = f2(true, ...([1, 'foo']))
>f2(true, ...([1, 'foo'])) : [boolean, number, string]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>f2 : <T extends unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>...([1, 'foo']) : string | number
@@ -273,7 +273,7 @@ const x31 = f3(...[1, 'foo'])
>f3(...[1, 'foo']) : [number, string]
> : ^^^^^^^^^^^^^^^^
>f3 : <T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>...[1, 'foo'] : string | number
> : ^^^^^^^^^^^^^^^
>[1, 'foo'] : [number, string]
@@ -289,7 +289,7 @@ const x32 = f3(true, ...[1, 'foo'])
>f3(true, ...[1, 'foo']) : [boolean, number, string]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>f3 : <T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>...[1, 'foo'] : string | number
@@ -307,7 +307,7 @@ const x33 = f3(...([1, 'foo']))
>f3(...([1, 'foo'])) : [number, string]
> : ^^^^^^^^^^^^^^^^
>f3 : <T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>...([1, 'foo']) : string | number
> : ^^^^^^^^^^^^^^^
>([1, 'foo']) : [number, string]
@@ -325,7 +325,7 @@ const x34 = f3(true, ...([1, 'foo']))
>f3(true, ...([1, 'foo'])) : [boolean, number, string]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>f3 : <T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>...([1, 'foo']) : string | number
@@ -351,7 +351,7 @@ const x41 = f4(...[1, 'foo'])
>f4(...[1, 'foo']) : readonly [number, string]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>f4 : <const T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>...[1, 'foo'] : string | number
> : ^^^^^^^^^^^^^^^
>[1, 'foo'] : [number, string]
@@ -367,7 +367,7 @@ const x42 = f4(true, ...[1, 'foo'])
>f4(true, ...[1, 'foo']) : readonly [true, number, string]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>f4 : <const T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>...[1, 'foo'] : string | number
@@ -385,7 +385,7 @@ const x43 = f4(...([1, 'foo']))
>f4(...([1, 'foo'])) : readonly [number, string]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>f4 : <const T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>...([1, 'foo']) : string | number
> : ^^^^^^^^^^^^^^^
>([1, 'foo']) : [number, string]
@@ -403,7 +403,7 @@ const x44 = f4(true, ...([1, 'foo']))
>f4(true, ...([1, 'foo'])) : readonly [true, number, string]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>f4 : <const T extends readonly unknown[]>(...args: T) => T
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^
>true : true
> : ^^^^
>...([1, 'foo']) : string | number
@@ -433,11 +433,11 @@ action.run(...[100, 'foo']) // error
>action.run(...[100, 'foo']) : unknown
> : ^^^^^^^
>action.run : (event?: unknown) => unknown
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^
>action : IAction
> : ^^^^^^^
>run : (event?: unknown) => unknown
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^^
>...[100, 'foo'] : string | number
> : ^^^^^^^^^^^^^^^
>[100, 'foo'] : [number, string]
tests/baselines/reference/arrayToLocaleStringES2015.types
+74 -74
View File
@@ -25,11 +25,11 @@ str = arr.toLocaleString(); // OK
>arr.toLocaleString() : string
> : ^^^^^^
>arr.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>arr : number[]
> : ^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = arr.toLocaleString('en-US'); // OK
>str = arr.toLocaleString('en-US') : string
@@ -39,11 +39,11 @@ str = arr.toLocaleString('en-US'); // OK
>arr.toLocaleString('en-US') : string
> : ^^^^^^
>arr.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>arr : number[]
> : ^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -55,11 +55,11 @@ str = arr.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }); // OK
>arr.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>arr.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>arr : number[]
> : ^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -95,11 +95,11 @@ str = dates.toLocaleString(); // OK
>dates.toLocaleString() : string
> : ^^^^^^
>dates.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>dates : readonly Date[]
> : ^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = dates.toLocaleString('fr'); // OK
>str = dates.toLocaleString('fr') : string
@@ -109,11 +109,11 @@ str = dates.toLocaleString('fr'); // OK
>dates.toLocaleString('fr') : string
> : ^^^^^^
>dates.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>dates : readonly Date[]
> : ^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'fr' : "fr"
> : ^^^^
@@ -125,11 +125,11 @@ str = dates.toLocaleString('fr', { timeZone: 'UTC' }); // OK
>dates.toLocaleString('fr', { timeZone: 'UTC' }) : string
> : ^^^^^^
>dates.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>dates : readonly Date[]
> : ^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'fr' : "fr"
> : ^^^^
>{ timeZone: 'UTC' } : { timeZone: string; }
@@ -165,11 +165,11 @@ str = mixed.toLocaleString(); // OK
>mixed.toLocaleString() : string
> : ^^^^^^
>mixed.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>mixed : (number | Date)[]
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = mixed.toLocaleString('fr'); // OK
>str = mixed.toLocaleString('fr') : string
@@ -179,11 +179,11 @@ str = mixed.toLocaleString('fr'); // OK
>mixed.toLocaleString('fr') : string
> : ^^^^^^
>mixed.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>mixed : (number | Date)[]
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'fr' : "fr"
> : ^^^^
@@ -195,11 +195,11 @@ str = mixed.toLocaleString('de', { style: 'currency', currency: 'EUR' }); // OK
>mixed.toLocaleString('de', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>mixed.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>mixed : (number | Date)[]
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'de' : "de"
> : ^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -221,7 +221,7 @@ str = (mixed as ReadonlyArray<number | Date>).toLocaleString('de', { currency: '
>(mixed as ReadonlyArray<number | Date>).toLocaleString('de', { currency: 'EUR', style: 'currency', timeZone: 'UTC' }) : string
> : ^^^^^^
>(mixed as ReadonlyArray<number | Date>).toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>(mixed as ReadonlyArray<number | Date>) : readonly (number | Date)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
>mixed as ReadonlyArray<number | Date> : readonly (number | Date)[]
@@ -229,7 +229,7 @@ str = (mixed as ReadonlyArray<number | Date>).toLocaleString('de', { currency: '
>mixed : (number | Date)[]
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'de' : "de"
> : ^^^^
>{ currency: 'EUR', style: 'currency', timeZone: 'UTC' } : { currency: string; style: "currency"; timeZone: string; }
@@ -265,11 +265,11 @@ str = int8Array.toLocaleString(); // OK
>int8Array.toLocaleString() : string
> : ^^^^^^
>int8Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int8Array : Int8Array
> : ^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = int8Array.toLocaleString('en-US'); // OK
>str = int8Array.toLocaleString('en-US') : string
@@ -279,11 +279,11 @@ str = int8Array.toLocaleString('en-US'); // OK
>int8Array.toLocaleString('en-US') : string
> : ^^^^^^
>int8Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int8Array : Int8Array
> : ^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -295,11 +295,11 @@ str = int8Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' });
>int8Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>int8Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int8Array : Int8Array
> : ^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -331,11 +331,11 @@ str = uint8Array.toLocaleString(); // OK
>uint8Array.toLocaleString() : string
> : ^^^^^^
>uint8Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint8Array : Uint8Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = uint8Array.toLocaleString('en-US'); // OK
>str = uint8Array.toLocaleString('en-US') : string
@@ -345,11 +345,11 @@ str = uint8Array.toLocaleString('en-US'); // OK
>uint8Array.toLocaleString('en-US') : string
> : ^^^^^^
>uint8Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint8Array : Uint8Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -361,11 +361,11 @@ str = uint8Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' })
>uint8Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>uint8Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint8Array : Uint8Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -397,11 +397,11 @@ str = uint8ClampedArray.toLocaleString(); // OK
>uint8ClampedArray.toLocaleString() : string
> : ^^^^^^
>uint8ClampedArray.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint8ClampedArray : Uint8ClampedArray
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = uint8ClampedArray.toLocaleString('en-US'); // OK
>str = uint8ClampedArray.toLocaleString('en-US') : string
@@ -411,11 +411,11 @@ str = uint8ClampedArray.toLocaleString('en-US'); // OK
>uint8ClampedArray.toLocaleString('en-US') : string
> : ^^^^^^
>uint8ClampedArray.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint8ClampedArray : Uint8ClampedArray
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -427,11 +427,11 @@ str = uint8ClampedArray.toLocaleString('en-US', { style: 'currency', currency: '
>uint8ClampedArray.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>uint8ClampedArray.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint8ClampedArray : Uint8ClampedArray
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -463,11 +463,11 @@ str = int16Array.toLocaleString(); // OK
>int16Array.toLocaleString() : string
> : ^^^^^^
>int16Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int16Array : Int16Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = int16Array.toLocaleString('en-US'); // OK
>str = int16Array.toLocaleString('en-US') : string
@@ -477,11 +477,11 @@ str = int16Array.toLocaleString('en-US'); // OK
>int16Array.toLocaleString('en-US') : string
> : ^^^^^^
>int16Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int16Array : Int16Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -493,11 +493,11 @@ str = int16Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' })
>int16Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>int16Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int16Array : Int16Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -529,11 +529,11 @@ str = uint16Array.toLocaleString(); // OK
>uint16Array.toLocaleString() : string
> : ^^^^^^
>uint16Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint16Array : Uint16Array
> : ^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = uint16Array.toLocaleString('en-US'); // OK
>str = uint16Array.toLocaleString('en-US') : string
@@ -543,11 +543,11 @@ str = uint16Array.toLocaleString('en-US'); // OK
>uint16Array.toLocaleString('en-US') : string
> : ^^^^^^
>uint16Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint16Array : Uint16Array
> : ^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -559,11 +559,11 @@ str = uint16Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }
>uint16Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>uint16Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint16Array : Uint16Array
> : ^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -595,11 +595,11 @@ str = int32Array.toLocaleString(); // OK
>int32Array.toLocaleString() : string
> : ^^^^^^
>int32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int32Array : Int32Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = int32Array.toLocaleString('en-US'); // OK
>str = int32Array.toLocaleString('en-US') : string
@@ -609,11 +609,11 @@ str = int32Array.toLocaleString('en-US'); // OK
>int32Array.toLocaleString('en-US') : string
> : ^^^^^^
>int32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int32Array : Int32Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -625,11 +625,11 @@ str = int32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' })
>int32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>int32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int32Array : Int32Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -661,11 +661,11 @@ str = uint32Array.toLocaleString(); // OK
>uint32Array.toLocaleString() : string
> : ^^^^^^
>uint32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint32Array : Uint32Array
> : ^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = uint32Array.toLocaleString('en-US'); // OK
>str = uint32Array.toLocaleString('en-US') : string
@@ -675,11 +675,11 @@ str = uint32Array.toLocaleString('en-US'); // OK
>uint32Array.toLocaleString('en-US') : string
> : ^^^^^^
>uint32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint32Array : Uint32Array
> : ^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -691,11 +691,11 @@ str = uint32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }
>uint32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>uint32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint32Array : Uint32Array
> : ^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -727,11 +727,11 @@ str = float32Array.toLocaleString(); // OK
>float32Array.toLocaleString() : string
> : ^^^^^^
>float32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>float32Array : Float32Array
> : ^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = float32Array.toLocaleString('en-US'); // OK
>str = float32Array.toLocaleString('en-US') : string
@@ -741,11 +741,11 @@ str = float32Array.toLocaleString('en-US'); // OK
>float32Array.toLocaleString('en-US') : string
> : ^^^^^^
>float32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>float32Array : Float32Array
> : ^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -757,11 +757,11 @@ str = float32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR'
>float32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>float32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>float32Array : Float32Array
> : ^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -793,11 +793,11 @@ str = float64Array.toLocaleString(); // OK
>float64Array.toLocaleString() : string
> : ^^^^^^
>float64Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>float64Array : Float64Array
> : ^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = float64Array.toLocaleString('en-US'); // OK
>str = float64Array.toLocaleString('en-US') : string
@@ -807,11 +807,11 @@ str = float64Array.toLocaleString('en-US'); // OK
>float64Array.toLocaleString('en-US') : string
> : ^^^^^^
>float64Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>float64Array : Float64Array
> : ^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -823,11 +823,11 @@ str = float64Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR'
>float64Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>float64Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>float64Array : Float64Array
> : ^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
tests/baselines/reference/arrayToLocaleStringES2020.types
+90 -90
View File
@@ -25,11 +25,11 @@ str = arr.toLocaleString(); // OK
>arr.toLocaleString() : string
> : ^^^^^^
>arr.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>arr : number[]
> : ^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = arr.toLocaleString('en-US'); // OK
>str = arr.toLocaleString('en-US') : string
@@ -39,11 +39,11 @@ str = arr.toLocaleString('en-US'); // OK
>arr.toLocaleString('en-US') : string
> : ^^^^^^
>arr.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>arr : number[]
> : ^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -55,11 +55,11 @@ str = arr.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }); // OK
>arr.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>arr.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>arr : number[]
> : ^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -95,11 +95,11 @@ str = dates.toLocaleString(); // OK
>dates.toLocaleString() : string
> : ^^^^^^
>dates.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>dates : readonly Date[]
> : ^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = dates.toLocaleString('fr'); // OK
>str = dates.toLocaleString('fr') : string
@@ -109,11 +109,11 @@ str = dates.toLocaleString('fr'); // OK
>dates.toLocaleString('fr') : string
> : ^^^^^^
>dates.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>dates : readonly Date[]
> : ^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'fr' : "fr"
> : ^^^^
@@ -125,11 +125,11 @@ str = dates.toLocaleString('fr', { timeZone: 'UTC' }); // OK
>dates.toLocaleString('fr', { timeZone: 'UTC' }) : string
> : ^^^^^^
>dates.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>dates : readonly Date[]
> : ^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'fr' : "fr"
> : ^^^^
>{ timeZone: 'UTC' } : { timeZone: string; }
@@ -165,11 +165,11 @@ str = mixed.toLocaleString(); // OK
>mixed.toLocaleString() : string
> : ^^^^^^
>mixed.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>mixed : (number | Date)[]
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = mixed.toLocaleString('de', { style: 'currency', currency: 'EUR' }); // OK
>str = mixed.toLocaleString('de', { style: 'currency', currency: 'EUR' }) : string
@@ -179,11 +179,11 @@ str = mixed.toLocaleString('de', { style: 'currency', currency: 'EUR' }); // OK
>mixed.toLocaleString('de', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>mixed.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>mixed : (number | Date)[]
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'de' : "de"
> : ^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -205,7 +205,7 @@ str = (mixed as ReadonlyArray<number | Date>).toLocaleString('de', { currency: '
>(mixed as ReadonlyArray<number | Date>).toLocaleString('de', { currency: 'EUR', style: 'currency', timeZone: 'UTC' }) : string
> : ^^^^^^
>(mixed as ReadonlyArray<number | Date>).toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>(mixed as ReadonlyArray<number | Date>) : readonly (number | Date)[]
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
>mixed as ReadonlyArray<number | Date> : readonly (number | Date)[]
@@ -213,7 +213,7 @@ str = (mixed as ReadonlyArray<number | Date>).toLocaleString('de', { currency: '
>mixed : (number | Date)[]
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'de' : "de"
> : ^^^^
>{ currency: 'EUR', style: 'currency', timeZone: 'UTC' } : { currency: string; style: "currency"; timeZone: string; }
@@ -263,11 +263,11 @@ str = bigInts.toLocaleString(); // OK
>bigInts.toLocaleString() : string
> : ^^^^^^
>bigInts.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>bigInts : bigint[]
> : ^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = bigInts.toLocaleString('en-US'); // OK
>str = bigInts.toLocaleString('en-US') : string
@@ -277,11 +277,11 @@ str = bigInts.toLocaleString('en-US'); // OK
>bigInts.toLocaleString('en-US') : string
> : ^^^^^^
>bigInts.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>bigInts : bigint[]
> : ^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -293,11 +293,11 @@ str = bigInts.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }); /
>bigInts.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>bigInts.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>bigInts : bigint[]
> : ^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions & Intl.DateTimeFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -329,11 +329,11 @@ str = int8Array.toLocaleString(); // OK
>int8Array.toLocaleString() : string
> : ^^^^^^
>int8Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int8Array : Int8Array
> : ^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = int8Array.toLocaleString('en-US'); // OK
>str = int8Array.toLocaleString('en-US') : string
@@ -343,11 +343,11 @@ str = int8Array.toLocaleString('en-US'); // OK
>int8Array.toLocaleString('en-US') : string
> : ^^^^^^
>int8Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int8Array : Int8Array
> : ^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -359,11 +359,11 @@ str = int8Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' });
>int8Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>int8Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int8Array : Int8Array
> : ^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -395,11 +395,11 @@ str = uint8Array.toLocaleString(); // OK
>uint8Array.toLocaleString() : string
> : ^^^^^^
>uint8Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint8Array : Uint8Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = uint8Array.toLocaleString('en-US'); // OK
>str = uint8Array.toLocaleString('en-US') : string
@@ -409,11 +409,11 @@ str = uint8Array.toLocaleString('en-US'); // OK
>uint8Array.toLocaleString('en-US') : string
> : ^^^^^^
>uint8Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint8Array : Uint8Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -425,11 +425,11 @@ str = uint8Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' })
>uint8Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>uint8Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint8Array : Uint8Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -461,11 +461,11 @@ str = uint8ClampedArray.toLocaleString(); // OK
>uint8ClampedArray.toLocaleString() : string
> : ^^^^^^
>uint8ClampedArray.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint8ClampedArray : Uint8ClampedArray
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = uint8ClampedArray.toLocaleString('en-US'); // OK
>str = uint8ClampedArray.toLocaleString('en-US') : string
@@ -475,11 +475,11 @@ str = uint8ClampedArray.toLocaleString('en-US'); // OK
>uint8ClampedArray.toLocaleString('en-US') : string
> : ^^^^^^
>uint8ClampedArray.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint8ClampedArray : Uint8ClampedArray
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -491,11 +491,11 @@ str = uint8ClampedArray.toLocaleString('en-US', { style: 'currency', currency: '
>uint8ClampedArray.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>uint8ClampedArray.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint8ClampedArray : Uint8ClampedArray
> : ^^^^^^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -527,11 +527,11 @@ str = int16Array.toLocaleString(); // OK
>int16Array.toLocaleString() : string
> : ^^^^^^
>int16Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int16Array : Int16Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = int16Array.toLocaleString('en-US'); // OK
>str = int16Array.toLocaleString('en-US') : string
@@ -541,11 +541,11 @@ str = int16Array.toLocaleString('en-US'); // OK
>int16Array.toLocaleString('en-US') : string
> : ^^^^^^
>int16Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int16Array : Int16Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -557,11 +557,11 @@ str = int16Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' })
>int16Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>int16Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int16Array : Int16Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -593,11 +593,11 @@ str = uint16Array.toLocaleString(); // OK
>uint16Array.toLocaleString() : string
> : ^^^^^^
>uint16Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint16Array : Uint16Array
> : ^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = uint16Array.toLocaleString('en-US'); // OK
>str = uint16Array.toLocaleString('en-US') : string
@@ -607,11 +607,11 @@ str = uint16Array.toLocaleString('en-US'); // OK
>uint16Array.toLocaleString('en-US') : string
> : ^^^^^^
>uint16Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint16Array : Uint16Array
> : ^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -623,11 +623,11 @@ str = uint16Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }
>uint16Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>uint16Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint16Array : Uint16Array
> : ^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -659,11 +659,11 @@ str = int32Array.toLocaleString(); // OK
>int32Array.toLocaleString() : string
> : ^^^^^^
>int32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int32Array : Int32Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = int32Array.toLocaleString('en-US'); // OK
>str = int32Array.toLocaleString('en-US') : string
@@ -673,11 +673,11 @@ str = int32Array.toLocaleString('en-US'); // OK
>int32Array.toLocaleString('en-US') : string
> : ^^^^^^
>int32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int32Array : Int32Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -689,11 +689,11 @@ str = int32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' })
>int32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>int32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>int32Array : Int32Array
> : ^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -725,11 +725,11 @@ str = uint32Array.toLocaleString(); // OK
>uint32Array.toLocaleString() : string
> : ^^^^^^
>uint32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint32Array : Uint32Array
> : ^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = uint32Array.toLocaleString('en-US'); // OK
>str = uint32Array.toLocaleString('en-US') : string
@@ -739,11 +739,11 @@ str = uint32Array.toLocaleString('en-US'); // OK
>uint32Array.toLocaleString('en-US') : string
> : ^^^^^^
>uint32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint32Array : Uint32Array
> : ^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -755,11 +755,11 @@ str = uint32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }
>uint32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>uint32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>uint32Array : Uint32Array
> : ^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -791,11 +791,11 @@ str = float32Array.toLocaleString(); // OK
>float32Array.toLocaleString() : string
> : ^^^^^^
>float32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>float32Array : Float32Array
> : ^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = float32Array.toLocaleString('en-US'); // OK
>str = float32Array.toLocaleString('en-US') : string
@@ -805,11 +805,11 @@ str = float32Array.toLocaleString('en-US'); // OK
>float32Array.toLocaleString('en-US') : string
> : ^^^^^^
>float32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>float32Array : Float32Array
> : ^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -821,11 +821,11 @@ str = float32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR'
>float32Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>float32Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>float32Array : Float32Array
> : ^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -857,11 +857,11 @@ str = float64Array.toLocaleString(); // OK
>float64Array.toLocaleString() : string
> : ^^^^^^
>float64Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>float64Array : Float64Array
> : ^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
str = float64Array.toLocaleString('en-US'); // OK
>str = float64Array.toLocaleString('en-US') : string
@@ -871,11 +871,11 @@ str = float64Array.toLocaleString('en-US'); // OK
>float64Array.toLocaleString('en-US') : string
> : ^^^^^^
>float64Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>float64Array : Float64Array
> : ^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -887,11 +887,11 @@ str = float64Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR'
>float64Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>float64Array.toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>float64Array : Float64Array
> : ^^^^^^^^^^^^
>toLocaleString : { (): string; (locales: string | string[], options?: Intl.NumberFormatOptions): string; }
> : ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -923,11 +923,11 @@ str = bigInt64Array.toLocaleString(); // OK
>bigInt64Array.toLocaleString() : string
> : ^^^^^^
>bigInt64Array.toLocaleString : (locales?: string | string[], options?: Intl.NumberFormatOptions) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
>bigInt64Array : BigInt64Array
> : ^^^^^^^^^^^^^
>toLocaleString : (locales?: string | string[], options?: Intl.NumberFormatOptions) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
str = bigInt64Array.toLocaleString('en-US'); // OK
>str = bigInt64Array.toLocaleString('en-US') : string
@@ -937,11 +937,11 @@ str = bigInt64Array.toLocaleString('en-US'); // OK
>bigInt64Array.toLocaleString('en-US') : string
> : ^^^^^^
>bigInt64Array.toLocaleString : (locales?: string | string[], options?: Intl.NumberFormatOptions) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
>bigInt64Array : BigInt64Array
> : ^^^^^^^^^^^^^
>toLocaleString : (locales?: string | string[], options?: Intl.NumberFormatOptions) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -953,11 +953,11 @@ str = bigInt64Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR'
>bigInt64Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>bigInt64Array.toLocaleString : (locales?: string | string[], options?: Intl.NumberFormatOptions) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
>bigInt64Array : BigInt64Array
> : ^^^^^^^^^^^^^
>toLocaleString : (locales?: string | string[], options?: Intl.NumberFormatOptions) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
@@ -989,11 +989,11 @@ str = bigIntUint64Array.toLocaleString(); // OK
>bigIntUint64Array.toLocaleString() : string
> : ^^^^^^
>bigIntUint64Array.toLocaleString : (locales?: string | string[], options?: Intl.NumberFormatOptions) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
>bigIntUint64Array : BigUint64Array
> : ^^^^^^^^^^^^^^
>toLocaleString : (locales?: string | string[], options?: Intl.NumberFormatOptions) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
str = bigIntUint64Array.toLocaleString('en-US'); // OK
>str = bigIntUint64Array.toLocaleString('en-US') : string
@@ -1003,11 +1003,11 @@ str = bigIntUint64Array.toLocaleString('en-US'); // OK
>bigIntUint64Array.toLocaleString('en-US') : string
> : ^^^^^^
>bigIntUint64Array.toLocaleString : (locales?: string | string[], options?: Intl.NumberFormatOptions) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
>bigIntUint64Array : BigUint64Array
> : ^^^^^^^^^^^^^^
>toLocaleString : (locales?: string | string[], options?: Intl.NumberFormatOptions) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
@@ -1019,11 +1019,11 @@ str = bigIntUint64Array.toLocaleString('en-US', { style: 'currency', currency: '
>bigIntUint64Array.toLocaleString('en-US', { style: 'currency', currency: 'EUR' }) : string
> : ^^^^^^
>bigIntUint64Array.toLocaleString : (locales?: string | string[], options?: Intl.NumberFormatOptions) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
>bigIntUint64Array : BigUint64Array
> : ^^^^^^^^^^^^^^
>toLocaleString : (locales?: string | string[], options?: Intl.NumberFormatOptions) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^ ^^^ ^^^^^^^^^^^
>'en-US' : "en-US"
> : ^^^^^^^
>{ style: 'currency', currency: 'EUR' } : { style: "currency"; currency: string; }
tests/baselines/reference/arrowFunctionContexts.types
+10 -10
View File
@@ -49,11 +49,11 @@ window.setTimeout(() => null, 100);
>window.setTimeout(() => null, 100) : number
> : ^^^^^^
>window.setTimeout : ((handler: TimerHandler, timeout?: number, ...arguments: any[]) => number) & ((handler: TimerHandler, timeout?: number, ...arguments: any[]) => number)
> : ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^ ^^ ^^ ^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^ ^^ ^^^^^^^^^^^^
>window : Window & typeof globalThis
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
>setTimeout : ((handler: TimerHandler, timeout?: number, ...arguments: any[]) => number) & ((handler: TimerHandler, timeout?: number, ...arguments: any[]) => number)
> : ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^ ^^ ^^ ^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^ ^^ ^^^^^^^^^^^^
>() => null : () => any
> : ^^^^^^^^^
>100 : 100
@@ -73,7 +73,7 @@ var obj = (n: number) => '';
var obj: { (n: number): string; }; // OK
>obj : (n: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>n : number
> : ^^^^^^
@@ -91,7 +91,7 @@ var arr = [(n: number) => ''];
var arr: { (n: number): string; }[]; // Incorrect error here (bug 829597)
>arr : ((n: number) => string)[]
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^ ^^ ^^^^^^^^^^^^^^
>n : number
> : ^^^^^^
@@ -202,11 +202,11 @@ module M2 {
>window.setTimeout(() => null, 100) : number
> : ^^^^^^
>window.setTimeout : ((handler: TimerHandler, timeout?: number, ...arguments: any[]) => number) & ((handler: TimerHandler, timeout?: number, ...arguments: any[]) => number)
> : ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^ ^^ ^^ ^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^ ^^ ^^^^^^^^^^^^
>window : Window & typeof globalThis
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^
>setTimeout : ((handler: TimerHandler, timeout?: number, ...arguments: any[]) => number) & ((handler: TimerHandler, timeout?: number, ...arguments: any[]) => number)
> : ^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^ ^^ ^^ ^^^ ^^^^^ ^^ ^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^^^ ^^ ^^^^^^^^^^^^
>() => null : () => any
> : ^^^^^^^^^
>100 : 100
@@ -226,7 +226,7 @@ module M2 {
var obj: { (n: number): string; }; // OK
>obj : (n: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>n : number
> : ^^^^^^
@@ -244,7 +244,7 @@ module M2 {
var arr: { (n: number): string; }[]; // Incorrect error here (bug 829597)
>arr : ((n: number) => string)[]
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^^ ^^ ^^^^^^^^^^^^^^
>n : number
> : ^^^^^^
@@ -319,7 +319,7 @@ var generic1 = <T>(n: T) => [n];
var generic1: { <T>(n: T): T[] }; // Incorrect error, Bug 829597
>generic1 : <T>(n: T) => T[]
> : ^^^^ ^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^
>n : T
> : ^
@@ -337,7 +337,7 @@ var generic2 = <T>(n: T) => { return [n]; };
var generic2: { <T>(n: T): T[] };
>generic2 : <T>(n: T) => T[]
> : ^^^^ ^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^
>n : T
> : ^
tests/baselines/reference/arrowFunctionErrorSpan.types
+10 -10
View File
@@ -12,7 +12,7 @@ f(() => { });
>f(() => { }) : void
> : ^^^^
>f : (a: () => number) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>() => { } : () => void
> : ^^^^^^^^^^
@@ -21,7 +21,7 @@ f(() => {
>f(() => {}) : void
> : ^^^^
>f : (a: () => number) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>() => {} : () => void
> : ^^^^^^^^^^
@@ -32,7 +32,7 @@ f(() => {
>f(() => {}) : void
> : ^^^^
>f : (a: () => number) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>() => {} : () => void
> : ^^^^^^^^^^
@@ -43,7 +43,7 @@ f(()
>f(() => { }) : void
> : ^^^^
>f : (a: () => number) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>() => { } : () => void
> : ^^^^^^^^^^
@@ -54,7 +54,7 @@ f((a,
>f((a, b, c, d) => { }) : void
> : ^^^^
>f : (a: () => number) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>(a, b, c, d) => { } : (a: any, b: any, c: any, d: any) => void
> : ^ ^^^^^^^ ^^^^^^^ ^^^^^^^ ^^^^^^^^^^^^^^
>a : any
@@ -77,7 +77,7 @@ f(/*
>f(/* */() => { }) : void
> : ^^^^
>f : (a: () => number) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
*/() => { });
>() => { } : () => void
@@ -88,7 +88,7 @@ f(/*
>f(/* */() => { }) : void
> : ^^^^
>f : (a: () => number) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
*/() => { });
>() => { } : () => void
@@ -99,7 +99,7 @@ f(/*
>f(/* */() => { }) : void
> : ^^^^
>f : (a: () => number) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
*/() => {
>() => { } : () => void
@@ -112,7 +112,7 @@ f( // comment 1
>f( // comment 1 // comment 2 () => // comment 3 { // comment 4 } // comment 5) : void
> : ^^^^
>f : (a: () => number) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
// comment 2
() =>
@@ -131,7 +131,7 @@ f(_ => 1 +
>f(_ => 1 + 2) : void
> : ^^^^
>f : (a: () => number) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>_ => 1 + 2 : (_: any) => number
> : ^ ^^^^^^^^^^^^^^^^
>_ : any
tests/baselines/reference/arrowFunctionExpressions.types
+19 -19
View File
@@ -18,7 +18,7 @@ var a = (p: string) => p.length;
var a = (p: string) => { return p.length; }
>a : (p: string) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>(p: string) => { return p.length; } : (p: string) => number
> : ^ ^^ ^^^^^^^^^^^
>p : string
@@ -271,13 +271,13 @@ var e = arrrr()(3)()(4);
>arrrr()(3)()(4) : number
> : ^^^^^^
>arrrr()(3)() : (n: number) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>arrrr()(3) : () => (n: number) => number
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^ ^^ ^^^^^^^^^^^
>arrrr() : (m: number) => () => (n: number) => number
> : ^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^
>arrrr : () => (m: number) => () => (n: number) => number
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^^^^^^^^^
>3 : 3
> : ^
>4 : 4
@@ -314,19 +314,19 @@ function someFn() {
>arr(3)(4).toExponential() : string
> : ^^^^^^
>arr(3)(4).toExponential : (fractionDigits?: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^
>arr(3)(4) : number
> : ^^^^^^
>arr(3) : (p: number) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>arr : (n: number) => (p: number) => number
> : ^ ^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^ ^^ ^^^^^^^^^^^
>3 : 3
> : ^
>4 : 4
> : ^
>toExponential : (fractionDigits?: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^
}
// Arrow function used in function
@@ -352,15 +352,15 @@ function someOtherFn() {
>arr(4).charAt(0) : string
> : ^^^^^^
>arr(4).charAt : (pos: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>arr(4) : string
> : ^^^^^^
>arr : (n: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>4 : 4
> : ^
>charAt : (pos: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>0 : 0
> : ^
}
@@ -423,7 +423,7 @@ var f = (n: string) => {
>fn(4) : () => string
> : ^^^^^^^^^^^^
>fn : (x: number) => () => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^
>4 : 4
> : ^
}
@@ -435,7 +435,7 @@ var g = f('')();
>f('') : () => string
> : ^^^^^^^^^^^^
>f : (n: string) => () => string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^
>'' : ""
> : ^^
@@ -477,7 +477,7 @@ function someOuterFn() {
}
return arr;
>arr : (n: string) => () => () => number
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
}
var h = someOuterFn()('')()();
>h : number
@@ -489,9 +489,9 @@ var h = someOuterFn()('')()();
>someOuterFn()('') : () => () => number
> : ^^^^^^^^^^^^^^^^^^
>someOuterFn() : (n: string) => () => () => number
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>someOuterFn : () => (n: string) => () => () => number
> : ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>'' : ""
> : ^^
@@ -499,11 +499,11 @@ h.toExponential();
>h.toExponential() : string
> : ^^^^^^
>h.toExponential : (fractionDigits?: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^
>h : number
> : ^^^^^^
>toExponential : (fractionDigits?: number) => string
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^^ ^^^^^^^^^^^
// Arrow function used in try/catch/finally in function
function tryCatchFn() {
tests/baselines/reference/arrowFunctionJSDocAnnotation.types
+1 -1
View File
@@ -17,7 +17,7 @@ const x = identity(
>x : any
>identity( /** * @param {number} param * @returns {number=} */ param => param) : any
>identity : (v: any) => any
> : ^ ^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^
/**
* @param {number} param
tests/baselines/reference/asOperator3.types
+2 -2
View File
@@ -88,7 +88,7 @@ var g = tag `Hello ${123} World` as string;
> : ^^^^^^
>tag `Hello ${123} World` : any
>tag : (...x: any[]) => any
> : ^^^^ ^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^
>`Hello ${123} World` : string
> : ^^^^^^
>123 : 123
@@ -101,7 +101,7 @@ var h = tag `Hello` as string;
> : ^^^^^^
>tag `Hello` : any
>tag : (...x: any[]) => any
> : ^^^^ ^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^
>`Hello` : "Hello"
> : ^^^^^^^
tests/baselines/reference/asOperatorASI.types
+2 -2
View File
@@ -21,7 +21,7 @@ var x = 10
as `Hello world`; // should not error
>as `Hello world` : any
>as : (...args: any[]) => any
> : ^^^^ ^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^
>`Hello world` : "Hello world"
> : ^^^^^^^^^^^^^
@@ -35,7 +35,7 @@ var y = 20
as(Foo); // should emit
>as(Foo) : any
>as : (...args: any[]) => any
> : ^^^^ ^^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^
>Foo : typeof Foo
> : ^^^^^^^^^^
tests/baselines/reference/assertionFunctionWildcardImport1.types
+8 -8
View File
@@ -30,7 +30,7 @@ ts.Debug.assert(true);
>ts.Debug.assert(true) : void
> : ^^^^
>ts.Debug.assert : (expression: unknown) => asserts expression
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>ts.Debug : typeof ts.Debug
> : ^^^^^^^^^^^^^^^
>ts : typeof ts
@@ -38,7 +38,7 @@ ts.Debug.assert(true);
>Debug : typeof ts.Debug
> : ^^^^^^^^^^^^^^^
>assert : (expression: unknown) => asserts expression
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>true : true
> : ^^^^
@@ -46,11 +46,11 @@ Debug.assert(true);
>Debug.assert(true) : void
> : ^^^^
>Debug.assert : (expression: unknown) => asserts expression
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>Debug : typeof ts.Debug
> : ^^^^^^^^^^^^^^^
>assert : (expression: unknown) => asserts expression
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>true : true
> : ^^^^
@@ -73,7 +73,7 @@ ts.Debug.assert(true);
>ts.Debug.assert(true) : void
> : ^^^^
>ts.Debug.assert : (expression: unknown) => asserts expression
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>ts.Debug : typeof ts.Debug
> : ^^^^^^^^^^^^^^^
>ts : typeof ts
@@ -81,7 +81,7 @@ ts.Debug.assert(true);
>Debug : typeof ts.Debug
> : ^^^^^^^^^^^^^^^
>assert : (expression: unknown) => asserts expression
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>true : true
> : ^^^^
@@ -89,11 +89,11 @@ Debug.assert(true);
>Debug.assert(true) : void
> : ^^^^
>Debug.assert : (expression: unknown) => asserts expression
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>Debug : typeof ts.Debug
> : ^^^^^^^^^^^^^^^
>assert : (expression: unknown) => asserts expression
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>true : true
> : ^^^^
tests/baselines/reference/assertionFunctionWildcardImport2.types
+3 -3
View File
@@ -34,7 +34,7 @@ function isNonNullable<T>(obj: T): asserts obj is NonNullable<T> {
export {
isNonNullable
>isNonNullable : <T>(obj: T) => asserts obj is NonNullable<T>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
};
@@ -53,11 +53,11 @@ function test(obj: string | null): void {
>asserts.isNonNullable(obj) : void
> : ^^^^
>asserts.isNonNullable : <T>(obj: T) => asserts obj is NonNullable<T>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>asserts : typeof asserts
> : ^^^^^^^^^^^^^^
>isNonNullable : <T>(obj: T) => asserts obj is NonNullable<T>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>obj : string | null
> : ^^^^^^^^^^^^^
tests/baselines/reference/assertionFunctionsCanNarrowByDiscriminant.types
+2 -2
View File
@@ -56,7 +56,7 @@ assertEqual(animal.type, 'cat' as const);
>assertEqual(animal.type, 'cat' as const) : void
> : ^^^^
>assertEqual : <T>(value: any, type: T) => asserts value is T
> : ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>animal.type : "cat" | "dog"
> : ^^^^^^^^^^^^^
>animal : Animal
@@ -96,7 +96,7 @@ assertEqual(animalOrUndef?.type, 'cat' as const);
>assertEqual(animalOrUndef?.type, 'cat' as const) : void
> : ^^^^
>assertEqual : <T>(value: any, type: T) => asserts value is T
> : ^^^^ ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^
>animalOrUndef?.type : "cat" | "dog" | undefined
> : ^^^^^^^^^^^^^^^^^^^^^^^^^
>animalOrUndef : Animal | undefined
tests/baselines/reference/assertionTypePredicates1.types
+50 -50
View File
@@ -59,7 +59,7 @@ function f01(x: unknown) {
>assert(typeof x === "string") : void
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>typeof x === "string" : boolean
> : ^^^^^^^
>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
@@ -89,7 +89,7 @@ function f01(x: unknown) {
>assert(x instanceof Error) : void
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>x instanceof Error : boolean
> : ^^^^^^^
>x : unknown
@@ -117,7 +117,7 @@ function f01(x: unknown) {
>assert(typeof x === "boolean" || typeof x === "number") : void
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>typeof x === "boolean" || typeof x === "number" : boolean
> : ^^^^^^^
>typeof x === "boolean" : boolean
@@ -138,12 +138,12 @@ function f01(x: unknown) {
> : ^^^^^^^^
x.toLocaleString;
>x.toLocaleString : ((locales?: string | string[] | undefined, options?: Intl.NumberFormatOptions | undefined) => string) | (() => string)
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x.toLocaleString : ((locales?: string | string[], options?: Intl.NumberFormatOptions) => string) | (() => string)
> : ^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : number | boolean
> : ^^^^^^^^^^^^^^^^
>toLocaleString : ((locales?: string | string[] | undefined, options?: Intl.NumberFormatOptions | undefined) => string) | (() => string)
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>toLocaleString : ((locales?: string | string[], options?: Intl.NumberFormatOptions) => string) | (() => string)
> : ^^ ^^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
}
if (!!true) {
>!!true : true
@@ -157,11 +157,11 @@ function f01(x: unknown) {
>assert(isArrayOfStrings(x)) : void
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>isArrayOfStrings(x) : boolean
> : ^^^^^^^
>isArrayOfStrings : (value: unknown) => value is string[]
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^
>x : unknown
> : ^^^^^^^
@@ -189,7 +189,7 @@ function f01(x: unknown) {
>assertIsArrayOfStrings(x) : void
> : ^^^^
>assertIsArrayOfStrings : (value: unknown) => asserts value is string[]
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : unknown
> : ^^^^^^^
@@ -217,7 +217,7 @@ function f01(x: unknown) {
>assertIsArrayOfStrings(false) : void
> : ^^^^
>assertIsArrayOfStrings : (value: unknown) => asserts value is string[]
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>false : false
> : ^^^^^
@@ -237,7 +237,7 @@ function f01(x: unknown) {
>assert(x === undefined || typeof x === "string") : void
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>x === undefined || typeof x === "string" : boolean
> : ^^^^^^^
>x === undefined : boolean
@@ -263,7 +263,7 @@ function f01(x: unknown) {
>assertDefined(x) : void
> : ^^^^
>assertDefined : <T>(value: T) => asserts value is NonNullable<T>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : string | undefined
> : ^^^^^^^^^^^^^^^^^^
@@ -283,7 +283,7 @@ function f01(x: unknown) {
>assert(false) : void
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>false : false
> : ^^^^^
@@ -303,7 +303,7 @@ function f01(x: unknown) {
>assert(false && x === undefined) : void
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>false && x === undefined : false
> : ^^^^^
>false : false
@@ -339,7 +339,7 @@ function f02(x: string | undefined) {
>assert(x) : void
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>x : string | undefined
> : ^^^^^^^^^^^^^^^^^^
@@ -363,7 +363,7 @@ function f02(x: string | undefined) {
>assert(x !== undefined) : void
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>x !== undefined : boolean
> : ^^^^^^^
>x : string | undefined
@@ -391,7 +391,7 @@ function f02(x: string | undefined) {
>assertDefined(x) : void
> : ^^^^
>assertDefined : <T>(value: T) => asserts value is NonNullable<T>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : string | undefined
> : ^^^^^^^^^^^^^^^^^^
@@ -419,7 +419,7 @@ function f03(x: string | undefined, assert: (value: unknown) => asserts value) {
>assert(x) : void
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>x : string | undefined
> : ^^^^^^^^^^^^^^^^^^
@@ -468,12 +468,12 @@ function f10(x: string | undefined) {
Debug.assert(x);
>Debug.assert(x) : void
> : ^^^^
>Debug.assert : (value: unknown, message?: string | undefined) => asserts value
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Debug.assert : (value: unknown, message?: string) => asserts value
> : ^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^
>Debug : typeof Debug
> : ^^^^^^^^^^^^
>assert : (value: unknown, message?: string | undefined) => asserts value
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>assert : (value: unknown, message?: string) => asserts value
> : ^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^
>x : string | undefined
> : ^^^^^^^^^^^^^^^^^^
@@ -496,12 +496,12 @@ function f10(x: string | undefined) {
Debug.assert(x !== undefined);
>Debug.assert(x !== undefined) : void
> : ^^^^
>Debug.assert : (value: unknown, message?: string | undefined) => asserts value
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Debug.assert : (value: unknown, message?: string) => asserts value
> : ^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^
>Debug : typeof Debug
> : ^^^^^^^^^^^^
>assert : (value: unknown, message?: string | undefined) => asserts value
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>assert : (value: unknown, message?: string) => asserts value
> : ^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^
>x !== undefined : boolean
> : ^^^^^^^
>x : string | undefined
@@ -529,11 +529,11 @@ function f10(x: string | undefined) {
>Debug.assertDefined(x) : void
> : ^^^^
>Debug.assertDefined : <T>(value: T) => asserts value is NonNullable<T>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Debug : typeof Debug
> : ^^^^^^^^^^^^
>assertDefined : <T>(value: T) => asserts value is NonNullable<T>
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>x : string | undefined
> : ^^^^^^^^^^^^^^^^^^
@@ -556,12 +556,12 @@ function f10(x: string | undefined) {
Debug.assert(false);
>Debug.assert(false) : void
> : ^^^^
>Debug.assert : (value: unknown, message?: string | undefined) => asserts value
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Debug.assert : (value: unknown, message?: string) => asserts value
> : ^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^
>Debug : typeof Debug
> : ^^^^^^^^^^^^
>assert : (value: unknown, message?: string | undefined) => asserts value
> : ^ ^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>assert : (value: unknown, message?: string) => asserts value
> : ^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^^^^^
>false : false
> : ^^^^^
@@ -665,11 +665,11 @@ class Test {
>this.assert(typeof x === "string") : void
> : ^^^^
>this.assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>this : this
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>typeof x === "string" : boolean
> : ^^^^^^^
>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
@@ -733,11 +733,11 @@ class Test {
>this.assert(false) : void
> : ^^^^
>this.assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>this : this
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>false : false
> : ^^^^^
@@ -776,11 +776,11 @@ class Derived extends Test {
>super.assert(typeof x === "string") : void
> : ^^^^
>super.assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>super : Test
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>typeof x === "string" : boolean
> : ^^^^^^^
>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
@@ -808,11 +808,11 @@ class Derived extends Test {
>super.assert(false) : void
> : ^^^^
>super.assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>super : Test
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>false : false
> : ^^^^^
@@ -935,7 +935,7 @@ function f20(x: unknown) {
>assert(typeof x === "string") : void
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>typeof x === "string" : boolean
> : ^^^^^^^
>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
@@ -947,19 +947,19 @@ function f20(x: unknown) {
const a = [assert];
>a : ((value: unknown) => asserts value)[]
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^
>[assert] : ((value: unknown) => asserts value)[]
> : ^ ^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
a[0](typeof x === "string"); // Error
>a[0](typeof x === "string") : void
> : ^^^^
>a[0] : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>a : ((value: unknown) => asserts value)[]
> : ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^ ^^ ^^^^^^^^^^^^^^^^^^^^^
>0 : 0
> : ^
>typeof x === "string" : boolean
@@ -983,11 +983,11 @@ function f20(x: unknown) {
>t1.assert(typeof x === "string") : void
> : ^^^^
>t1.assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>t1 : Test
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>typeof x === "string" : boolean
> : ^^^^^^^
>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
@@ -1009,11 +1009,11 @@ function f20(x: unknown) {
>t2.assert(typeof x === "string") : void
> : ^^^^
>t2.assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>t2 : Test
> : ^^^^
>assert : (value: unknown) => asserts value
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>typeof x === "string" : boolean
> : ^^^^^^^
>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
tests/baselines/reference/assertionTypePredicates2.types
+1 -1
View File
@@ -66,7 +66,7 @@ export const main = () => {
>foo(a) : void
> : ^^^^
>foo : (a: A) => asserts a is B
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^
>a : A
> : ^
tests/baselines/reference/assertionsAndNonReturningFunctions.types
+2 -2
View File
@@ -135,7 +135,7 @@ function f1(x) {
>assert2(typeof x === "string") : void
> : ^^^^
>assert2 : (check: boolean) => asserts check
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^
>typeof x === "string" : boolean
> : ^^^^^^^
>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
@@ -165,7 +165,7 @@ function f1(x) {
>assertIsString(x) : void
> : ^^^^
>assertIsString : (x: unknown) => asserts x is string
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^
>x : any
> : ^^^
tests/baselines/reference/assignFromStringInterface2.types
+10 -10
View File
@@ -58,19 +58,19 @@ interface NotString {
match(regexp: string): RegExpMatchArray;
>match : { (regexp: string): RegExpMatchArray; (regexp: RegExp): RegExpMatchArray; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^
>regexp : string
> : ^^^^^^
match(regexp: RegExp): RegExpMatchArray;
>match : { (regexp: string): RegExpMatchArray; (regexp: RegExp): RegExpMatchArray; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
>regexp : RegExp
> : ^^^^^^
replace(searchValue: string, replaceValue: string): string;
>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
> : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>searchValue : string
> : ^^^^^^
>replaceValue : string
@@ -78,7 +78,7 @@ interface NotString {
replace(searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string;
>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>searchValue : string
> : ^^^^^^
>replaceValue : (substring: string, ...args: any[]) => string
@@ -90,7 +90,7 @@ interface NotString {
replace(searchValue: RegExp, replaceValue: string): string;
>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^
>searchValue : RegExp
> : ^^^^^^
>replaceValue : string
@@ -98,7 +98,7 @@ interface NotString {
replace(searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string;
>replace : { (searchValue: string, replaceValue: string): string; (searchValue: string, replaceValue: (substring: string, ...args: any[]) => string): string; (searchValue: RegExp, replaceValue: string): string; (searchValue: RegExp, replaceValue: (substring: string, ...args: any[]) => string): string; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^ ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^^^^ ^^ ^^ ^^ ^^^ ^^^
>searchValue : RegExp
> : ^^^^^^
>replaceValue : (substring: string, ...args: any[]) => string
@@ -110,13 +110,13 @@ interface NotString {
search(regexp: string): number;
>search : { (regexp: string): number; (regexp: RegExp): number; }
> : ^^^ ^^ ^^^ ^^^ ^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^^ ^^^ ^^ ^^^^^^^^^^^^
>regexp : string
> : ^^^^^^
search(regexp: RegExp): number;
>search : { (regexp: string): number; (regexp: RegExp): number; }
> : ^^^ ^^^^^^^^^^^^^^^^^^^^ ^^ ^^^ ^^^
> : ^^^ ^^ ^^^^^^^^^^^^ ^^ ^^^ ^^^
>regexp : RegExp
> : ^^^^^^
@@ -130,7 +130,7 @@ interface NotString {
split(separator: string, limit?: number): string[];
>split : { (separator: string, limit?: number): string[]; (separator: RegExp, limit?: number): string[]; }
> : ^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^
> : ^^^ ^^ ^^ ^^^ ^^^ ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^
>separator : string
> : ^^^^^^
>limit : number
@@ -138,7 +138,7 @@ interface NotString {
split(separator: RegExp, limit?: number): string[];
>split : { (separator: string, limit?: number): string[]; (separator: RegExp, limit?: number): string[]; }
> : ^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^
> : ^^^ ^^ ^^ ^^^ ^^^^^^^^^^^^^^ ^^ ^^ ^^^ ^^^ ^^^
>separator : RegExp
> : ^^^^^^
>limit : number
tests/baselines/reference/assignLambdaToNominalSubtypeOfFunction.types
+2 -2
View File
@@ -17,7 +17,7 @@ fn((a, b) => true);
>fn((a, b) => true) : void
> : ^^^^
>fn : (cb: IResultCallback) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>(a, b) => true : (a: any, b: any) => boolean
> : ^ ^^^^^^^ ^^^^^^^^^^^^^^^^^
>a : any
@@ -31,7 +31,7 @@ fn(function (a, b) { return true; })
>fn(function (a, b) { return true; }) : void
> : ^^^^
>fn : (cb: IResultCallback) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>function (a, b) { return true; } : (a: any, b: any) => boolean
> : ^ ^^^^^^^ ^^^^^^^^^^^^^^^^^
>a : any
tests/baselines/reference/assignToFn.types
+2 -2
View File
@@ -31,11 +31,11 @@ module M {
>x.f="hello" : "hello"
> : ^^^^^^^
>x.f : (n: number) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^
>x : I
> : ^
>f : (n: number) => boolean
> : ^ ^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^^
>"hello" : "hello"
> : ^^^^^^^
}
tests/baselines/reference/assignToPrototype1.types
+2 -2
View File
@@ -18,7 +18,7 @@ Point.prototype.add = function(dx, dy) {
>Point.prototype.add = function(dx, dy) {} : (dx: number, dy: number) => void
> : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
>Point.prototype.add : (dx: number, dy: number) => void
> : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^^^^^^^^
>Point.prototype : Point
> : ^^^^^
>Point : typeof Point
@@ -26,7 +26,7 @@ Point.prototype.add = function(dx, dy) {
>prototype : Point
> : ^^^^^
>add : (dx: number, dy: number) => void
> : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^ ^^ ^^^^^^^^^
>function(dx, dy) {} : (dx: number, dy: number) => void
> : ^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^
>dx : number
tests/baselines/reference/assigningFromObjectToAnythingElse.types
+8 -8
View File
@@ -22,12 +22,12 @@ var a: String = Object.create<Object>("");
> : ^^^^^^
>Object.create<Object>("") : any
> : ^^^
>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap & ThisType<any>): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Object.create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any; }
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^
>Object : ObjectConstructor
> : ^^^^^^^^^^^^^^^^^
>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap & ThisType<any>): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any; }
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^
>"" : ""
> : ^^
@@ -36,12 +36,12 @@ var c: String = Object.create<Number>(1);
> : ^^^^^^
>Object.create<Number>(1) : any
> : ^^^
>Object.create : { (o: object): any; (o: object, properties: PropertyDescriptorMap & ThisType<any>): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>Object.create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any; }
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^
>Object : ObjectConstructor
> : ^^^^^^^^^^^^^^^^^
>create : { (o: object): any; (o: object, properties: PropertyDescriptorMap & ThisType<any>): any; }
> : ^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>create : { (o: object | null): any; (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any; }
> : ^^^ ^^ ^^^^^^^^^ ^^ ^^ ^^ ^^^^^^^^^
>1 : 1
> : ^
tests/baselines/reference/assignmentCompatBug2.types
+5 -5
View File
@@ -65,7 +65,7 @@ b3 = {
>b3 = { f: (n) => { return 0; }, g: (s) => { return 0; }, m: 0,} : { f: (n: number) => number; g: (s: string) => number; m: number; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^
>{ f: (n) => { return 0; }, g: (s) => { return 0; }, m: 0,} : { f: (n: number) => number; g: (s: string) => number; m: number; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -101,7 +101,7 @@ b3 = {
>b3 = { f: (n) => { return 0; }, g: (s) => { return 0; },} : { f: (n: number) => number; g: (s: string) => number; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
>b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^
>{ f: (n) => { return 0; }, g: (s) => { return 0; },} : { f: (n: number) => number; g: (s: string) => number; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^
@@ -131,7 +131,7 @@ b3 = {
>b3 = { f: (n) => { return 0; }, m: 0,} : { f: (n: number) => number; m: number; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^
>{ f: (n) => { return 0; }, m: 0,} : { f: (n: number) => number; m: number; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ b3 = {
>b3 = { f: (n) => { return 0; }, g: (s) => { return 0; }, m: 0, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; m: number; n: number; k: (a: any) => any; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
>b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^
>{ f: (n) => { return 0; }, g: (s) => { return 0; }, m: 0, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; m: number; n: number; k: (a: any) => any; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
@@ -207,7 +207,7 @@ b3 = {
>b3 = { f: (n) => { return 0; }, g: (s) => { return 0; }, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => any; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
>b3 : { f(n: number): number; g(s: string): number; m: number; n?: number; k?(a: any): any; }
> : ^^^^ ^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^
> : ^^^^ ^^ ^^^^^^^^^^^^^ ^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^ ^^^^^^^^^
>{ f: (n) => { return 0; }, g: (s) => { return 0; }, n: 0, k: (a) =>{ return null; },} : { f: (n: number) => number; g: (s: string) => number; n: number; k: (a: any) => any; }
> : ^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^
tests/baselines/reference/assignmentCompatBug3.types
+4 -4
View File
@@ -37,11 +37,11 @@ function makePoint(x: number, y: number) {
>Math.sqrt(x*x+y*y) : number
> : ^^^^^^
>Math.sqrt : (x: number) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>Math : Math
> : ^^^^
>sqrt : (x: number) => number
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^^^
>x*x+y*y : number
> : ^^^^^^
>x*x : number
@@ -90,14 +90,14 @@ foo(x);
>foo(x) : void
> : ^^^^
>foo : (test: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>x : any
foo(x + y);
>foo(x + y) : void
> : ^^^^
>foo : (test: string) => void
> : ^ ^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>x + y : any
>x : any
>y : any
tests/baselines/reference/assignmentCompatBug5.types
+4 -4
View File
@@ -13,7 +13,7 @@ foo1({ b: 5 });
>foo1({ b: 5 }) : void
> : ^^^^
>foo1 : (x: { a: number; }) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>{ b: 5 } : { b: number; }
> : ^^^^^^^^^^^^^^
>b : number
@@ -31,7 +31,7 @@ foo2(["s", "t"]);
>foo2(["s", "t"]) : void
> : ^^^^
>foo2 : (x: number[]) => void
> : ^ ^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>["s", "t"] : string[]
> : ^^^^^^^^
>"s" : "s"
@@ -51,7 +51,7 @@ foo3((s:string) => { });
>foo3((s:string) => { }) : void
> : ^^^^
>foo3 : (x: (n: number) => number) => void
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>(s:string) => { } : (s: string) => void
> : ^ ^^ ^^^^^^^^^
>s : string
@@ -61,7 +61,7 @@ foo3((n) => { return; });
>foo3((n) => { return; }) : void
> : ^^^^
>foo3 : (x: (n: number) => number) => void
> : ^ ^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>(n) => { return; } : (n: number) => void
> : ^ ^^^^^^^^^^^^^^^^^
>n : number
tests/baselines/reference/assignmentCompatFunctionsWithOptionalArgs.types
+4 -4
View File
@@ -15,7 +15,7 @@ foo({ id: 1234 }); // Ok
>foo({ id: 1234 }) : void
> : ^^^^
>foo : (x: { id: number; name?: string; }) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>{ id: 1234 } : { id: number; }
> : ^^^^^^^^^^^^^^^
>id : number
@@ -27,7 +27,7 @@ foo({ id: 1234, name: "hello" }); // Ok
>foo({ id: 1234, name: "hello" }) : void
> : ^^^^
>foo : (x: { id: number; name?: string; }) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>{ id: 1234, name: "hello" } : { id: number; name: string; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>id : number
@@ -43,7 +43,7 @@ foo({ id: 1234, name: false }); // Error, name of wrong type
>foo({ id: 1234, name: false }) : void
> : ^^^^
>foo : (x: { id: number; name?: string; }) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>{ id: 1234, name: false } : { id: number; name: boolean; }
> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
>id : number
@@ -59,7 +59,7 @@ foo({ name: "hello" }); // Error, id required but missing
>foo({ name: "hello" }) : void
> : ^^^^
>foo : (x: { id: number; name?: string; }) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>{ name: "hello" } : { name: string; }
> : ^^^^^^^^^^^^^^^^^
>name : string
tests/baselines/reference/assignmentCompatInterfaceWithStringIndexSignature.types
+1 -1
View File
@@ -32,7 +32,7 @@ Biz(new Foo());
>Biz(new Foo()) : void
> : ^^^^
>Biz : (map: IHandlerMap) => void
> : ^ ^^^^^^^^^^^^^^^^^^^^^^
> : ^ ^^ ^^^^^^^^^
>new Foo() : Foo
> : ^^^
>Foo : typeof Foo

Some files were not shown because too many files have changed in this diff Show More