ScriptKind,

ScriptTarget,

SetAccessorDeclaration,

setEmitFlags,

setIdentifierTypeArguments,

setNodeFlags,

VariableLikeDeclaration,

VariableStatement,

VarianceFlags,

visitNode,

visitNodes,

Visitor,

function markAsSynthetic<T extends Node>(node: T): VisitResult<T> {

setTextRangePosEnd(node, -1, -1);

}

function getEmitResolver(sourceFile: SourceFile, cancellationToken: CancellationToken, skipDiagnostics?: boolean) {

* 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).

* 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 (range === location) return range;

if (!location) {

return range;

}

if (!context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(getOriginalNode(location))) {

}

return setTextRangeWorker(setOriginalNode(range, location), location);

}

if (!nodeIsSynthesized(node) && getParseTreeNode(node) === node) {

return node;

}

}

function deepCloneOrReuseNodes(

const getterSignature = getSignatureFromDeclaration(getterDeclaration);

typeElements.push(

setCommentRange(

signatureToSignatureDeclarationHelper(getterSignature, SyntaxKind.GetAccessor, context, { name: propertyName }) as GetAccessorDeclaration,

getterDeclaration,

),

const setterSignature = getSignatureFromDeclaration(setterDeclaration);

typeElements.push(

setCommentRange(

signatureToSignatureDeclarationHelper(setterSignature, SyntaxKind.SetAccessor, context, { name: propertyName }) as SetAccessorDeclaration,

setterDeclaration,

),

}

else if (propertySymbol.valueDeclaration) {

// Copy comments to node for declaration emit

}

return node;

}

}

function mapToTypeNodes(types: readonly Type[] | undefined, context: NodeBuilderContext, isBareList?: boolean): TypeNode[] | undefined {

if (some(types)) {

if (checkTruncationLength(context)) {

if (context.tracker.canTrackSymbol && isComputedPropertyName(node) && isLateBindableName(node)) {

trackComputedName(node.expression, context.enclosingDeclaration, context);

}

if (isBindingElement(visited)) {

visited = factory.updateBindingElement(

visited,

if (!(result.kind & SyntaxKind.Identifier)) {

return factory.createIdentifier("(Missing type parameter)");

}

if (context.flags & NodeBuilderFlags.GenerateNamesForShadowedTypeParams) {

const rawtext = result.escapedText as string;

let i = context.typeParameterNamesByTextNextNameCount?.get(rawtext) || 0;

name.symbol = sym!; // for quickinfo, which uses identifier symbol information

return setTextRange(context, setEmitFlags(name, EmitFlags.NoAsciiEscaping), node);

}

if (updated !== node) {

setTextRange(context, updated, node);

}

// 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).

}

function createRecoveryBoundary() {

|| (isPropertySignature(node) && !node.type && !node.initializer)

|| (isParameter(node) && !node.type && !node.initializer)

) {

if (visited === node) {

visited = setTextRange(context, factory.cloneNode(node), node);

}

}

if (isTupleTypeNode(node) || isTypeLiteralNode(node) || isMappedTypeNode(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));

}

}

function getEffectiveDotDotDotForParameter(p: ParameterDeclaration) {

return p.dotDotDotToken || (p.type && isJSDocVariadicType(p.type) ? factory.createToken(SyntaxKind.DotDotDotToken) : undefined);

>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

> : ^^^^

>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

=== FunctionPropertyAssignments6_es6.ts ===

var v = { *<T>() { } }

>v : { ""<T>(): Generator<never, void, unknown>; }

>{ *<T>() { } } : { ""<T>(): Generator<never, void, unknown>; }

> : <T>() => Generator<never, void, unknown>

*foo<T>() { }

>foo : <T>() => Generator<never, void, unknown>

}