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

Update parser to use node factory

Browse Source
This commit is contained in:
Ron Buckton
2019-09-10 11:46:58 -07:00
parent 1efcfbf4ef
commit ad5ab7cd55
13 changed files with 1240 additions and 1176 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/factory.ts
+109 -27
View File
@@ -269,11 +269,22 @@ namespace ts {
createJSDocFunctionType,
createJSDocVariadicType,
createJSDocNamepathType,
createJSDocTypeLiteral,
createJSDocTypeExpression,
createJSDocSignature,
createJSDocTemplateTag,
createJSDocTypeTag,
createJSDocTypedefTag,
createJSDocReturnTag,
createJSDocThisTag,
createJSDocParamTag,
createJSDocParameterTag,
createJSDocPropertyTag,
createJSDocAuthorTag,
createJSDocAugmentsTag,
createJSDocCallbackTag,
createJSDocClassTag,
createJSDocEnumTag,
createJSDocTag: tagName => createJSDocTag(SyntaxKind.JSDocTag, tagName),
createJSDocComment,
createJsxElement,
updateJsxElement,
@@ -308,7 +319,6 @@ namespace ts {
createPropertyAssignment,
updatePropertyAssignment,
createShorthandPropertyAssignment,
createShorthandPropertyAssignmentInternal,
updateShorthandPropertyAssignment,
createSpreadAssignment,
updateSpreadAssignment,
@@ -442,6 +452,8 @@ namespace ts {
) {
const node = createNode(kind) as T;
node.text = text;
node.hasExtendedUnicodeEscape = undefined;
node.isUnterminated = undefined;
return node;
}
@@ -495,11 +507,11 @@ namespace ts {
originalKeywordKind = undefined;
}
const node = createNode(SyntaxKind.Identifier) as Identifier;
node.escapedText = escapeLeadingUnderscores(text);
node.originalKeywordKind = originalKeywordKind;
node.autoGenerateFlags = GeneratedIdentifierFlags.None;
node.autoGenerateId = 0;
node.escapedText = escapeLeadingUnderscores(text);
node.typeArguments = asNodeArray(typeArguments);
node.autoGenerateFlags = undefined;
node.autoGenerateId = undefined;
return node;
}
@@ -1070,7 +1082,7 @@ namespace ts {
decorators: readonly Decorator[] | undefined,
modifiers: readonly Modifier[] | undefined,
parameters: readonly ParameterDeclaration[],
type: TypeNode
type: TypeNode | undefined
): IndexSignatureDeclaration {
return createBaseSignatureLikeDeclaration(
SyntaxKind.IndexSignature,
@@ -2000,17 +2012,17 @@ namespace ts {
return createNode(SyntaxKind.OmittedExpression) as OmittedExpression;
}
function createExpressionWithTypeArguments(typeArguments: readonly TypeNode[] | undefined, expression: Expression) {
function createExpressionWithTypeArguments(expression: Expression, typeArguments: readonly TypeNode[] | undefined) {
const node = createNode(SyntaxKind.ExpressionWithTypeArguments) as ExpressionWithTypeArguments;
node.expression = parenthesizer().parenthesizeLeftSideOfAccess(expression);
node.typeArguments = typeArguments && parenthesizer().parenthesizeTypeArguments(typeArguments);
return node;
}
function updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, typeArguments: readonly TypeNode[] | undefined, expression: Expression) {
return node.typeArguments !== typeArguments
|| node.expression !== expression
? updateNode(createExpressionWithTypeArguments(typeArguments, expression), node)
function updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, expression: Expression, typeArguments: readonly TypeNode[] | undefined) {
return node.expression !== expression
|| node.typeArguments !== typeArguments
? updateNode(createExpressionWithTypeArguments(expression, typeArguments), node)
: node;
}
@@ -2805,45 +2817,115 @@ namespace ts {
return node;
}
function createJSDocTypeLiteral(propertyTags?: readonly JSDocPropertyLikeTag[], isArrayType?: boolean): JSDocTypeLiteral {
const node = createNode(SyntaxKind.JSDocTypeLiteral) as JSDocTypeLiteral;
node.jsDocPropertyTags = propertyTags;
node.isArrayType = isArrayType;
return node;
}
function createJSDocTypeExpression(type: TypeNode): JSDocTypeExpression {
const node = createNode(SyntaxKind.JSDocTypeExpression) as JSDocTypeExpression;
node.type = type;
return node;
}
function createJSDocTypeTag(typeExpression: JSDocTypeExpression, comment?: string): JSDocTypeTag {
const tag = createJSDocTag<JSDocTypeTag>(
SyntaxKind.JSDocTypeTag, "type");
function createJSDocSignature(typeParameters: readonly JSDocTemplateTag[] | undefined, parameters: readonly JSDocParameterTag[], type?: JSDocReturnTag): JSDocSignature {
const node = createNode(SyntaxKind.JSDocSignature) as JSDocSignature;
node.typeParameters = asNodeArray(typeParameters);
node.parameters = createNodeArray(parameters);
node.type = type;
return node;
}
function createJSDocTemplateTag(tagName: Identifier | undefined, constraint: JSDocTypeExpression | undefined, typeParameters: readonly TypeParameterDeclaration[]): JSDocTemplateTag {
const tag = createJSDocTag<JSDocTemplateTag>(SyntaxKind.JSDocTemplateTag, tagName || createIdentifier("template"));
tag.constraint = constraint;
tag.typeParameters = createNodeArray(typeParameters);
return tag;
}
function createJSDocTypeTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string): JSDocTypeTag {
const tag = createJSDocTag<JSDocTypeTag>(SyntaxKind.JSDocTypeTag, tagName || createIdentifier("type"));
tag.typeExpression = typeExpression;
tag.comment = comment;
return tag;
}
function createJSDocReturnTag(typeExpression?: JSDocTypeExpression, comment?: string): JSDocReturnTag {
const tag = createJSDocTag<JSDocReturnTag>(
SyntaxKind.JSDocReturnTag, "returns");
function createJSDocTypedefTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression, fullName?: Identifier | JSDocNamespaceDeclaration, comment?: string): JSDocTypedefTag {
const tag = createJSDocTag<JSDocTypedefTag>(SyntaxKind.JSDocTypedefTag, tagName || createIdentifier("typedef"));
tag.typeExpression = typeExpression;
tag.fullName = fullName;
tag.name = getJSDocTypeAliasName(fullName);
tag.comment = comment;
return tag;
}
function createJSDocReturnTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression, comment?: string): JSDocReturnTag {
const tag = createJSDocTag<JSDocReturnTag>(SyntaxKind.JSDocReturnTag, tagName || createIdentifier("returns"));
tag.typeExpression = typeExpression;
tag.comment = comment;
return tag;
}
function createJSDocThisTag(typeExpression?: JSDocTypeExpression): JSDocThisTag {
const tag = createJSDocTag<JSDocThisTag>(
SyntaxKind.JSDocThisTag, "this");
function createJSDocThisTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression): JSDocThisTag {
const tag = createJSDocTag<JSDocThisTag>(SyntaxKind.JSDocThisTag, tagName || createIdentifier("this"));
tag.typeExpression = typeExpression;
return tag;
}
function createJSDocParamTag(name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, comment?: string): JSDocParameterTag {
const tag = createJSDocTag<JSDocParameterTag>(
SyntaxKind.JSDocParameterTag, "param");
function createJSDocParameterTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string): JSDocParameterTag {
const tag = createJSDocTag<JSDocParameterTag>(SyntaxKind.JSDocParameterTag, tagName || createIdentifier("param"));
tag.typeExpression = typeExpression;
tag.name = name;
tag.isNameFirst = !!isNameFirst;
tag.isBracketed = isBracketed;
tag.comment = comment;
return tag;
}
function createJSDocPropertyTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string): JSDocPropertyTag {
const tag = createJSDocTag<JSDocPropertyTag>(SyntaxKind.JSDocPropertyTag, tagName || createIdentifier("prop"));
tag.typeExpression = typeExpression;
tag.name = name;
tag.isNameFirst = !!isNameFirst;
tag.isBracketed = isBracketed;
tag.comment = comment;
return tag;
}
function createJSDocAuthorTag(tagName: Identifier | undefined, comment?: string): JSDocAuthorTag {
const tag = createJSDocTag<JSDocAuthorTag>(SyntaxKind.JSDocAuthorTag, tagName || createIdentifier("author"));
tag.comment = comment;
return tag;
}
function createJSDocAugmentsTag(tagName: Identifier | undefined, className: JSDocAugmentsTag["class"]): JSDocAugmentsTag {
const tag = createJSDocTag<JSDocAugmentsTag>(SyntaxKind.JSDocAugmentsTag, tagName || createIdentifier("augments"));
tag.class = className;
return tag;
}
function createJSDocCallbackTag(tagName: Identifier | undefined, typeExpression: JSDocSignature, fullName?: Identifier | JSDocNamespaceDeclaration, comment?: string): JSDocCallbackTag {
const tag = createJSDocTag<JSDocCallbackTag>(SyntaxKind.JSDocCallbackTag, tagName || createIdentifier("callback"));
tag.typeExpression = typeExpression;
tag.fullName = fullName;
tag.name = getJSDocTypeAliasName(fullName);
tag.comment = comment;
return tag;
}
function createJSDocClassTag(tagName: Identifier | undefined): JSDocClassTag {
const tag = createJSDocTag<JSDocClassTag>(SyntaxKind.JSDocClassTag, tagName || createIdentifier("class"));
return tag;
}
function createJSDocEnumTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression): JSDocEnumTag {
const tag = createJSDocTag<JSDocEnumTag>(SyntaxKind.JSDocEnumTag, tagName || createIdentifier("enum"));
tag.typeExpression = typeExpression;
return tag;
}
function createJSDocComment(comment?: string | undefined, tags?: NodeArray<JSDocTag> | undefined) {
const node = createNode(SyntaxKind.JSDocComment) as JSDoc;
node.comment = comment;
@@ -2851,9 +2933,9 @@ namespace ts {
return node;
}
function createJSDocTag<T extends JSDocTag>(kind: T["kind"], tagName: string): T {
function createJSDocTag<T extends JSDocTag>(kind: T["kind"], tagName: Identifier): T {
const node = createNode(kind) as T;
node.tagName = createIdentifier(tagName);
node.tagName = tagName;
return node;
}
@@ -2959,14 +3041,14 @@ namespace ts {
: node;
}
function createJsxAttribute(name: Identifier, initializer: StringLiteral | JsxExpression) {
function createJsxAttribute(name: Identifier, initializer: StringLiteral | JsxExpression | undefined) {
const node = createNode(SyntaxKind.JsxAttribute) as JsxAttribute;
node.name = name;
node.initializer = initializer;
return node;
}
function updateJsxAttribute(node: JsxAttribute, name: Identifier, initializer: StringLiteral | JsxExpression) {
function updateJsxAttribute(node: JsxAttribute, name: Identifier, initializer: StringLiteral | JsxExpression | undefined) {
return node.name !== name
|| node.initializer !== initializer
? updateNode(createJsxAttribute(name, initializer), node)
src/compiler/parser.ts
+1030 -1092
View File
File diff suppressed because it is too large Load Diff
src/compiler/scanner.ts
+6
View File
@@ -21,11 +21,15 @@ namespace ts {
hasUnicodeEscape(): boolean;
hasExtendedUnicodeEscape(): boolean;
hasPrecedingLineBreak(): boolean;
/* @internal */
hasPrecedingJSDocComment(): boolean;
isIdentifier(): boolean;
isReservedWord(): boolean;
isUnterminated(): boolean;
/* @internal */
getTokenFlags(): TokenFlags;
/* @internal */
getNumericLiteralFlags(): TokenFlags;
reScanGreaterToken(): SyntaxKind;
reScanSlashToken(): SyntaxKind;
reScanTemplateToken(): SyntaxKind;
@@ -888,9 +892,11 @@ namespace ts {
hasUnicodeEscape: () => (tokenFlags & TokenFlags.UnicodeEscape) !== 0,
hasExtendedUnicodeEscape: () => (tokenFlags & TokenFlags.ExtendedUnicodeEscape) !== 0,
hasPrecedingLineBreak: () => (tokenFlags & TokenFlags.PrecedingLineBreak) !== 0,
hasPrecedingJSDocComment: () => (tokenFlags & TokenFlags.PrecedingJSDocComment) !== 0,
isIdentifier: () => token === SyntaxKind.Identifier || token > SyntaxKind.LastReservedWord,
isReservedWord: () => token >= SyntaxKind.FirstReservedWord && token <= SyntaxKind.LastReservedWord,
isUnterminated: () => (tokenFlags & TokenFlags.Unterminated) !== 0,
getNumericLiteralFlags: () => tokenFlags & TokenFlags.NumericLiteralFlags,
getTokenFlags: () => tokenFlags,
reScanGreaterToken,
reScanSlashToken,
src/compiler/transformers/declarations.ts
+2 -2
View File
@@ -822,7 +822,7 @@ namespace ts {
checkEntityNameVisibility(input.expression, enclosingDeclaration);
}
const node = visitEachChild(input, visitDeclarationSubtree, context);
return cleanup(factory.updateExpressionWithTypeArguments(node, node.typeArguments, node.expression));
return cleanup(factory.updateExpressionWithTypeArguments(node, node.expression, node.typeArguments));
}
case SyntaxKind.TypeReference: {
checkEntityNameVisibility(input.typeName, enclosingDeclaration);
@@ -1311,7 +1311,7 @@ namespace ts {
if (clause.token === SyntaxKind.ExtendsKeyword) {
const oldDiag = getSymbolAccessibilityDiagnostic;
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(clause.types[0]);
const newClause = factory.updateHeritageClause(clause, map(clause.types, t => factory.updateExpressionWithTypeArguments(t, visitNodes(t.typeArguments, visitDeclarationSubtree), newId)));
const newClause = factory.updateHeritageClause(clause, map(clause.types, t => factory.updateExpressionWithTypeArguments(t, newId, visitNodes(t.typeArguments, visitDeclarationSubtree))));
getSymbolAccessibilityDiagnostic = oldDiag;
return newClause;
}
src/compiler/transformers/ts.ts
+2 -2
View File
@@ -1860,8 +1860,8 @@ namespace ts {
function visitExpressionWithTypeArguments(node: ExpressionWithTypeArguments): ExpressionWithTypeArguments {
return factory.updateExpressionWithTypeArguments(
node,
/*typeArguments*/ undefined,
visitNode(node.expression, visitor, isLeftHandSideExpression)
visitNode(node.expression, visitor, isLeftHandSideExpression),
/*typeArguments*/ undefined
);
}
src/compiler/types.ts
+31 -16
View File
@@ -674,6 +674,9 @@ namespace ts {
| EnumDeclaration
| ModuleDeclaration
| ImportEqualsDeclaration
| ImportDeclaration
| NamespaceExportDeclaration
| ExportAssignment
| IndexSignatureDeclaration
| FunctionTypeNode
| ConstructorTypeNode
@@ -970,7 +973,8 @@ namespace ts {
parent: ObjectLiteralExpression;
kind: SyntaxKind.PropertyAssignment;
name: PropertyName;
questionToken?: QuestionToken;
questionToken?: QuestionToken; // Present for use with reporting a grammar error
exclamationToken?: ExclamationToken; // Present for use with reporting a grammar error
initializer: Expression;
}
@@ -978,8 +982,8 @@ namespace ts {
parent: ObjectLiteralExpression;
kind: SyntaxKind.ShorthandPropertyAssignment;
name: Identifier;
questionToken?: QuestionToken;
exclamationToken?: ExclamationToken;
questionToken?: QuestionToken; // Present for use with reporting a grammar error
exclamationToken?: ExclamationToken; // Present for use with reporting a grammar error
// used when ObjectLiteralExpression is used in ObjectAssignmentPattern
// it is grammar error to appear in actual object initializer
equalsToken?: Token<SyntaxKind.EqualsToken>;
@@ -2334,7 +2338,7 @@ namespace ts {
// import "mod" => importClause = undefined, moduleSpecifier = "mod"
// In rest of the cases, module specifier is string literal corresponding to module
// ImportClause information is shown at its declaration below.
export interface ImportDeclaration extends Statement {
export interface ImportDeclaration extends Statement, JSDocContainer {
kind: SyntaxKind.ImportDeclaration;
parent: SourceFile | ModuleBlock;
importClause?: ImportClause;
@@ -2363,7 +2367,7 @@ namespace ts {
name: Identifier;
}
export interface NamespaceExportDeclaration extends DeclarationStatement {
export interface NamespaceExportDeclaration extends DeclarationStatement, JSDocContainer {
kind: SyntaxKind.NamespaceExportDeclaration;
name: Identifier;
}
@@ -2411,7 +2415,7 @@ namespace ts {
* This is either an `export =` or an `export default` declaration.
* Unless `isExportEquals` is set, this node was parsed as an `export default`.
*/
export interface ExportAssignment extends DeclarationStatement {
export interface ExportAssignment extends DeclarationStatement, JSDocContainer {
kind: SyntaxKind.ExportAssignment;
parent: SourceFile;
isExportEquals?: boolean;
@@ -5827,6 +5831,7 @@ namespace ts {
updateConstructSignature(node: ConstructSignatureDeclaration, typeParameters: NodeArray<TypeParameterDeclaration> | undefined, parameters: NodeArray<ParameterDeclaration>, type: TypeNode | undefined): ConstructSignatureDeclaration;
/* @internal */ createSignatureDeclaration<T extends SignatureDeclaration>(kind: T["kind"], typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, typeArguments?: readonly TypeNode[] | undefined): T;
createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
/* @internal */ createIndexSignature(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): IndexSignatureDeclaration; // tslint:disable-line unified-signatures
updateIndexSignature(node: IndexSignatureDeclaration, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration;
//
@@ -5957,8 +5962,8 @@ namespace ts {
createClassExpression(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
updateClassExpression(node: ClassExpression, decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: Identifier | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, heritageClauses: readonly HeritageClause[] | undefined, members: readonly ClassElement[]): ClassExpression;
createOmittedExpression(): OmittedExpression;
createExpressionWithTypeArguments(typeArguments: readonly TypeNode[] | undefined, expression: Expression): ExpressionWithTypeArguments;
updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, typeArguments: readonly TypeNode[] | undefined, expression: Expression): ExpressionWithTypeArguments;
createExpressionWithTypeArguments(expression: Expression, typeArguments: readonly TypeNode[] | undefined): ExpressionWithTypeArguments;
updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, expression: Expression, typeArguments: readonly TypeNode[] | undefined): ExpressionWithTypeArguments;
createAsExpression(expression: Expression, type: TypeNode): AsExpression;
updateAsExpression(node: AsExpression, expression: Expression, type: TypeNode): AsExpression;
createNonNullExpression(expression: Expression): NonNullExpression;
@@ -6014,6 +6019,7 @@ namespace ts {
createTry(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement;
updateTry(node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement;
createDebuggerStatement(): DebuggerStatement;
// TODO(rbuckton): Add `exclamationToken`:
createVariableDeclaration(name: string | BindingName, type?: TypeNode, initializer?: Expression): VariableDeclaration;
updateVariableDeclaration(node: VariableDeclaration, name: BindingName, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration;
createVariableDeclarationList(declarations: readonly VariableDeclaration[], flags?: NodeFlags): VariableDeclarationList;
@@ -6077,11 +6083,21 @@ namespace ts {
/* @internal */ createJSDocVariadicType(type: TypeNode): JSDocVariadicType;
/* @internal */ createJSDocNamepathType(type: TypeNode): JSDocNamepathType;
/* @internal */ createJSDocTypeExpression(type: TypeNode): JSDocTypeExpression;
/* @internal */ createJSDocTypeTag(typeExpression: JSDocTypeExpression, comment?: string): JSDocTypeTag;
/* @internal */ createJSDocReturnTag(typeExpression?: JSDocTypeExpression, comment?: string): JSDocReturnTag;
/* @internal */ createJSDocThisTag(typeExpression?: JSDocTypeExpression): JSDocThisTag;
/* @internal */ createJSDocParamTag(name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, comment?: string): JSDocParameterTag;
/* @internal */ createJSDocTypeLiteral(jsDocPropertyTags?: readonly JSDocPropertyLikeTag[], isArrayType?: boolean): JSDocTypeLiteral;
/* @internal */ createJSDocSignature(typeParameters: readonly JSDocTemplateTag[] | undefined, parameters: readonly JSDocParameterTag[], type?: JSDocReturnTag): JSDocSignature;
/* @internal */ createJSDocTemplateTag(tagName: Identifier | undefined, constraint: JSDocTypeExpression | undefined, typeParameters: readonly TypeParameterDeclaration[]): JSDocTemplateTag;
/* @internal */ createJSDocTypedefTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression | JSDocTypeLiteral, fullName?: Identifier | JSDocNamespaceDeclaration, comment?: string): JSDocTypedefTag;
/* @internal */ createJSDocTypeTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string): JSDocTypeTag;
/* @internal */ createJSDocReturnTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression, comment?: string): JSDocReturnTag;
/* @internal */ createJSDocThisTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression): JSDocThisTag;
/* @internal */ createJSDocAuthorTag(tagName: Identifier | undefined, comment?: string): JSDocAuthorTag;
/* @internal */ createJSDocAugmentsTag(tagName: Identifier | undefined, className: JSDocAugmentsTag["class"]): JSDocAugmentsTag;
/* @internal */ createJSDocClassTag(tagName: Identifier | undefined): JSDocClassTag;
/* @internal */ createJSDocCallbackTag(tagName: Identifier | undefined, typeExpression: JSDocSignature, fullName?: Identifier | JSDocNamespaceDeclaration, comment?: string): JSDocCallbackTag;
/* @internal */ createJSDocEnumTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression): JSDocEnumTag;
/* @internal */ createJSDocParameterTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string): JSDocParameterTag;
/* @internal */ createJSDocPropertyTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string): JSDocPropertyTag;
/* @internal */ createJSDocTag(tagName: Identifier): JSDocTag;
/* @internal */ createJSDocComment(comment?: string | undefined, tags?: NodeArray<JSDocTag> | undefined): JSDoc;
//
@@ -6102,8 +6118,8 @@ namespace ts {
createJsxOpeningFragment(): JsxOpeningFragment;
createJsxJsxClosingFragment(): JsxClosingFragment;
updateJsxFragment(node: JsxFragment, openingFragment: JsxOpeningFragment, children: readonly JsxChild[], closingFragment: JsxClosingFragment): JsxFragment;
createJsxAttribute(name: Identifier, initializer: StringLiteral | JsxExpression): JsxAttribute;
updateJsxAttribute(node: JsxAttribute, name: Identifier, initializer: StringLiteral | JsxExpression): JsxAttribute;
createJsxAttribute(name: Identifier, initializer: StringLiteral | JsxExpression | undefined): JsxAttribute;
updateJsxAttribute(node: JsxAttribute, name: Identifier, initializer: StringLiteral | JsxExpression | undefined): JsxAttribute;
createJsxAttributes(properties: readonly JsxAttributeLike[]): JsxAttributes;
updateJsxAttributes(node: JsxAttributes, properties: readonly JsxAttributeLike[]): JsxAttributes;
createJsxSpreadAttribute(expression: Expression): JsxSpreadAttribute;
@@ -6131,7 +6147,6 @@ namespace ts {
createPropertyAssignment(name: string | PropertyName, initializer: Expression): PropertyAssignment;
updatePropertyAssignment(node: PropertyAssignment, name: PropertyName, initializer: Expression): PropertyAssignment;
createShorthandPropertyAssignment(name: string | Identifier, objectAssignmentInitializer?: Expression): ShorthandPropertyAssignment;
/* @internal */ createShorthandPropertyAssignmentInternal(decorators: readonly Decorator[] | undefined, modifiers: readonly Modifier[] | undefined, name: string | Identifier, equalsToken: EqualsToken | undefined, objectAssignmentInitializer: Expression | undefined): ShorthandPropertyAssignment;
updateShorthandPropertyAssignment(node: ShorthandPropertyAssignment, name: Identifier, objectAssignmentInitializer: Expression | undefined): ShorthandPropertyAssignment;
createSpreadAssignment(expression: Expression): SpreadAssignment;
updateSpreadAssignment(node: SpreadAssignment, expression: Expression): SpreadAssignment;
src/compiler/utilities.ts
+24 -7
View File
@@ -3950,13 +3950,7 @@ namespace ts {
}
export function getModifierFlagsNoCache(node: Node): ModifierFlags {
let flags = ModifierFlags.None;
if (node.modifiers) {
for (const modifier of node.modifiers) {
flags |= modifierToFlag(modifier.kind);
}
}
let flags = modifiersToFlags(node.modifiers);
if (node.flags & NodeFlags.NestedNamespace || (node.kind === SyntaxKind.Identifier && (<Identifier>node).isInJSDocNamespace)) {
flags |= ModifierFlags.Export;
@@ -3965,6 +3959,16 @@ namespace ts {
return flags;
}
export function modifiersToFlags(modifiers: NodeArray<Modifier> | undefined) {
let flags = ModifierFlags.None;
if (modifiers) {
for (const modifier of modifiers) {
flags |= modifierToFlag(modifier.kind);
}
}
return flags;
}
export function modifierToFlag(token: SyntaxKind): ModifierFlags {
switch (token) {
case SyntaxKind.StaticKeyword: return ModifierFlags.Static;
@@ -7087,6 +7091,19 @@ namespace ts {
return !!jsDoc && jsDoc.length > 0;
}
/* @internal */
export function getJSDocTypeAliasName(fullName: JSDocNamespaceBody | undefined) {
if (fullName) {
let rightNode = fullName;
while (true) {
if (isIdentifier(rightNode) || !rightNode.body) {
return isIdentifier(rightNode) ? rightNode : rightNode.name;
}
rightNode = rightNode.body;
}
}
}
/** True if has type node attached to it. */
/* @internal */
export function hasType(node: Node): node is HasType {
src/compiler/visitor.ts
+2 -2
View File
@@ -585,8 +585,8 @@ namespace ts {
case SyntaxKind.ExpressionWithTypeArguments:
return factory.updateExpressionWithTypeArguments(<ExpressionWithTypeArguments>node,
nodesVisitor((<ExpressionWithTypeArguments>node).typeArguments, visitor, isTypeNode),
visitNode((<ExpressionWithTypeArguments>node).expression, visitor, isExpression));
visitNode((<ExpressionWithTypeArguments>node).expression, visitor, isExpression),
nodesVisitor((<ExpressionWithTypeArguments>node).typeArguments, visitor, isTypeNode));
case SyntaxKind.AsExpression:
return factory.updateAsExpression(<AsExpression>node,
src/services/codefixes/inferFromUsage.ts
+6 -6
View File
@@ -126,7 +126,7 @@ namespace ts.codefix {
const typeNode = getTypeNodeIfAccessible(type, parent, program, host);
if (typeNode) {
// Note that the codefix will never fire with an existing `@type` tag, so there is no need to merge tags
const typeTag = createJSDocTypeTag(createJSDocTypeExpression(typeNode), /*comment*/ "");
const typeTag = createJSDocTypeTag(/*tagName*/ undefined, createJSDocTypeExpression(typeNode), /*comment*/ "");
addJSDocTags(changes, sourceFile, cast(parent.parent.parent, isExpressionStatement), [typeTag]);
}
return parent;
@@ -254,7 +254,7 @@ namespace ts.codefix {
function annotateJSDocThis(changes: textChanges.ChangeTracker, sourceFile: SourceFile, containingFunction: FunctionLike, typeNode: TypeNode) {
addJSDocTags(changes, sourceFile, containingFunction, [
createJSDocThisTag(createJSDocTypeExpression(typeNode)),
createJSDocThisTag(/*tagName*/ undefined, createJSDocTypeExpression(typeNode)),
]);
}
@@ -283,7 +283,7 @@ namespace ts.codefix {
return;
}
const typeExpression = createJSDocTypeExpression(typeNode);
const typeTag = isGetAccessorDeclaration(declaration) ? createJSDocReturnTag(typeExpression, "") : createJSDocTypeTag(typeExpression, "");
const typeTag = isGetAccessorDeclaration(declaration) ? createJSDocReturnTag(/*tagName*/ undefined, typeExpression, "") : createJSDocTypeTag(/*tagName*/ undefined, typeExpression, "");
addJSDocTags(changes, sourceFile, parent, [typeTag]);
}
else {
@@ -305,7 +305,7 @@ namespace ts.codefix {
const typeNode = inference.type && getTypeNodeIfAccessible(inference.type, param, program, host);
const name = getSynthesizedClone(param.name);
setEmitFlags(name, EmitFlags.NoComments | EmitFlags.NoNestedComments);
return typeNode && createJSDocParamTag(name, !!inference.isOptional, createJSDocTypeExpression(typeNode), "");
return typeNode && syntheticNodeFactory.createJSDocParameterTag(/*tagName*/ undefined, name, !!inference.isOptional, createJSDocTypeExpression(typeNode), /*isNameFirst*/ undefined, "");
});
addJSDocTags(changes, sourceFile, signature, paramTags);
}
@@ -341,11 +341,11 @@ namespace ts.codefix {
const oldParam = oldTag as JSDocParameterTag;
const newParam = newTag as JSDocParameterTag;
return isIdentifier(oldParam.name) && isIdentifier(newParam.name) && oldParam.name.escapedText === newParam.name.escapedText
? createJSDocParamTag(newParam.name, newParam.isBracketed, newParam.typeExpression, oldParam.comment)
? syntheticNodeFactory.createJSDocParameterTag(/*tagName*/ undefined, newParam.name, newParam.isBracketed, newParam.typeExpression, /*isNameFirst*/ undefined, oldParam.comment)
: undefined;
}
case SyntaxKind.JSDocReturnTag:
return createJSDocReturnTag((newTag as JSDocReturnTag).typeExpression, oldTag.comment);
return createJSDocReturnTag(/*tagName*/ undefined, (newTag as JSDocReturnTag).typeExpression, oldTag.comment);
}
}
src/services/factoryCompat.ts
+8 -3
View File
@@ -142,8 +142,6 @@ namespace ts {
createSpread,
updateSpread,
createOmittedExpression,
createExpressionWithTypeArguments,
updateExpressionWithTypeArguments,
createAsExpression,
updateAsExpression,
createNonNullExpression,
@@ -241,7 +239,6 @@ namespace ts {
createJSDocTypeTag,
createJSDocReturnTag,
createJSDocThisTag,
createJSDocParamTag,
createJSDocComment,
createJsxElement,
updateJsxElement,
@@ -479,6 +476,14 @@ namespace ts {
? updateNode(createPropertySignature(modifiers, name, questionToken, type, initializer), node)
: node;
}
export function createExpressionWithTypeArguments(typeArguments: readonly TypeNode[] | undefined, expression: Expression) {
return syntheticNodeFactory.createExpressionWithTypeArguments(expression, typeArguments);
}
export function updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, typeArguments: readonly TypeNode[] | undefined, expression: Expression) {
return syntheticNodeFactory.updateExpressionWithTypeArguments(node, expression, typeArguments);
}
}
/* @internal */
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.@link tags.json
+2 -2
View File
@@ -5,6 +5,7 @@
"flags": "JSDoc",
"modifierFlagsCache": 0,
"transformFlags": 0,
"comment": "{@link first link}\nInside {@link link text} thing",
"tags": {
"0": {
"kind": "JSDocTag",
@@ -25,6 +26,5 @@
"length": 1,
"pos": 63,
"end": 68
},
"comment": "{@link first link}\nInside {@link link text} thing"
}
}
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.Nested @param tags.json
+2 -1
View File
@@ -88,7 +88,8 @@
"isBracketed": false,
"comment": "Doc for f"
}
]
],
"isArrayType": false
}
},
"name": {
tests/baselines/reference/JSDocParsing/DocComments.parsesCorrectly.typedefTagWithChildrenTags.json
+16 -16
View File
@@ -20,22 +20,6 @@
"transformFlags": 0,
"escapedText": "typedef"
},
"fullName": {
"kind": "Identifier",
"pos": 17,
"end": 23,
"modifierFlagsCache": 0,
"transformFlags": 0,
"escapedText": "People"
},
"name": {
"kind": "Identifier",
"pos": 17,
"end": 23,
"modifierFlagsCache": 0,
"transformFlags": 0,
"escapedText": "People"
},
"typeExpression": {
"kind": "JSDocTypeLiteral",
"pos": 8,
@@ -122,6 +106,22 @@
"isBracketed": false
}
]
},
"fullName": {
"kind": "Identifier",
"pos": 17,
"end": 23,
"modifierFlagsCache": 0,
"transformFlags": 0,
"escapedText": "People"
},
"name": {
"kind": "Identifier",
"pos": 17,
"end": 23,
"modifierFlagsCache": 0,
"transformFlags": 0,
"escapedText": "People"
}
},
"length": 1,