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

Added ArrayKind, moved createNode, changed JSDocParsing tests to use baselines.

Browse Source
This commit is contained in:
Ron Buckton
2016-02-04 15:01:31 -08:00
parent 3855261796
commit f8e574f1d6
69 changed files with 2225 additions and 2393 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/core.ts
+1
View File
@@ -866,6 +866,7 @@ namespace ts {
this.end = end;
this.flags = NodeFlags.None;
this.parent = undefined;
this.original = undefined;
}
export let objectAllocator: ObjectAllocator = {
src/compiler/factory.ts
+98 -17
View File
@@ -1,53 +1,134 @@
/// <reference path="types.ts"/>
/// <reference path="core.ts"/>
/// <reference path="utilities.ts"/>
/* @internal */
namespace ts {
export function createNodeArray<T extends Node>(elements?: T[], location?: TextRange): NodeArray<T>;
export function createNodeArray<T extends Node, TArray extends NodeArray<T>>(elements: TArray, location?: TextRange): TArray;
export function createNodeArray<T extends Node, TArray extends NodeArray<T>>(elements?: T[], location?: TextRange): TArray {
const array = <TArray>(elements || []);
if (location) {
array.pos = location.pos;
array.end = location.end;
}
else if (array.pos === undefined || array.end === undefined) {
array.pos = -1;
array.end = -1;
}
let NodeConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;
let SourceFileConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;
export function createNode(kind: SyntaxKind, pos?: number, end?: number): Node {
if (kind === SyntaxKind.SourceFile) {
return new (SourceFileConstructor || (SourceFileConstructor = objectAllocator.getSourceFileConstructor()))(kind, pos, end);
}
else {
return new (NodeConstructor || (NodeConstructor = objectAllocator.getNodeConstructor()))(kind, pos, end);
}
}
/* @internal */
export function createNodeArray<T extends Node>(elements?: T[], pos?: number, end?: number): NodeArray<T> {
const array = <NodeArray<T>>(elements || []);
array.pos = pos;
array.end = end;
array.arrayKind = ArrayKind.NodeArray;
return array;
}
export function createNodeArrayNode<T extends Node>(elements?: (T | NodeArrayNode<T>)[]): NodeArrayNode<T> {
const array = <NodeArrayNode<T>>createNodeArray(elements);
array.kind = SyntaxKind.NodeArrayNode;
/* @internal */
export function createModifiersArray(elements?: Modifier[], pos?: number, end?: number): ModifiersArray {
const array = <ModifiersArray>(elements || []);
array.pos = pos;
array.end = end;
array.arrayKind = ArrayKind.ModifiersArray;
array.flags = 0;
return array;
}
/* @internal */
export function createSynthesizedNode(kind: SyntaxKind, startsOnNewLine?: boolean): Node {
const node = <SynthesizedNode>createNode(kind, /*pos*/ -1, /*end*/ -1);
node.startsOnNewLine = startsOnNewLine;
return node;
}
/* @internal */
export function createSynthesizedNodeArray<T extends Node>(elements?: T[]): NodeArray<T> {
return createNodeArray(elements, /*pos*/ -1, /*end*/ -1);
}
/* @internal */
export function createSynthesizedModifiersArray(elements?: Modifier[]): ModifiersArray {
return createModifiersArray(elements, /*pos*/ -1, /*end*/ -1);
}
/**
* Creates a shallow, memberwise clone of a node. The "kind", "pos", "end", "flags", and "parent"
* properties are excluded by default, and can be provided via the "location", "flags", and
* "parent" parameters.
*
* @param node The node to clone.
* @param location An optional TextRange to use to supply the new position.
* @param flags The NodeFlags to use for the cloned node.
* @param parent The parent for the new node.
* @param original An optional pointer to the original source tree node.
*/
/* @internal */
export function cloneNode<T extends Node>(node: T, location?: TextRange, flags?: NodeFlags, parent?: Node, original?: Node): T {
// We don't use "clone" from core.ts here, as we need to preserve the prototype chain of
// the original node. We also need to exclude specific properties and only include own-
// properties (to skip members already defined on the shared prototype).
const clone = location !== undefined
? <T>createNode(node.kind, location.pos, location.end)
: <T>createSynthesizedNode(node.kind);
for (const key in node) {
if (clone.hasOwnProperty(key) || !node.hasOwnProperty(key)) {
continue;
}
(<any>clone)[key] = (<any>node)[key];
}
if (flags !== undefined) {
clone.flags = flags;
}
if (parent !== undefined) {
clone.parent = parent;
}
if (original !== undefined) {
clone.original = original;
}
return clone;
}
/* @internal */
export function createNodeArrayNode<T extends Node>(elements: T[]): NodeArrayNode<T> {
const node = <NodeArrayNode<T>>createSynthesizedNode(SyntaxKind.NodeArrayNode);
node.nodes = createNodeArray(elements);
return node;
}
/* @internal */
export function createReturn(expression?: Expression): ReturnStatement {
const node = <ReturnStatement>createSynthesizedNode(SyntaxKind.ReturnStatement);
node.expression = expression;
return node;
}
/* @internal */
export function createStatement(expression: Expression): ExpressionStatement {
const node = <ExpressionStatement>createSynthesizedNode(SyntaxKind.ExpressionStatement);
node.expression = expression;
return node;
}
/* @internal */
export function createVariableStatement(declarationList: VariableDeclarationList): VariableStatement {
const node = <VariableStatement>createSynthesizedNode(SyntaxKind.VariableStatement);
node.declarationList = declarationList;
return node;
}
/* @internal */
export function createVariableDeclarationList(declarations: VariableDeclaration[]): VariableDeclarationList {
const node = <VariableDeclarationList>createSynthesizedNode(SyntaxKind.VariableDeclarationList);
node.declarations = createNodeArray(declarations);
return node;
}
/* @internal */
export function createBlock(statements: Statement[]): Block {
const block = <Block>createSynthesizedNode(SyntaxKind.Block);
block.statements = createNodeArray(statements);
src/compiler/parser.ts
+58 -60
View File
@@ -1,21 +1,10 @@
/// <reference path="utilities.ts"/>
/// <reference path="scanner.ts"/>
/// <reference path="factory.ts"/>
namespace ts {
/* @internal */ export let parseTime = 0;
let NodeConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;
let SourceFileConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;
export function createNode(kind: SyntaxKind, pos?: number, end?: number): Node {
if (kind === SyntaxKind.SourceFile) {
return new (SourceFileConstructor || (SourceFileConstructor = objectAllocator.getSourceFileConstructor()))(kind, pos, end);
}
else {
return new (NodeConstructor || (NodeConstructor = objectAllocator.getNodeConstructor()))(kind, pos, end);
}
}
function visitNode<T>(cbNode: (node: Node) => T, node: Node): T {
if (node) {
return cbNode(node);
@@ -875,7 +864,7 @@ namespace ts {
/** Invokes the provided callback then unconditionally restores the parser to the state it
* was in immediately prior to invoking the callback. The result of invoking the callback
* is returned from this function.
* is returned from this function.
*/
function lookAhead<T>(callback: () => T): T {
return speculationHelper(callback, /*isLookAhead*/ true);
@@ -989,6 +978,29 @@ namespace ts {
return new NodeConstructor(kind, pos, pos);
}
function createNodeArray<T extends Node>(elements?: T[], pos?: number): NodeArray<T> {
const array = <NodeArray<T>>(elements || []);
if (!(pos >= 0)) {
pos = getNodePos();
}
array.pos = pos;
array.end = pos;
array.arrayKind = ArrayKind.NodeArray;
return array;
}
function createModifiersArray(elements?: Modifier[], pos?: number): ModifiersArray {
const array = <ModifiersArray>(elements || []);
if (!(pos >= 0)) {
pos = getNodePos();
}
array.pos = pos;
array.end = pos;
array.arrayKind = ArrayKind.ModifiersArray;
array.flags = 0;
return array;
}
function finishNode<T extends Node>(node: T, end?: number): T {
node.end = end === undefined ? scanner.getStartPos() : end;
@@ -1374,8 +1386,7 @@ namespace ts {
function parseList<T extends Node>(kind: ParsingContext, parseElement: () => T): NodeArray<T> {
const saveParsingContext = parsingContext;
parsingContext |= 1 << kind;
const result = <NodeArray<T>>[];
result.pos = getNodePos();
const result = createNodeArray<T>();
while (!isListTerminator(kind)) {
if (isListElement(kind, /*inErrorRecovery*/ false)) {
@@ -1722,8 +1733,7 @@ namespace ts {
function parseDelimitedList<T extends Node>(kind: ParsingContext, parseElement: () => T, considerSemicolonAsDelimeter?: boolean): NodeArray<T> {
const saveParsingContext = parsingContext;
parsingContext |= 1 << kind;
const result = <NodeArray<T>>[];
result.pos = getNodePos();
const result = createNodeArray<T>();
let commaStart = -1; // Meaning the previous token was not a comma
while (true) {
@@ -1778,12 +1788,8 @@ namespace ts {
return result;
}
function createMissingList<T>(): NodeArray<T> {
const pos = getNodePos();
const result = <NodeArray<T>>[];
result.pos = pos;
result.end = pos;
return result;
function createMissingList<T extends Node>(): NodeArray<T> {
return createNodeArray<T>();
}
function parseBracketedList<T extends Node>(kind: ParsingContext, parseElement: () => T, open: SyntaxKind, close: SyntaxKind): NodeArray<T> {
@@ -1848,8 +1854,7 @@ namespace ts {
template.head = parseTemplateLiteralFragment();
Debug.assert(template.head.kind === SyntaxKind.TemplateHead, "Template head has wrong token kind");
const templateSpans = <NodeArray<TemplateSpan>>[];
templateSpans.pos = getNodePos();
const templateSpans = createNodeArray<TemplateSpan>();
do {
templateSpans.push(parseTemplateSpan());
@@ -2425,8 +2430,7 @@ namespace ts {
function parseUnionOrIntersectionType(kind: SyntaxKind, parseConstituentType: () => TypeNode, operator: SyntaxKind): TypeNode {
let type = parseConstituentType();
if (token === operator) {
const types = <NodeArray<TypeNode>>[type];
types.pos = type.pos;
const types = createNodeArray<TypeNode>([type], type.pos);
while (parseOptional(operator)) {
types.push(parseConstituentType());
}
@@ -2781,8 +2785,7 @@ namespace ts {
parameter.name = identifier;
finishNode(parameter);
node.parameters = <NodeArray<ParameterDeclaration>>[parameter];
node.parameters.pos = parameter.pos;
node.parameters = createNodeArray<ParameterDeclaration>([parameter], parameter.pos);
node.parameters.end = parameter.end;
node.equalsGreaterThanToken = parseExpectedToken(SyntaxKind.EqualsGreaterThanToken, /*reportAtCurrentPosition*/ false, Diagnostics._0_expected, "=>");
@@ -3557,8 +3560,7 @@ namespace ts {
}
function parseJsxChildren(openingTagName: EntityName): NodeArray<JsxChild> {
const result = <NodeArray<JsxChild>>[];
result.pos = scanner.getStartPos();
const result = createNodeArray<JsxChild>();
const saveParsingContext = parsingContext;
parsingContext |= 1 << ParsingContext.JsxChildren;
@@ -4922,14 +4924,15 @@ namespace ts {
break;
}
if (!decorators) {
decorators = <NodeArray<Decorator>>[];
decorators.pos = decoratorStart;
}
const decorator = <Decorator>createNode(SyntaxKind.Decorator, decoratorStart);
decorator.expression = doInDecoratorContext(parseLeftHandSideExpressionOrHigher);
decorators.push(finishNode(decorator));
finishNode(decorator);
if (!decorators) {
decorators = createNodeArray<Decorator>([decorator], decoratorStart);
}
else {
decorators.push(decorator);
}
}
if (decorators) {
decorators.end = getNodeEnd();
@@ -4953,7 +4956,7 @@ namespace ts {
if (token === SyntaxKind.ConstKeyword && permitInvalidConstAsModifier) {
// We need to ensure that any subsequent modifiers appear on the same line
// so that when 'const' is a standalone declaration, we don't issue an error.
// so that when 'const' is a standalone declaration, we don't issue an error.
if (!tryParse(nextTokenIsOnSameLineAndCanFollowModifier)) {
break;
}
@@ -4964,13 +4967,14 @@ namespace ts {
}
}
if (!modifiers) {
modifiers = <ModifiersArray>[];
modifiers.pos = modifierStart;
}
flags |= modifierToFlag(modifierKind);
modifiers.push(finishNode(createNode(modifierKind, modifierStart)));
const modifier = finishNode(createNode(modifierKind, modifierStart));
if (!modifiers) {
modifiers = createModifiersArray([modifier], modifierStart);
}
else {
modifiers.push(modifier);
}
}
if (modifiers) {
modifiers.flags = flags;
@@ -4980,17 +4984,14 @@ namespace ts {
}
function parseModifiersForArrowFunction(): ModifiersArray {
let flags = 0;
let modifiers: ModifiersArray;
if (token === SyntaxKind.AsyncKeyword) {
const modifierStart = scanner.getStartPos();
const modifierKind = token;
nextToken();
modifiers = <ModifiersArray>[];
modifiers.pos = modifierStart;
flags |= modifierToFlag(modifierKind);
modifiers.push(finishNode(createNode(modifierKind, modifierStart)));
modifiers.flags = flags;
const modifier = finishNode(createNode(modifierKind, modifierStart));
modifiers = createModifiersArray([modifier], modifierStart);
modifiers.flags = modifierToFlag(modifierKind);
modifiers.end = scanner.getStartPos();
}
@@ -5216,7 +5217,7 @@ namespace ts {
node.decorators = decorators;
setModifiers(node, modifiers);
if (token === SyntaxKind.GlobalKeyword) {
// parse 'global' as name of global scope augmentation
// parse 'global' as name of global scope augmentation
node.name = parseIdentifier();
node.flags |= NodeFlags.GlobalAugmentation;
}
@@ -5848,10 +5849,8 @@ namespace ts {
function parseJSDocTypeList(firstType: JSDocType) {
Debug.assert(!!firstType);
const types = <NodeArray<JSDocType>>[];
types.pos = firstType.pos;
const types = createNodeArray([firstType], firstType.pos);
types.push(firstType);
while (parseOptional(SyntaxKind.BarToken)) {
types.push(parseJSDocType());
}
@@ -6059,11 +6058,11 @@ namespace ts {
function addTag(tag: JSDocTag): void {
if (tag) {
if (!tags) {
tags = <NodeArray<JSDocTag>>[];
tags.pos = tag.pos;
tags = createNodeArray([tag], tag.pos);
}
else {
tags.push(tag);
}
tags.push(tag);
tags.end = tag.end;
}
}
@@ -6156,8 +6155,7 @@ namespace ts {
}
// Type parameter list looks like '@template T,U,V'
const typeParameters = <NodeArray<TypeParameterDeclaration>>[];
typeParameters.pos = scanner.getStartPos();
const typeParameters = createNodeArray<TypeParameterDeclaration>();
while (true) {
const name = parseJSDocIdentifier();
src/compiler/types.ts
+17 -2
View File
@@ -454,12 +454,27 @@ namespace ts {
/* @internal */ localSymbol?: Symbol; // Local symbol declared by node (initialized by binding only for exported nodes)
}
export interface NodeArray<T> extends Array<T>, TextRange {
export const enum ArrayKind {
NodeArray = 1,
ModifiersArray = 2,
}
export interface NodeArray<T extends Node> extends Array<T>, TextRange {
arrayKind: ArrayKind;
hasTrailingComma?: boolean;
}
/**
* A NodeArrayNode is a transient node used during transformations to indicate that more than
* one node will substitute a single node in the source. When the source is a NodeArray (as
* part of a call to `visitNodes`), the nodes of a NodeArrayNode will be spread into the
* result array. When the source is a Node (as part of a call to `visitNode`), the NodeArrayNode
* must be converted into a compatible node via the `lift` callback.
*/
/* @internal */
// @kind(SyntaxKind.NodeArrayNode)
export interface NodeArrayNode<T> extends Node, NodeArray<T | NodeArrayNode<T>> {
export interface NodeArrayNode<T extends Node> extends Node {
nodes: NodeArray<T>;
}
export interface ModifiersArray extends NodeArray<Modifier> {
src/compiler/utilities.ts
+4 -58
View File
@@ -1647,47 +1647,6 @@ namespace ts {
return isFunctionLike(n) || n.kind === SyntaxKind.ModuleDeclaration || n.kind === SyntaxKind.SourceFile;
}
/**
* Creates a shallow, memberwise clone of a node. The "kind", "pos", "end", "flags", and "parent"
* properties are excluded by default, and can be provided via the "location", "flags", and
* "parent" parameters.
* @param node The node to clone.
* @param location An optional TextRange to use to supply the new position.
* @param flags The NodeFlags to use for the cloned node.
* @param parent The parent for the new node.
* @param original An optional pointer to the original node.
*/
export function cloneNode<T extends Node>(node: T, location?: TextRange, flags?: NodeFlags, parent?: Node, original?: Node): T {
// We don't use "clone" from core.ts here, as we need to preserve the prototype chain of
// the original node. We also need to exclude specific properties and only include own-
// properties (to skip members already defined on the shared prototype).
const clone = location !== undefined
? <T>createNode(node.kind, location.pos, location.end)
: <T>createSynthesizedNode(node.kind);
for (const key in node) {
if (key === "parent" || key === "flags" || clone.hasOwnProperty(key) || !node.hasOwnProperty(key)) {
continue;
}
(<any>clone)[key] = (<any>node)[key];
}
if (flags !== undefined) {
clone.flags = flags;
}
if (parent !== undefined) {
clone.parent = parent;
}
if (original !== undefined) {
clone.original = original;
}
return clone;
}
/**
* Creates a deep clone of an EntityName, with new parent pointers.
* @param node The EntityName to clone.
@@ -1719,19 +1678,6 @@ namespace ts {
return !(pos >= 0);
}
export function createSynthesizedNode(kind: SyntaxKind, startsOnNewLine?: boolean): Node {
const node = <SynthesizedNode>createNode(kind, /* pos */ -1, /* end */ -1);
node.startsOnNewLine = startsOnNewLine;
return node;
}
export function createSynthesizedNodeArray(): NodeArray<any> {
const array = <NodeArray<any>>[];
array.pos = -1;
array.end = -1;
return array;
}
export function getOriginalNode(node: Node): Node {
while (node.original !== undefined) {
node = node.original;
@@ -2728,12 +2674,12 @@ namespace ts {
return false;
}
export function isModifiersArray(nodes: NodeArray<Node>): nodes is ModifiersArray {
return !isNodeArrayNode(nodes) && typeof (<ModifiersArray>nodes).flags === "number";
export function isModifiersArray(array: NodeArray<Node>): array is ModifiersArray {
return array.arrayKind === ArrayKind.ModifiersArray;
}
export function isNodeArrayNode<T extends Node>(value: Node | NodeArray<T | NodeArrayNode<T>>): value is NodeArrayNode<T> {
return (<Node>value).kind === SyntaxKind.NodeArrayNode;
export function isNodeArrayNode<T extends Node>(node: Node): node is NodeArrayNode<T> {
return node.kind === SyntaxKind.NodeArrayNode;
}
export function getLocalSymbolForExportDefault(symbol: Symbol) {
src/compiler/visitor.ts
+104 -117
View File
@@ -1,5 +1,5 @@
/// <reference path="checker.ts" />
/// <reference path="factory.ts" />
/* @internal */
namespace ts {
/** Additional context provided to `visitEachChild` */
@@ -15,9 +15,6 @@ namespace ts {
* Describes an edge of a Node, used when traversing a syntax tree.
*/
interface NodeEdge {
/** Indicates that the edge is a NodeArray. */
array?: boolean;
/** Indicates that the result is optional. */
optional?: boolean;
@@ -25,7 +22,7 @@ namespace ts {
test?: (node: Node) => node is Node;
/** A callback used to lift a NodeArrayNode into a valid node. */
lift?: (nodes: NodeArrayNode<Node>) => Node;
lift?: (nodes: NodeArray<Node>) => Node;
};
/**
@@ -55,8 +52,8 @@ namespace ts {
expression: { test: isExpressionNode },
},
[SyntaxKind.Parameter]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
name: { test: isBindingPatternOrIdentifier },
type: { test: isTypeNodeNode, optional: true },
initializer: { test: isExpressionNode, optional: true },
@@ -65,52 +62,52 @@ namespace ts {
expression: { test: isLeftHandSideExpression },
},
[SyntaxKind.PropertyDeclaration]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
name: { test: isPropertyName },
type: { test: isTypeNodeNode, optional: true },
initializer: { test: isExpressionNode, optional: true },
},
[SyntaxKind.MethodDeclaration]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
name: { test: isPropertyName },
typeParameters: { test: isTypeParameter, array: true },
parameters: { test: isParameter, array: true },
typeParameters: { test: isTypeParameter },
parameters: { test: isParameter },
type: { test: isTypeNodeNode, optional: true },
body: { test: isBlock, optional: true },
},
[SyntaxKind.Constructor]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
typeParameters: { test: isTypeParameter, array: true },
parameters: { test: isParameter, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
typeParameters: { test: isTypeParameter },
parameters: { test: isParameter },
type: { test: isTypeNodeNode, optional: true },
body: { test: isBlock, optional: true },
},
[SyntaxKind.GetAccessor]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
name: { test: isPropertyName },
typeParameters: { test: isTypeParameter, array: true },
parameters: { test: isParameter, array: true },
typeParameters: { test: isTypeParameter },
parameters: { test: isParameter },
type: { test: isTypeNodeNode, optional: true },
body: { test: isBlock, optional: true },
},
[SyntaxKind.SetAccessor]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
name: { test: isPropertyName },
typeParameters: { test: isTypeParameter, array: true },
parameters: { test: isParameter, array: true },
typeParameters: { test: isTypeParameter },
parameters: { test: isParameter },
type: { test: isTypeNodeNode, optional: true },
body: { test: isBlock, optional: true },
},
[SyntaxKind.ObjectBindingPattern]: {
elements: { test: isBindingElement, array: true },
elements: { test: isBindingElement },
},
[SyntaxKind.ArrayBindingPattern]: {
elements: { test: isBindingElement, array: true },
elements: { test: isBindingElement },
},
[SyntaxKind.BindingElement]: {
propertyName: { test: isPropertyName, optional: true },
@@ -118,10 +115,10 @@ namespace ts {
initializer: { test: isExpressionNode, optional: true },
},
[SyntaxKind.ArrayLiteralExpression]: {
elements: { test: isExpressionNode, array: true },
elements: { test: isExpressionNode },
},
[SyntaxKind.ObjectLiteralExpression]: {
properties: { test: isObjectLiteralElement, array: true },
properties: { test: isObjectLiteralElement },
},
[SyntaxKind.PropertyAccessExpression]: {
expression: { test: isLeftHandSideExpression },
@@ -133,13 +130,13 @@ namespace ts {
},
[SyntaxKind.CallExpression]: {
expression: { test: isLeftHandSideExpression },
typeArguments: { test: isTypeNodeNode, array: true },
arguments: { test: isExpressionNode, array: true },
typeArguments: { test: isTypeNodeNode },
arguments: { test: isExpressionNode },
},
[SyntaxKind.NewExpression]: {
expression: { test: isLeftHandSideExpression },
typeArguments: { test: isTypeNodeNode, array: true },
arguments: { test: isExpressionNode, array: true },
typeArguments: { test: isTypeNodeNode },
arguments: { test: isExpressionNode },
},
[SyntaxKind.TaggedTemplateExpression]: {
tag: { test: isLeftHandSideExpression },
@@ -153,19 +150,19 @@ namespace ts {
expression: { test: isExpressionNode },
},
[SyntaxKind.FunctionExpression]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
name: { test: isIdentifierNode, optional: true },
typeParameters: { test: isTypeParameter, array: true },
parameters: { test: isParameter, array: true },
typeParameters: { test: isTypeParameter },
parameters: { test: isParameter },
type: { test: isTypeNodeNode, optional: true },
body: { test: isBlock, optional: true },
},
[SyntaxKind.ArrowFunction]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
typeParameters: { test: isTypeParameter, array: true },
parameters: { test: isParameter, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
typeParameters: { test: isTypeParameter },
parameters: { test: isParameter },
type: { test: isTypeNodeNode, optional: true },
body: { test: isConciseBody, lift: liftToBlock },
},
@@ -198,7 +195,7 @@ namespace ts {
},
[SyntaxKind.TemplateExpression]: {
head: { test: isTemplateLiteralFragment },
templateSpans: { test: isTemplateSpan, array: true },
templateSpans: { test: isTemplateSpan },
},
[SyntaxKind.YieldExpression]: {
expression: { test: isExpressionNode, optional: true },
@@ -207,16 +204,16 @@ namespace ts {
expression: { test: isExpressionNode },
},
[SyntaxKind.ClassExpression]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
name: { test: isIdentifierNode, optional: true },
typeParameters: { test: isTypeParameter, array: true },
heritageClauses: { test: isHeritageClause, array: true },
members: { test: isClassElement, array: true },
typeParameters: { test: isTypeParameter },
heritageClauses: { test: isHeritageClause },
members: { test: isClassElement },
},
[SyntaxKind.ExpressionWithTypeArguments]: {
expression: { test: isLeftHandSideExpression },
typeArguments: { test: isTypeNodeNode, array: true },
typeArguments: { test: isTypeNodeNode },
},
[SyntaxKind.AsExpression]: {
expression: { test: isExpressionNode },
@@ -227,11 +224,11 @@ namespace ts {
literal: { test: isTemplateLiteralFragment },
},
[SyntaxKind.Block]: {
statements: { test: isStatementNode, array: true },
statements: { test: isStatementNode },
},
[SyntaxKind.VariableStatement]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
declarationList: { test: isVariableDeclarationList },
},
[SyntaxKind.ExpressionStatement]: {
@@ -301,52 +298,52 @@ namespace ts {
initializer: { test: isExpressionNode, optional: true },
},
[SyntaxKind.VariableDeclarationList]: {
declarations: { test: isVariableDeclaration, array: true },
declarations: { test: isVariableDeclaration },
},
[SyntaxKind.FunctionDeclaration]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
name: { test: isIdentifierNode, optional: true },
typeParameters: { test: isTypeParameter, array: true },
parameters: { test: isParameter, array: true },
typeParameters: { test: isTypeParameter },
parameters: { test: isParameter },
type: { test: isTypeNodeNode, optional: true },
body: { test: isBlock, optional: true },
},
[SyntaxKind.ClassDeclaration]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
name: { test: isIdentifierNode, optional: true },
typeParameters: { test: isTypeParameter, array: true },
heritageClauses: { test: isHeritageClause, array: true },
members: { test: isClassElement, array: true },
typeParameters: { test: isTypeParameter },
heritageClauses: { test: isHeritageClause },
members: { test: isClassElement },
},
[SyntaxKind.EnumDeclaration]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
name: { test: isIdentifierNode },
members: { test: isEnumMember, array: true },
members: { test: isEnumMember },
},
[SyntaxKind.ModuleDeclaration]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
name: { test: isModuleName },
body: { test: isModuleBody },
},
[SyntaxKind.ModuleBlock]: {
statements: { test: isStatementNode, array: true },
statements: { test: isStatementNode },
},
[SyntaxKind.CaseBlock]: {
clauses: { test: isCaseOrDefaultClause, array: true },
clauses: { test: isCaseOrDefaultClause },
},
[SyntaxKind.ImportEqualsDeclaration]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
name: { test: isIdentifierNode },
moduleReference: { test: isModuleReference },
},
[SyntaxKind.ImportDeclaration]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
importClause: { test: isImportClause, optional: true },
moduleSpecifier: { test: isExpressionNode },
},
@@ -358,25 +355,25 @@ namespace ts {
name: { test: isIdentifierNode },
},
[SyntaxKind.NamedImports]: {
elements: { test: isImportSpecifier, array: true },
elements: { test: isImportSpecifier },
},
[SyntaxKind.ImportSpecifier]: {
propertyName: { test: isIdentifierNode, optional: true },
name: { test: isIdentifierNode },
},
[SyntaxKind.ExportAssignment]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
expression: { test: isExpressionNode },
},
[SyntaxKind.ExportDeclaration]: {
decorators: { test: isDecorator, array: true },
modifiers: { test: isModifier, array: true },
decorators: { test: isDecorator },
modifiers: { test: isModifier },
exportClause: { test: isNamedExports, optional: true },
moduleSpecifier: { test: isExpressionNode, optional: true },
},
[SyntaxKind.NamedExports]: {
elements: { test: isExportSpecifier, array: true },
elements: { test: isExportSpecifier },
},
[SyntaxKind.ExportSpecifier]: {
propertyName: { test: isIdentifierNode, optional: true },
@@ -387,16 +384,16 @@ namespace ts {
},
[SyntaxKind.JsxElement]: {
openingElement: { test: isJsxOpeningElement },
children: { test: isJsxChild, array: true },
children: { test: isJsxChild },
closingElement: { test: isJsxClosingElement },
},
[SyntaxKind.JsxSelfClosingElement]: {
tagName: { test: isEntityName },
attributes: { test: isJsxAttributeOrJsxSpreadAttribute, array: true },
attributes: { test: isJsxAttributeOrJsxSpreadAttribute },
},
[SyntaxKind.JsxOpeningElement]: {
tagName: { test: isEntityName },
attributes: { test: isJsxAttributeOrJsxSpreadAttribute, array: true },
attributes: { test: isJsxAttributeOrJsxSpreadAttribute },
},
[SyntaxKind.JsxClosingElement]: {
tagName: { test: isEntityName },
@@ -413,13 +410,13 @@ namespace ts {
},
[SyntaxKind.CaseClause]: {
expression: { test: isExpressionNode },
statements: { test: isStatementNode, array: true },
statements: { test: isStatementNode },
},
[SyntaxKind.DefaultClause]: {
statements: { test: isStatementNode, array: true },
statements: { test: isStatementNode },
},
[SyntaxKind.HeritageClause]: {
types: { test: isExpressionWithTypeArguments, array: true },
types: { test: isExpressionWithTypeArguments },
},
[SyntaxKind.CatchClause]: {
variableDeclaration: { test: isVariableDeclaration },
@@ -438,7 +435,7 @@ namespace ts {
initializer: { test: isExpressionNode, optional: true },
},
[SyntaxKind.SourceFile]: {
statements: { test: isStatementNode, array: true },
statements: { test: isStatementNode },
},
};
@@ -462,13 +459,9 @@ namespace ts {
for (const propertyName in edgeTraversalPath) {
const value = (<Map<any>>node)[propertyName];
if (value !== undefined) {
const edge = edgeTraversalPath[propertyName];
if (edge.array) {
result = reduceLeft(<NodeArray<Node>>value, f, result);
}
else {
result = f(result, <Node>value);
}
result = isArray(value)
? reduceLeft(<NodeArray<Node>>value, f, result)
: f(result, <Node>value);
}
}
}
@@ -485,7 +478,7 @@ namespace ts {
* @param lift A callback to execute to lift a NodeArrayNode into a valid Node.
* @param optional A value indicating whether the Node is optional.
*/
export function visitNode<T extends Node>(node: T, visitor: (node: Node) => Node, test?: (node: Node) => boolean, lift?: (node: NodeArrayNode<T>) => T, optional?: boolean): T {
export function visitNode<T extends Node>(node: T, visitor: (node: Node) => Node, test?: (node: Node) => boolean, lift?: (node: NodeArray<Node>) => T, optional?: boolean): T {
if (node === undefined) {
return undefined;
}
@@ -501,10 +494,7 @@ namespace ts {
return undefined;
}
if (test !== undefined) {
Debug.assert(test(visited), "Wrong node type after visit.");
}
Debug.assert(test === undefined || test(visited), "Wrong node type after visit.");
return <T>visited;
}
@@ -520,7 +510,7 @@ namespace ts {
return undefined;
}
let updated: TArray;
let updated: NodeArray<T> | ModifiersArray;
for (let i = 0, len = nodes.length; i < len; i++) {
const node = nodes[i];
if (node === undefined) {
@@ -530,7 +520,9 @@ namespace ts {
const visited = visitor(node);
if (updated !== undefined || visited === undefined || visited !== node) {
if (updated === undefined) {
updated = <TArray>createNodeArray(nodes.slice(0, i), /*location*/ nodes);
updated = isModifiersArray(nodes)
? createModifiersArray(nodes.slice(0, i), nodes.pos, nodes.end)
: createNodeArray<T>(nodes.slice(0, i), nodes.pos, nodes.end);
}
if (visited === undefined) {
@@ -541,22 +533,22 @@ namespace ts {
spreadNodeArrayNode(visited, updated, test);
}
else if (visited !== undefined) {
Debug.assert(test(visited), "Wrong node type after visit.");
Debug.assert(test === undefined || test(visited), "Wrong node type after visit.");
updated.push(<T>visited);
}
}
}
if (updated && isModifiersArray(nodes)) {
if (updated && isModifiersArray(updated)) {
let flags: NodeFlags = 0;
for (const node of updated) {
flags |= modifierToFlag(node.kind);
}
(<ModifiersArray><NodeArray<Node>>updated).flags = flags;
updated.flags = flags;
}
return updated || nodes;
return <TArray>updated || nodes;
}
/**
@@ -592,8 +584,8 @@ namespace ts {
updated[propertyName] = visited;
}
if (visited && edge.array && isModifiersArray(<NodeArray<Node>>visited)) {
updated.flags |= (<ModifiersArray>visited).flags;
if (visited && isArray(visited) && isModifiersArray(visited)) {
updated.flags |= visited.flags;
}
}
}
@@ -621,7 +613,7 @@ namespace ts {
* @param visitor A callback used to visit the node.
*/
function visitEdge(edge: NodeEdge, value: Node | NodeArray<Node>, visitor: (node: Node) => Node) {
return edge.array
return isArray(value)
? visitNodes(<NodeArray<Node>>value, visitor, edge.test)
: visitNode(<Node>value, visitor, edge.test, edge.lift, edge.optional);
}
@@ -634,18 +626,13 @@ namespace ts {
* @param test The node test used to validate each node.
*/
function spreadNodeArrayNode<T extends Node>(source: NodeArrayNode<T>, dest: NodeArray<T>, test: (node: Node) => boolean) {
for (const element of source) {
for (const element of source.nodes) {
if (element === undefined) {
continue;
}
if (isNodeArrayNode<T>(element)) {
spreadNodeArrayNode(element, dest, test);
}
else {
Debug.assert(test === undefined || test(element), "Wrong node type after visit.");
dest.push(element);
}
Debug.assert(test === undefined || test(element), "Wrong node type after visit.");
dest.push(element);
}
}
@@ -724,7 +711,7 @@ namespace ts {
* Merge generated declarations of a lexical environment into a NodeArray of Statement.
*/
function mergeStatements(statements: NodeArray<Statement>, declarations: Statement[]) {
return createNodeArray(statements.concat(declarations), /*location*/ statements);
return createNodeArray(statements.concat(declarations), statements.pos, statements.end);
}
/**
@@ -734,13 +721,13 @@ namespace ts {
* @param node The visited Node.
* @param options Options used to control lift behavior.
*/
function liftNode(node: Node, lifter: (nodes: NodeArrayNode<Node>) => Node): Node {
function liftNode(node: Node, lifter: (nodes: NodeArray<Node>) => Node): Node {
if (node === undefined) {
return undefined;
}
else if (isNodeArrayNode(node)) {
const lift = lifter || extractSingleNode;
return lift(node);
return lift(node.nodes);
}
else {
return node;
src/services/breakpoints.ts
+18 -18
View File
@@ -1,4 +1,4 @@
// Copyright (c) Microsoft. All rights reserved. Licensed under the Apache License, Version 2.0.
// Copyright (c) Microsoft. All rights reserved. Licensed under the Apache License, Version 2.0.
// See LICENSE.txt in the project root for complete license information.
/// <reference path='services.ts' />
@@ -19,8 +19,8 @@ namespace ts.BreakpointResolver {
if (sourceFile.getLineAndCharacterOfPosition(tokenAtLocation.getStart(sourceFile)).line > lineOfPosition) {
// Get previous token if the token is returned starts on new line
// eg: let x =10; |--- cursor is here
// let y = 10;
// token at position will return let keyword on second line as the token but we would like to use
// let y = 10;
// token at position will return let keyword on second line as the token but we would like to use
// token on same line if trailing trivia (comments or white spaces on same line) part of the last token on that line
tokenAtLocation = findPrecedingToken(tokenAtLocation.pos, sourceFile);
@@ -56,7 +56,7 @@ namespace ts.BreakpointResolver {
return spanInNode(otherwiseOnNode);
}
function spanInNodeArray<T>(nodeArray: NodeArray<T>) {
function spanInNodeArray<T extends Node>(nodeArray: NodeArray<T>) {
return createTextSpanFromBounds(skipTrivia(sourceFile.text, nodeArray.pos), nodeArray.end);
}
@@ -259,13 +259,13 @@ namespace ts.BreakpointResolver {
if (isArrayLiteralOrObjectLiteralDestructuringPattern(node)) {
return spanInArrayLiteralOrObjectLiteralDestructuringPattern(<DestructuringPattern>node);
}
// Set breakpoint on identifier element of destructuring pattern
// a or ...c or d: x from
// a or ...c or d: x from
// [a, b, ...c] or { a, b } or { d: x } from destructuring pattern
if ((node.kind === SyntaxKind.Identifier ||
node.kind == SyntaxKind.SpreadElementExpression ||
node.kind === SyntaxKind.PropertyAssignment ||
node.kind == SyntaxKind.SpreadElementExpression ||
node.kind === SyntaxKind.PropertyAssignment ||
node.kind === SyntaxKind.ShorthandPropertyAssignment) &&
isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent)) {
return textSpan(node);
@@ -275,7 +275,7 @@ namespace ts.BreakpointResolver {
const binaryExpression = <BinaryExpression>node;
// Set breakpoint in destructuring pattern if its destructuring assignment
// [a, b, c] or {a, b, c} of
// [a, b, c] = expression or
// [a, b, c] = expression or
// {a, b, c} = expression
if (isArrayLiteralOrObjectLiteralDestructuringPattern(binaryExpression.left)) {
return spanInArrayLiteralOrObjectLiteralDestructuringPattern(
@@ -285,8 +285,8 @@ namespace ts.BreakpointResolver {
if (binaryExpression.operatorToken.kind === SyntaxKind.EqualsToken &&
isArrayLiteralOrObjectLiteralDestructuringPattern(binaryExpression.parent)) {
// Set breakpoint on assignment expression element of destructuring pattern
// a = expression of
// [a = expression, b, c] = someExpression or
// a = expression of
// [a = expression, b, c] = someExpression or
// { a = expression, b, c } = someExpression
return textSpan(node);
}
@@ -325,14 +325,14 @@ namespace ts.BreakpointResolver {
break;
}
}
// If this is name of property assignment, set breakpoint in the initializer
if (node.parent.kind === SyntaxKind.PropertyAssignment &&
(<PropertyDeclaration>node.parent).name === node &&
(<PropertyDeclaration>node.parent).name === node &&
!isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent.parent)) {
return spanInNode((<PropertyDeclaration>node.parent).initializer);
}
// Breakpoint in type assertion goes to its operand
if (node.parent.kind === SyntaxKind.TypeAssertionExpression && (<TypeAssertion>node.parent).type === node) {
return spanInNextNode((<TypeAssertion>node.parent).type);
@@ -386,7 +386,7 @@ namespace ts.BreakpointResolver {
if (variableDeclaration.parent.parent.kind === SyntaxKind.ForInStatement) {
return spanInNode(variableDeclaration.parent.parent);
}
// If this is a destructuring pattern set breakpoint in binding pattern
if (isBindingPattern(variableDeclaration.name)) {
return spanInBindingPattern(<BindingPattern>variableDeclaration.name);
@@ -403,7 +403,7 @@ namespace ts.BreakpointResolver {
let declarations = variableDeclaration.parent.declarations;
if (declarations && declarations[0] !== variableDeclaration) {
// If we cant set breakpoint on this declaration, set it on previous one
// Because the variable declaration may be binding pattern and
// Because the variable declaration may be binding pattern and
// we would like to set breakpoint in last binding element if thats the case,
// use preceding token instead
return spanInNode(findPrecedingToken(variableDeclaration.pos, sourceFile, variableDeclaration.parent));
@@ -549,7 +549,7 @@ namespace ts.BreakpointResolver {
return spanInNode(firstBindingElement);
}
// Could be ArrayLiteral from destructuring assignment or
// Could be ArrayLiteral from destructuring assignment or
// just nested element in another destructuring assignment
// set breakpoint on assignment when parent is destructuring assignment
// Otherwise set breakpoint for this element
@@ -686,7 +686,7 @@ namespace ts.BreakpointResolver {
function spanInColonToken(node: Node): TextSpan {
// Is this : specifying return annotation of the function declaration
if (isFunctionLike(node.parent) ||
node.parent.kind === SyntaxKind.PropertyAssignment ||
node.parent.kind === SyntaxKind.PropertyAssignment ||
node.parent.kind === SyntaxKind.Parameter) {
return spanInPreviousNode(node);
}
src/services/services.ts
+4 -2
View File
@@ -186,6 +186,7 @@ namespace ts {
public end: number;
public flags: NodeFlags;
public parent: Node;
public original: Node;
private _children: Node[];
constructor(kind: SyntaxKind, pos: number, end: number) {
@@ -194,6 +195,7 @@ namespace ts {
this.end = end;
this.flags = NodeFlags.None;
this.parent = undefined;
this.original = undefined;
}
public getSourceFile(): SourceFile {
@@ -1876,7 +1878,7 @@ namespace ts {
options.isolatedModules = true;
// transpileModule does not write anything to disk so there is no need to verify that there are no conflicts between input and output paths.
// transpileModule does not write anything to disk so there is no need to verify that there are no conflicts between input and output paths.
options.suppressOutputPathCheck = true;
// Filename can be non-ts file.
@@ -6102,7 +6104,7 @@ namespace ts {
}
}
// For export specifiers, it can be a local symbol, e.g.
// For export specifiers, it can be a local symbol, e.g.
// import {a} from "mod";
// export {a as somethingElse}
// We want the local target of the export (i.e. the import symbol) and not the final target (i.e. "mod".a)
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.leadingAsterisk.json
+37
View File
@@ -0,0 +1,37 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 27,
"tags": {
"0": {
"kind": "JSDocTypeTag",
"pos": 8,
"end": 22,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 13,
"text": "type"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 14,
"end": 22,
"type": {
"kind": "NumberKeyword",
"pos": 15,
"end": 21
}
}
},
"length": 1,
"pos": 8,
"end": 22,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.noLeadingAsterisk.json
+37
View File
@@ -0,0 +1,37 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 27,
"tags": {
"0": {
"kind": "JSDocTypeTag",
"pos": 8,
"end": 22,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 13,
"text": "type"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 14,
"end": 22,
"type": {
"kind": "NumberKeyword",
"pos": 15,
"end": 21
}
}
},
"length": 1,
"pos": 8,
"end": 22,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.noReturnType.json
+27
View File
@@ -0,0 +1,27 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 20,
"tags": {
"0": {
"kind": "JSDocReturnTag",
"pos": 8,
"end": 15,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 15,
"text": "return"
}
},
"length": 1,
"pos": 8,
"end": 15,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.noType.json
+27
View File
@@ -0,0 +1,27 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 18,
"tags": {
"0": {
"kind": "JSDocTypeTag",
"pos": 8,
"end": 13,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 13,
"text": "type"
}
},
"length": 1,
"pos": 8,
"end": 13,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.oneParamTag.json
+43
View File
@@ -0,0 +1,43 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 34,
"tags": {
"0": {
"kind": "JSDocParameterTag",
"pos": 8,
"end": 29,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 14,
"text": "param"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 15,
"end": 23,
"type": {
"kind": "NumberKeyword",
"pos": 16,
"end": 22
}
},
"postParameterName": {
"kind": "Identifier",
"pos": 24,
"end": 29,
"text": "name1"
}
},
"length": 1,
"pos": 8,
"end": 29,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.paramTag1.json
+43
View File
@@ -0,0 +1,43 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 59,
"tags": {
"0": {
"kind": "JSDocParameterTag",
"pos": 8,
"end": 29,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 14,
"text": "param"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 15,
"end": 23,
"type": {
"kind": "NumberKeyword",
"pos": 16,
"end": 22
}
},
"postParameterName": {
"kind": "Identifier",
"pos": 24,
"end": 29,
"text": "name1"
}
},
"length": 1,
"pos": 8,
"end": 29,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.paramTagBracketedName1.json
+44
View File
@@ -0,0 +1,44 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 61,
"tags": {
"0": {
"kind": "JSDocParameterTag",
"pos": 8,
"end": 31,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 14,
"text": "param"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 15,
"end": 23,
"type": {
"kind": "NumberKeyword",
"pos": 16,
"end": 22
}
},
"postParameterName": {
"kind": "Identifier",
"pos": 25,
"end": 30,
"text": "name1"
},
"isBracketed": true
},
"length": 1,
"pos": 8,
"end": 31,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.paramTagBracketedName2.json
+44
View File
@@ -0,0 +1,44 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 66,
"tags": {
"0": {
"kind": "JSDocParameterTag",
"pos": 8,
"end": 36,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 14,
"text": "param"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 15,
"end": 23,
"type": {
"kind": "NumberKeyword",
"pos": 16,
"end": 22
}
},
"postParameterName": {
"kind": "Identifier",
"pos": 26,
"end": 31,
"text": "name1"
},
"isBracketed": true
},
"length": 1,
"pos": 8,
"end": 36,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.paramTagNameThenType1.json
+43
View File
@@ -0,0 +1,43 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 34,
"tags": {
"0": {
"kind": "JSDocParameterTag",
"pos": 8,
"end": 29,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 14,
"text": "param"
},
"preParameterName": {
"kind": "Identifier",
"pos": 15,
"end": 20,
"text": "name1"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 21,
"end": 29,
"type": {
"kind": "NumberKeyword",
"pos": 22,
"end": 28
}
}
},
"length": 1,
"pos": 8,
"end": 29,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.paramTagNameThenType2.json
+43
View File
@@ -0,0 +1,43 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 46,
"tags": {
"0": {
"kind": "JSDocParameterTag",
"pos": 8,
"end": 29,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 14,
"text": "param"
},
"preParameterName": {
"kind": "Identifier",
"pos": 15,
"end": 20,
"text": "name1"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 21,
"end": 29,
"type": {
"kind": "NumberKeyword",
"pos": 22,
"end": 28
}
}
},
"length": 1,
"pos": 8,
"end": 29,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.paramWithoutType.json
+33
View File
@@ -0,0 +1,33 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 23,
"tags": {
"0": {
"kind": "JSDocParameterTag",
"pos": 8,
"end": 18,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 14,
"text": "param"
},
"preParameterName": {
"kind": "Identifier",
"pos": 15,
"end": 18,
"text": "foo"
}
},
"length": 1,
"pos": 8,
"end": 18,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.returnTag1.json
+37
View File
@@ -0,0 +1,37 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 29,
"tags": {
"0": {
"kind": "JSDocReturnTag",
"pos": 8,
"end": 24,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 15,
"text": "return"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 16,
"end": 24,
"type": {
"kind": "NumberKeyword",
"pos": 17,
"end": 23
}
}
},
"length": 1,
"pos": 8,
"end": 24,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.returnTag2.json
+37
View File
@@ -0,0 +1,37 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 54,
"tags": {
"0": {
"kind": "JSDocReturnTag",
"pos": 8,
"end": 24,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 15,
"text": "return"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 16,
"end": 24,
"type": {
"kind": "NumberKeyword",
"pos": 17,
"end": 23
}
}
},
"length": 1,
"pos": 8,
"end": 24,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.returnsTag1.json
+37
View File
@@ -0,0 +1,37 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 30,
"tags": {
"0": {
"kind": "JSDocReturnTag",
"pos": 8,
"end": 25,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 16,
"text": "returns"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 17,
"end": 25,
"type": {
"kind": "NumberKeyword",
"pos": 18,
"end": 24
}
}
},
"length": 1,
"pos": 8,
"end": 25,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.templateTag.json
+44
View File
@@ -0,0 +1,44 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 24,
"tags": {
"0": {
"kind": "JSDocTemplateTag",
"pos": 8,
"end": 19,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 17,
"text": "template"
},
"typeParameters": {
"0": {
"kind": "TypeParameter",
"pos": 18,
"end": 19,
"name": {
"kind": "Identifier",
"pos": 18,
"end": 19,
"text": "T"
}
},
"length": 1,
"pos": 17,
"end": 19,
"arrayKind": 1
}
},
"length": 1,
"pos": 8,
"end": 19,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.templateTag2.json
+55
View File
@@ -0,0 +1,55 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 26,
"tags": {
"0": {
"kind": "JSDocTemplateTag",
"pos": 8,
"end": 21,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 17,
"text": "template"
},
"typeParameters": {
"0": {
"kind": "TypeParameter",
"pos": 18,
"end": 19,
"name": {
"kind": "Identifier",
"pos": 18,
"end": 19,
"text": "K"
}
},
"1": {
"kind": "TypeParameter",
"pos": 20,
"end": 21,
"name": {
"kind": "Identifier",
"pos": 20,
"end": 21,
"text": "V"
}
},
"length": 2,
"pos": 17,
"end": 21,
"arrayKind": 1
}
},
"length": 1,
"pos": 8,
"end": 21,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.templateTag3.json
+55
View File
@@ -0,0 +1,55 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 27,
"tags": {
"0": {
"kind": "JSDocTemplateTag",
"pos": 8,
"end": 22,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 17,
"text": "template"
},
"typeParameters": {
"0": {
"kind": "TypeParameter",
"pos": 18,
"end": 19,
"name": {
"kind": "Identifier",
"pos": 18,
"end": 19,
"text": "K"
}
},
"1": {
"kind": "TypeParameter",
"pos": 21,
"end": 22,
"name": {
"kind": "Identifier",
"pos": 21,
"end": 22,
"text": "V"
}
},
"length": 2,
"pos": 17,
"end": 22,
"arrayKind": 1
}
},
"length": 1,
"pos": 8,
"end": 22,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.templateTag4.json
+55
View File
@@ -0,0 +1,55 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 27,
"tags": {
"0": {
"kind": "JSDocTemplateTag",
"pos": 8,
"end": 22,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 17,
"text": "template"
},
"typeParameters": {
"0": {
"kind": "TypeParameter",
"pos": 18,
"end": 19,
"name": {
"kind": "Identifier",
"pos": 18,
"end": 19,
"text": "K"
}
},
"1": {
"kind": "TypeParameter",
"pos": 21,
"end": 22,
"name": {
"kind": "Identifier",
"pos": 21,
"end": 22,
"text": "V"
}
},
"length": 2,
"pos": 17,
"end": 22,
"arrayKind": 1
}
},
"length": 1,
"pos": 8,
"end": 22,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.templateTag5.json
+55
View File
@@ -0,0 +1,55 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 28,
"tags": {
"0": {
"kind": "JSDocTemplateTag",
"pos": 8,
"end": 23,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 17,
"text": "template"
},
"typeParameters": {
"0": {
"kind": "TypeParameter",
"pos": 18,
"end": 19,
"name": {
"kind": "Identifier",
"pos": 18,
"end": 19,
"text": "K"
}
},
"1": {
"kind": "TypeParameter",
"pos": 22,
"end": 23,
"name": {
"kind": "Identifier",
"pos": 22,
"end": 23,
"text": "V"
}
},
"length": 2,
"pos": 17,
"end": 23,
"arrayKind": 1
}
},
"length": 1,
"pos": 8,
"end": 23,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.templateTag6.json
+55
View File
@@ -0,0 +1,55 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 60,
"tags": {
"0": {
"kind": "JSDocTemplateTag",
"pos": 8,
"end": 23,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 17,
"text": "template"
},
"typeParameters": {
"0": {
"kind": "TypeParameter",
"pos": 18,
"end": 19,
"name": {
"kind": "Identifier",
"pos": 18,
"end": 19,
"text": "K"
}
},
"1": {
"kind": "TypeParameter",
"pos": 22,
"end": 23,
"name": {
"kind": "Identifier",
"pos": 22,
"end": 23,
"text": "V"
}
},
"length": 2,
"pos": 17,
"end": 23,
"arrayKind": 1
}
},
"length": 1,
"pos": 8,
"end": 23,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.twoParamTag2.json
+75
View File
@@ -0,0 +1,75 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 60,
"tags": {
"0": {
"kind": "JSDocParameterTag",
"pos": 8,
"end": 29,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 14,
"text": "param"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 15,
"end": 23,
"type": {
"kind": "NumberKeyword",
"pos": 16,
"end": 22
}
},
"postParameterName": {
"kind": "Identifier",
"pos": 24,
"end": 29,
"text": "name1"
}
},
"1": {
"kind": "JSDocParameterTag",
"pos": 34,
"end": 55,
"atToken": {
"kind": "AtToken",
"pos": 34,
"end": 35
},
"tagName": {
"kind": "Identifier",
"pos": 35,
"end": 40,
"text": "param"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 41,
"end": 49,
"type": {
"kind": "NumberKeyword",
"pos": 42,
"end": 48
}
},
"postParameterName": {
"kind": "Identifier",
"pos": 50,
"end": 55,
"text": "name2"
}
},
"length": 2,
"pos": 8,
"end": 55,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.twoParamTagOnSameLine.json
+43
View File
@@ -0,0 +1,43 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 56,
"tags": {
"0": {
"kind": "JSDocParameterTag",
"pos": 8,
"end": 29,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 14,
"text": "param"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 15,
"end": 23,
"type": {
"kind": "NumberKeyword",
"pos": 16,
"end": 22
}
},
"postParameterName": {
"kind": "Identifier",
"pos": 24,
"end": 29,
"text": "name1"
}
},
"length": 1,
"pos": 8,
"end": 29,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.typeTag.json
+37
View File
@@ -0,0 +1,37 @@
{
"kind": "JSDocComment",
"pos": 0,
"end": 27,
"tags": {
"0": {
"kind": "JSDocTypeTag",
"pos": 8,
"end": 22,
"atToken": {
"kind": "AtToken",
"pos": 8,
"end": 9
},
"tagName": {
"kind": "Identifier",
"pos": 9,
"end": 13,
"text": "type"
},
"typeExpression": {
"kind": "JSDocTypeExpression",
"pos": 14,
"end": 22,
"type": {
"kind": "NumberKeyword",
"pos": 15,
"end": 21
}
}
},
"length": 1,
"pos": 8,
"end": 22,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.allType.json
+5
View File
@@ -0,0 +1,5 @@
{
"kind": "JSDocAllType",
"pos": 1,
"end": 2
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.arrayType1.json
+16
View File
@@ -0,0 +1,16 @@
{
"kind": "JSDocArrayType",
"pos": 1,
"end": 4,
"elementType": {
"kind": "JSDocTypeReference",
"pos": 1,
"end": 2,
"name": {
"kind": "Identifier",
"pos": 1,
"end": 2,
"text": "a"
}
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.arrayType2.json
+21
View File
@@ -0,0 +1,21 @@
{
"kind": "JSDocArrayType",
"pos": 1,
"end": 6,
"elementType": {
"kind": "JSDocArrayType",
"pos": 1,
"end": 4,
"elementType": {
"kind": "JSDocTypeReference",
"pos": 1,
"end": 2,
"name": {
"kind": "Identifier",
"pos": 1,
"end": 2,
"text": "a"
}
}
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.arrayType3.json
+26
View File
@@ -0,0 +1,26 @@
{
"kind": "JSDocOptionalType",
"pos": 1,
"end": 7,
"type": {
"kind": "JSDocArrayType",
"pos": 1,
"end": 6,
"elementType": {
"kind": "JSDocArrayType",
"pos": 1,
"end": 4,
"elementType": {
"kind": "JSDocTypeReference",
"pos": 1,
"end": 2,
"name": {
"kind": "Identifier",
"pos": 1,
"end": 2,
"text": "a"
}
}
}
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.functionReturnType1.json
+31
View File
@@ -0,0 +1,31 @@
{
"kind": "JSDocFunctionType",
"pos": 1,
"end": 26,
"parameters": {
"0": {
"kind": "Parameter",
"pos": 10,
"end": 16,
"type": {
"kind": "StringKeyword",
"pos": 10,
"end": 16
}
},
"1": {
"kind": "Parameter",
"pos": 17,
"end": 25,
"type": {
"kind": "BooleanKeyword",
"pos": 17,
"end": 25
}
},
"length": 2,
"pos": 10,
"end": 25,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.functionType1.json
+11
View File
@@ -0,0 +1,11 @@
{
"kind": "JSDocFunctionType",
"pos": 1,
"end": 11,
"parameters": {
"length": 0,
"pos": 10,
"end": 10,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.functionType2.json
+31
View File
@@ -0,0 +1,31 @@
{
"kind": "JSDocFunctionType",
"pos": 1,
"end": 26,
"parameters": {
"0": {
"kind": "Parameter",
"pos": 10,
"end": 16,
"type": {
"kind": "StringKeyword",
"pos": 10,
"end": 16
}
},
"1": {
"kind": "Parameter",
"pos": 17,
"end": 25,
"type": {
"kind": "BooleanKeyword",
"pos": 17,
"end": 25
}
},
"length": 2,
"pos": 10,
"end": 25,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword1.json
+12
View File
@@ -0,0 +1,12 @@
{
"kind": "JSDocTypeReference",
"pos": 1,
"end": 4,
"name": {
"kind": "Identifier",
"pos": 1,
"end": 4,
"originalKeywordKind": "VarKeyword",
"text": "var"
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword2.json
+12
View File
@@ -0,0 +1,12 @@
{
"kind": "JSDocTypeReference",
"pos": 1,
"end": 5,
"name": {
"kind": "Identifier",
"pos": 1,
"end": 5,
"originalKeywordKind": "NullKeyword",
"text": "null"
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.keyword3.json
+11
View File
@@ -0,0 +1,11 @@
{
"kind": "JSDocTypeReference",
"pos": 1,
"end": 10,
"name": {
"kind": "Identifier",
"pos": 1,
"end": 10,
"text": "undefined"
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.newType1.json
+27
View File
@@ -0,0 +1,27 @@
{
"kind": "JSDocConstructorType",
"pos": 1,
"end": 8,
"type": {
"kind": "JSDocTypeReference",
"pos": 5,
"end": 8,
"name": {
"kind": "FirstNode",
"pos": 5,
"end": 8,
"left": {
"kind": "Identifier",
"pos": 5,
"end": 6,
"text": "a"
},
"right": {
"kind": "Identifier",
"pos": 7,
"end": 8,
"text": "b"
}
}
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.nonNullableType.json
+10
View File
@@ -0,0 +1,10 @@
{
"kind": "JSDocNonNullableType",
"pos": 1,
"end": 8,
"type": {
"kind": "NumberKeyword",
"pos": 2,
"end": 8
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.nonNullableType2.json
+10
View File
@@ -0,0 +1,10 @@
{
"kind": "JSDocNonNullableType",
"pos": 1,
"end": 8,
"type": {
"kind": "NumberKeyword",
"pos": 1,
"end": 7
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.nullableType.json
+10
View File
@@ -0,0 +1,10 @@
{
"kind": "JSDocNullableType",
"pos": 1,
"end": 8,
"type": {
"kind": "NumberKeyword",
"pos": 2,
"end": 8
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.nullableType2.json
+10
View File
@@ -0,0 +1,10 @@
{
"kind": "JSDocNullableType",
"pos": 1,
"end": 8,
"type": {
"kind": "NumberKeyword",
"pos": 1,
"end": 7
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.optionalNullable.json
+10
View File
@@ -0,0 +1,10 @@
{
"kind": "JSDocOptionalType",
"pos": 1,
"end": 3,
"type": {
"kind": "JSDocUnknownType",
"pos": 1,
"end": 2
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.optionalType.json
+10
View File
@@ -0,0 +1,10 @@
{
"kind": "JSDocOptionalType",
"pos": 1,
"end": 8,
"type": {
"kind": "NumberKeyword",
"pos": 1,
"end": 7
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType1.json
+11
View File
@@ -0,0 +1,11 @@
{
"kind": "JSDocRecordType",
"pos": 1,
"end": 3,
"members": {
"length": 0,
"pos": 2,
"end": 2,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType2.json
+22
View File
@@ -0,0 +1,22 @@
{
"kind": "JSDocRecordType",
"pos": 1,
"end": 6,
"members": {
"0": {
"kind": "JSDocRecordMember",
"pos": 2,
"end": 5,
"name": {
"kind": "Identifier",
"pos": 2,
"end": 5,
"text": "foo"
}
},
"length": 1,
"pos": 2,
"end": 5,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType3.json
+27
View File
@@ -0,0 +1,27 @@
{
"kind": "JSDocRecordType",
"pos": 1,
"end": 14,
"members": {
"0": {
"kind": "JSDocRecordMember",
"pos": 2,
"end": 13,
"name": {
"kind": "Identifier",
"pos": 2,
"end": 5,
"text": "foo"
},
"type": {
"kind": "NumberKeyword",
"pos": 6,
"end": 13
}
},
"length": 1,
"pos": 2,
"end": 13,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType4.json
+33
View File
@@ -0,0 +1,33 @@
{
"kind": "JSDocRecordType",
"pos": 1,
"end": 11,
"members": {
"0": {
"kind": "JSDocRecordMember",
"pos": 2,
"end": 5,
"name": {
"kind": "Identifier",
"pos": 2,
"end": 5,
"text": "foo"
}
},
"1": {
"kind": "JSDocRecordMember",
"pos": 6,
"end": 10,
"name": {
"kind": "Identifier",
"pos": 6,
"end": 10,
"text": "bar"
}
},
"length": 2,
"pos": 2,
"end": 10,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType5.json
+38
View File
@@ -0,0 +1,38 @@
{
"kind": "JSDocRecordType",
"pos": 1,
"end": 19,
"members": {
"0": {
"kind": "JSDocRecordMember",
"pos": 2,
"end": 13,
"name": {
"kind": "Identifier",
"pos": 2,
"end": 5,
"text": "foo"
},
"type": {
"kind": "NumberKeyword",
"pos": 6,
"end": 13
}
},
"1": {
"kind": "JSDocRecordMember",
"pos": 14,
"end": 18,
"name": {
"kind": "Identifier",
"pos": 14,
"end": 18,
"text": "bar"
}
},
"length": 2,
"pos": 2,
"end": 18,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType6.json
+38
View File
@@ -0,0 +1,38 @@
{
"kind": "JSDocRecordType",
"pos": 1,
"end": 19,
"members": {
"0": {
"kind": "JSDocRecordMember",
"pos": 2,
"end": 5,
"name": {
"kind": "Identifier",
"pos": 2,
"end": 5,
"text": "foo"
}
},
"1": {
"kind": "JSDocRecordMember",
"pos": 6,
"end": 18,
"name": {
"kind": "Identifier",
"pos": 6,
"end": 10,
"text": "bar"
},
"type": {
"kind": "NumberKeyword",
"pos": 11,
"end": 18
}
},
"length": 2,
"pos": 2,
"end": 18,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType7.json
+43
View File
@@ -0,0 +1,43 @@
{
"kind": "JSDocRecordType",
"pos": 1,
"end": 27,
"members": {
"0": {
"kind": "JSDocRecordMember",
"pos": 2,
"end": 13,
"name": {
"kind": "Identifier",
"pos": 2,
"end": 5,
"text": "foo"
},
"type": {
"kind": "NumberKeyword",
"pos": 6,
"end": 13
}
},
"1": {
"kind": "JSDocRecordMember",
"pos": 14,
"end": 26,
"name": {
"kind": "Identifier",
"pos": 14,
"end": 18,
"text": "bar"
},
"type": {
"kind": "NumberKeyword",
"pos": 19,
"end": 26
}
},
"length": 2,
"pos": 2,
"end": 26,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.recordType8.json
+23
View File
@@ -0,0 +1,23 @@
{
"kind": "JSDocRecordType",
"pos": 1,
"end": 11,
"members": {
"0": {
"kind": "JSDocRecordMember",
"pos": 2,
"end": 10,
"name": {
"kind": "Identifier",
"pos": 2,
"end": 10,
"originalKeywordKind": "FunctionKeyword",
"text": "function"
}
},
"length": 1,
"pos": 2,
"end": 10,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.thisType1.json
+27
View File
@@ -0,0 +1,27 @@
{
"kind": "JSDocThisType",
"pos": 1,
"end": 9,
"type": {
"kind": "JSDocTypeReference",
"pos": 6,
"end": 9,
"name": {
"kind": "FirstNode",
"pos": 6,
"end": 9,
"left": {
"kind": "Identifier",
"pos": 6,
"end": 7,
"text": "a"
},
"right": {
"kind": "Identifier",
"pos": 8,
"end": 9,
"text": "b"
}
}
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.topLevelNoParenUnionType.json
+21
View File
@@ -0,0 +1,21 @@
{
"kind": "JSDocUnionType",
"pos": 1,
"end": 14,
"types": {
"0": {
"kind": "NumberKeyword",
"pos": 1,
"end": 7
},
"1": {
"kind": "StringKeyword",
"pos": 8,
"end": 14
},
"length": 2,
"pos": 1,
"end": 14,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType0.json
+11
View File
@@ -0,0 +1,11 @@
{
"kind": "JSDocTupleType",
"pos": 1,
"end": 3,
"types": {
"length": 0,
"pos": 2,
"end": 2,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType1.json
+16
View File
@@ -0,0 +1,16 @@
{
"kind": "JSDocTupleType",
"pos": 1,
"end": 9,
"types": {
"0": {
"kind": "NumberKeyword",
"pos": 2,
"end": 8
},
"length": 1,
"pos": 2,
"end": 8,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType2.json
+21
View File
@@ -0,0 +1,21 @@
{
"kind": "JSDocTupleType",
"pos": 1,
"end": 16,
"types": {
"0": {
"kind": "NumberKeyword",
"pos": 2,
"end": 8
},
"1": {
"kind": "StringKeyword",
"pos": 9,
"end": 15
},
"length": 2,
"pos": 2,
"end": 15,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.tupleType3.json
+26
View File
@@ -0,0 +1,26 @@
{
"kind": "JSDocTupleType",
"pos": 1,
"end": 24,
"types": {
"0": {
"kind": "NumberKeyword",
"pos": 2,
"end": 8
},
"1": {
"kind": "StringKeyword",
"pos": 9,
"end": 15
},
"2": {
"kind": "BooleanKeyword",
"pos": 16,
"end": 23
},
"length": 3,
"pos": 2,
"end": 23,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.typeReference1.json
+22
View File
@@ -0,0 +1,22 @@
{
"kind": "JSDocTypeReference",
"pos": 1,
"end": 11,
"name": {
"kind": "Identifier",
"pos": 1,
"end": 2,
"text": "a"
},
"typeArguments": {
"0": {
"kind": "NumberKeyword",
"pos": 4,
"end": 10
},
"length": 1,
"pos": 4,
"end": 10,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.typeReference2.json
+27
View File
@@ -0,0 +1,27 @@
{
"kind": "JSDocTypeReference",
"pos": 1,
"end": 18,
"name": {
"kind": "Identifier",
"pos": 1,
"end": 2,
"text": "a"
},
"typeArguments": {
"0": {
"kind": "NumberKeyword",
"pos": 4,
"end": 10
},
"1": {
"kind": "StringKeyword",
"pos": 11,
"end": 17
},
"length": 2,
"pos": 4,
"end": 17,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.typeReference3.json
+23
View File
@@ -0,0 +1,23 @@
{
"kind": "JSDocTypeReference",
"pos": 1,
"end": 11,
"name": {
"kind": "FirstNode",
"pos": 1,
"end": 11,
"left": {
"kind": "Identifier",
"pos": 1,
"end": 2,
"text": "a"
},
"right": {
"kind": "Identifier",
"pos": 3,
"end": 11,
"originalKeywordKind": "FunctionKeyword",
"text": "function"
}
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.unionType.json
+21
View File
@@ -0,0 +1,21 @@
{
"kind": "JSDocUnionType",
"pos": 1,
"end": 16,
"types": {
"0": {
"kind": "NumberKeyword",
"pos": 2,
"end": 8
},
"1": {
"kind": "StringKeyword",
"pos": 9,
"end": 15
},
"length": 2,
"pos": 2,
"end": 15,
"arrayKind": 1
}
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.unknownType.json
+5
View File
@@ -0,0 +1,5 @@
{
"kind": "JSDocUnknownType",
"pos": 1,
"end": 2
}
tests/baselines/reference/JSDocParsing/TypeExpressions.parsesCorrectly.variadicType.json
+10
View File
@@ -0,0 +1,10 @@
{
"kind": "JSDocVariadicType",
"pos": 1,
"end": 10,
"type": {
"kind": "NumberKeyword",
"pos": 4,
"end": 10
}
}
tests/cases/unittests/jsDocParsing.ts
+187 -2119
View File
File diff suppressed because it is too large Load Diff