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

Allow and emit accessors on interfaces

Browse Source
This commit is contained in:
Ron Buckton
2019-08-07 11:38:45 -07:00
parent 37c4f24ef3
commit 77fc6f3b2e
11 changed files with 490 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/binder.ts
+10
View File
@@ -1502,6 +1502,8 @@ namespace ts {
case SyntaxKind.MethodSignature:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.CallSignature:
case SyntaxKind.JSDocSignature:
case SyntaxKind.JSDocFunctionType:
@@ -1600,6 +1602,8 @@ namespace ts {
case SyntaxKind.Constructor:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.FunctionDeclaration:
case SyntaxKind.FunctionExpression:
case SyntaxKind.ArrowFunction:
@@ -2236,8 +2240,10 @@ namespace ts {
case SyntaxKind.Constructor:
return declareSymbolAndAddToSymbolTable(<Declaration>node, SymbolFlags.Constructor, /*symbolExcludes:*/ SymbolFlags.None);
case SyntaxKind.GetAccessor:
case SyntaxKind.GetAccessorSignature:
return bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.GetAccessor, SymbolFlags.GetAccessorExcludes);
case SyntaxKind.SetAccessor:
case SyntaxKind.SetAccessorSignature:
return bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.SetAccessor, SymbolFlags.SetAccessorExcludes);
case SyntaxKind.FunctionType:
case SyntaxKind.JSDocFunctionType:
@@ -3750,6 +3756,8 @@ namespace ts {
case SyntaxKind.TypeParameter:
case SyntaxKind.PropertySignature:
case SyntaxKind.MethodSignature:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.CallSignature:
case SyntaxKind.ConstructSignature:
case SyntaxKind.IndexSignature:
@@ -3934,6 +3942,8 @@ namespace ts {
case SyntaxKind.TypeParameter:
case SyntaxKind.PropertySignature:
case SyntaxKind.MethodSignature:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.CallSignature:
case SyntaxKind.ConstructSignature:
case SyntaxKind.IndexSignature:
src/compiler/checker.ts
+91 -46
View File
@@ -4902,6 +4902,8 @@ namespace ts {
case SyntaxKind.PropertySignature:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.MethodDeclaration:
case SyntaxKind.MethodSignature:
if (hasModifier(node, ModifierFlags.Private | ModifierFlags.Protected)) {
@@ -5356,13 +5358,14 @@ namespace ts {
}
if (declaration.kind === SyntaxKind.Parameter) {
const func = <FunctionLikeDeclaration>declaration.parent;
const func = declaration.parent;
// For a parameter of a set accessor, use the type of the get accessor if one is present
if (func.kind === SyntaxKind.SetAccessor && !hasNonBindableDynamicName(func)) {
const getter = getDeclarationOfKind<AccessorDeclaration>(getSymbolOfNode(declaration.parent), SyntaxKind.GetAccessor);
if (isSetAccessorLike(func) && !hasNonBindableDynamicName(func)) {
const getAccessorKind = func.kind === SyntaxKind.SetAccessorSignature ? SyntaxKind.GetAccessorSignature : SyntaxKind.GetAccessor;
const getter = getDeclarationOfKind<AccessorLike>(getSymbolOfNode(declaration.parent), getAccessorKind);
if (getter) {
const getterSignature = getSignatureFromDeclaration(getter);
const thisParameter = getAccessorThisParameter(func as AccessorDeclaration);
const thisParameter = getAccessorThisParameter(func);
if (thisParameter && declaration === thisParameter) {
// Use the type from the *getter*
Debug.assert(!thisParameter.type);
@@ -5866,9 +5869,9 @@ namespace ts {
return type;
}
function getAnnotatedAccessorTypeNode(accessor: AccessorDeclaration | undefined): TypeNode | undefined {
function getAnnotatedAccessorTypeNode(accessor: AccessorLike | undefined): TypeNode | undefined {
if (accessor) {
if (accessor.kind === SyntaxKind.GetAccessor) {
if (isGetAccessorLike(accessor)) {
const getterTypeAnnotation = getEffectiveReturnTypeNode(accessor);
return getterTypeAnnotation;
}
@@ -5880,12 +5883,12 @@ namespace ts {
return undefined;
}
function getAnnotatedAccessorType(accessor: AccessorDeclaration | undefined): Type | undefined {
function getAnnotatedAccessorType(accessor: AccessorLike | undefined): Type | undefined {
const node = getAnnotatedAccessorTypeNode(accessor);
return node && getTypeFromTypeNode(node);
}
function getAnnotatedAccessorThisParameter(accessor: AccessorDeclaration): Symbol | undefined {
function getAnnotatedAccessorThisParameter(accessor: AccessorLike): Symbol | undefined {
const parameter = getAccessorThisParameter(accessor);
return parameter && parameter.symbol;
}
@@ -5900,8 +5903,10 @@ namespace ts {
}
function getTypeOfAccessorsWorker(symbol: Symbol): Type {
const getter = getDeclarationOfKind<AccessorDeclaration>(symbol, SyntaxKind.GetAccessor);
const setter = getDeclarationOfKind<AccessorDeclaration>(symbol, SyntaxKind.SetAccessor);
const getter = getDeclarationOfKind<AccessorDeclaration>(symbol, SyntaxKind.GetAccessor) ||
getDeclarationOfKind<AccessorSignature>(symbol, SyntaxKind.GetAccessorSignature);
const setter = getDeclarationOfKind<AccessorDeclaration>(symbol, SyntaxKind.SetAccessor) ||
getDeclarationOfKind<AccessorSignature>(symbol, SyntaxKind.SetAccessorSignature);
if (getter && isInJSFile(getter)) {
const jsDocType = getTypeForDeclarationFromJSDocComment(getter);
@@ -5929,7 +5934,7 @@ namespace ts {
}
else {
// If there are no specified types, try to infer it from the body of the get accessor if it exists.
if (getter && getter.body) {
if (getter && isGetAccessorDeclaration(getter) && getter.body) {
type = getReturnTypeFromBody(getter);
}
// Otherwise, fall back to 'any'.
@@ -5950,7 +5955,8 @@ namespace ts {
if (!popTypeResolution()) {
type = anyType;
if (noImplicitAny) {
const getter = getDeclarationOfKind<AccessorDeclaration>(symbol, SyntaxKind.GetAccessor);
const getter = getDeclarationOfKind<AccessorDeclaration>(symbol, SyntaxKind.GetAccessor) ||
getDeclarationOfKind<AccessorSignature>(symbol, SyntaxKind.GetAccessorSignature);
error(getter, Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol));
}
}
@@ -6748,7 +6754,9 @@ namespace ts {
case SyntaxKind.Constructor:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
return isThislessFunctionLikeDeclaration(<FunctionLikeDeclaration | AccessorDeclaration>declaration);
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
return isThislessFunctionLikeDeclaration(<FunctionLikeDeclaration>declaration);
}
}
}
@@ -8562,11 +8570,12 @@ namespace ts {
}
// If only one accessor includes a this-type annotation, the other behaves as if it had the same type annotation
if ((declaration.kind === SyntaxKind.GetAccessor || declaration.kind === SyntaxKind.SetAccessor) &&
if (isAccessorDeclaration(declaration) &&
!hasNonBindableDynamicName(declaration) &&
(!hasThisParameter || !thisParameter)) {
const otherKind = declaration.kind === SyntaxKind.GetAccessor ? SyntaxKind.SetAccessor : SyntaxKind.GetAccessor;
const other = getDeclarationOfKind<AccessorDeclaration>(getSymbolOfNode(declaration), otherKind);
const symbol = getSymbolOfNode(declaration);
const other = getDeclarationOfKind<AccessorDeclaration>(symbol, getOtherAccessorDeclarationKind(declaration)) ||
getDeclarationOfKind<AccessorSignature>(symbol, getOtherAccessorSignatureKind(declaration));
if (other) {
thisParameter = getAnnotatedAccessorThisParameter(other);
}
@@ -8779,12 +8788,13 @@ namespace ts {
if (typeNode) {
return getTypeFromTypeNode(typeNode);
}
if (declaration.kind === SyntaxKind.GetAccessor && !hasNonBindableDynamicName(declaration)) {
if (isGetAccessorLike(declaration) && !hasNonBindableDynamicName(declaration)) {
const jsDocType = isInJSFile(declaration) && getTypeForDeclarationFromJSDocComment(declaration);
if (jsDocType) {
return jsDocType;
}
const setter = getDeclarationOfKind<AccessorDeclaration>(getSymbolOfNode(declaration), SyntaxKind.SetAccessor);
const setter = getDeclarationOfKind<AccessorDeclaration>(getSymbolOfNode(declaration), SyntaxKind.SetAccessor) ||
getDeclarationOfKind<AccessorSignature>(getSymbolOfNode(declaration), SyntaxKind.SetAccessorSignature);
const setterType = getAnnotatedAccessorType(setter);
if (setterType) {
return setterType;
@@ -15177,6 +15187,8 @@ namespace ts {
case SyntaxKind.MethodSignature:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.FunctionExpression:
case SyntaxKind.ArrowFunction:
if (noImplicitAny && !(declaration as NamedDeclaration).name) {
@@ -18566,13 +18578,17 @@ namespace ts {
return container.kind === SyntaxKind.MethodDeclaration ||
container.kind === SyntaxKind.MethodSignature ||
container.kind === SyntaxKind.GetAccessor ||
container.kind === SyntaxKind.SetAccessor;
container.kind === SyntaxKind.SetAccessor ||
container.kind === SyntaxKind.GetAccessorSignature ||
container.kind === SyntaxKind.SetAccessorSignature;
}
else {
return container.kind === SyntaxKind.MethodDeclaration ||
container.kind === SyntaxKind.MethodSignature ||
container.kind === SyntaxKind.GetAccessor ||
container.kind === SyntaxKind.SetAccessor ||
container.kind === SyntaxKind.GetAccessorSignature ||
container.kind === SyntaxKind.SetAccessorSignature ||
container.kind === SyntaxKind.PropertyDeclaration ||
container.kind === SyntaxKind.PropertySignature ||
container.kind === SyntaxKind.Constructor;
@@ -25861,7 +25877,7 @@ namespace ts {
}
}
function checkAccessorDeclaration(node: AccessorDeclaration) {
function checkAccessorDeclaration(node: AccessorLike) {
if (produceDiagnostics) {
// Grammar checking accessors
if (!checkGrammarFunctionLikeDeclaration(node) && !checkGrammarAccessor(node)) checkGrammarComputedPropertyName(node.name);
@@ -25884,8 +25900,9 @@ namespace ts {
if (!hasNonBindableDynamicName(node)) {
// TypeScript 1.0 spec (April 2014): 8.4.3
// Accessors for the same member name must specify the same accessibility.
const otherKind = node.kind === SyntaxKind.GetAccessor ? SyntaxKind.SetAccessor : SyntaxKind.GetAccessor;
const otherAccessor = getDeclarationOfKind<AccessorDeclaration>(getSymbolOfNode(node), otherKind);
const symbol = getSymbolOfNode(node);
const otherAccessor = getDeclarationOfKind<AccessorDeclaration>(symbol, getOtherAccessorDeclarationKind(node)) ||
getDeclarationOfKind<AccessorSignature>(symbol, getOtherAccessorSignatureKind(node));
if (otherAccessor) {
const nodeFlags = getModifierFlags(node);
const otherFlags = getModifierFlags(otherAccessor);
@@ -25907,10 +25924,12 @@ namespace ts {
checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType);
}
}
checkSourceElement(node.body);
if (isAccessorDeclaration(node)) {
checkSourceElement(node.body);
}
}
function checkAccessorDeclarationTypesIdentical(first: AccessorDeclaration, second: AccessorDeclaration, getAnnotatedType: (a: AccessorDeclaration) => Type | undefined, message: DiagnosticMessage) {
function checkAccessorDeclarationTypesIdentical(first: AccessorLike, second: AccessorLike, getAnnotatedType: (a: AccessorLike) => Type | undefined, message: DiagnosticMessage) {
const firstType = getAnnotatedType(first);
const secondType = getAnnotatedType(second);
if (firstType && secondType && !isTypeIdenticalTo(firstType, secondType)) {
@@ -27199,6 +27218,8 @@ namespace ts {
checkUnusedTypeParameters(node, addDiagnostic);
break;
case SyntaxKind.MethodSignature:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.CallSignature:
case SyntaxKind.ConstructSignature:
case SyntaxKind.FunctionType:
@@ -27471,7 +27492,9 @@ namespace ts {
node.kind === SyntaxKind.MethodDeclaration ||
node.kind === SyntaxKind.MethodSignature ||
node.kind === SyntaxKind.GetAccessor ||
node.kind === SyntaxKind.SetAccessor) {
node.kind === SyntaxKind.SetAccessor ||
node.kind === SyntaxKind.GetAccessorSignature ||
node.kind === SyntaxKind.SetAccessorSignature) {
// it is ok to have member named '_super' or '_this' - member access is always qualified
return false;
}
@@ -30326,6 +30349,8 @@ namespace ts {
return checkConstructorDeclaration(<ConstructorDeclaration>node);
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
return checkAccessorDeclaration(<AccessorDeclaration>node);
case SyntaxKind.TypeReference:
return checkTypeReferenceNode(<TypeReferenceNode>node);
@@ -30564,7 +30589,9 @@ namespace ts {
break;
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
checkAccessorDeclaration(<AccessorDeclaration>node);
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
checkAccessorDeclaration(<AccessorLike>node);
break;
case SyntaxKind.ClassExpression:
checkClassExpressionDeferred(<ClassExpression>node);
@@ -31931,8 +31958,8 @@ namespace ts {
},
getJsxFactoryEntity: location => location ? (getJsxNamespace(location), (getSourceFileOfNode(location).localJsxFactory || _jsxFactoryEntity)) : _jsxFactoryEntity,
getAllAccessorDeclarations(accessor: AccessorDeclaration): AllAccessorDeclarations {
accessor = getParseTreeNode(accessor, isGetOrSetAccessorDeclaration)!; // TODO: GH#18217
const otherKind = accessor.kind === SyntaxKind.SetAccessor ? SyntaxKind.GetAccessor : SyntaxKind.SetAccessor;
accessor = getParseTreeNode(accessor, isAccessorDeclaration)!; // TODO: GH#18217
const otherKind = getOtherAccessorDeclarationKind(accessor);
const otherAccessor = getDeclarationOfKind<AccessorDeclaration>(getSymbolOfNode(accessor), otherKind);
const firstAccessor = otherAccessor && (otherAccessor.pos < accessor.pos) ? otherAccessor : accessor;
const secondAccessor = otherAccessor && (otherAccessor.pos < accessor.pos) ? accessor : otherAccessor;
@@ -31945,6 +31972,21 @@ namespace ts {
getAccessor
};
},
getAllAccessorSignatures(accessor: AccessorSignature): AllAccessorSignatures {
accessor = getParseTreeNode(accessor, isAccessorSignature)!; // TODO: GH#18217
const otherKind = getOtherAccessorSignatureKind(accessor);
const otherAccessor = getDeclarationOfKind<AccessorSignature>(getSymbolOfNode(accessor), otherKind);
const firstAccessor = otherAccessor && (otherAccessor.pos < accessor.pos) ? otherAccessor : accessor;
const secondAccessor = otherAccessor && (otherAccessor.pos < accessor.pos) ? accessor : otherAccessor;
const setAccessor = accessor.kind === SyntaxKind.SetAccessorSignature ? accessor : otherAccessor as SetAccessorSignature;
const getAccessor = accessor.kind === SyntaxKind.GetAccessorSignature ? accessor : otherAccessor as GetAccessorSignature;
return {
firstAccessor,
secondAccessor,
setAccessor,
getAccessor
};
},
getSymbolOfExternalModuleSpecifier: moduleName => resolveExternalModuleNameWorker(moduleName, moduleName, /*moduleNotFoundError*/ undefined),
isBindingCapturedByNode: (node, decl) => {
const parseNode = getParseTreeNode(node);
@@ -32493,6 +32535,8 @@ namespace ts {
switch (node.kind) {
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.Constructor:
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.PropertySignature:
@@ -32624,7 +32668,7 @@ namespace ts {
return false;
}
function checkGrammarFunctionLikeDeclaration(node: FunctionLikeDeclaration | MethodSignature): boolean {
function checkGrammarFunctionLikeDeclaration(node: FunctionLikeDeclaration | MethodSignature | AccessorSignature): boolean {
// Prevent cascading error by short-circuit
const file = getSourceFileOfNode(node);
return checkGrammarDecoratorsAndModifiers(node) || checkGrammarTypeParameterList(node.typeParameters, file) ||
@@ -33036,27 +33080,28 @@ namespace ts {
return false;
}
function checkGrammarAccessor(accessor: AccessorDeclaration): boolean {
const kind = accessor.kind;
if (languageVersion < ScriptTarget.ES5) {
return grammarErrorOnNode(accessor.name, Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher);
function checkGrammarAccessor(accessor: AccessorLike): boolean {
if (isAccessorDeclaration(accessor)) {
if (languageVersion < ScriptTarget.ES5) {
return grammarErrorOnNode(accessor.name, Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher);
}
else if (accessor.body === undefined && !hasModifier(accessor, ModifierFlags.Abstract) && !(accessor.flags & NodeFlags.Ambient)) {
return grammarErrorAtPos(accessor, accessor.end - 1, ";".length, Diagnostics._0_expected, "{");
}
else if (accessor.body && hasModifier(accessor, ModifierFlags.Abstract)) {
return grammarErrorOnNode(accessor, Diagnostics.An_abstract_accessor_cannot_have_an_implementation);
}
}
else if (accessor.body === undefined && !hasModifier(accessor, ModifierFlags.Abstract) && !(accessor.flags & NodeFlags.Ambient)) {
return grammarErrorAtPos(accessor, accessor.end - 1, ";".length, Diagnostics._0_expected, "{");
}
else if (accessor.body && hasModifier(accessor, ModifierFlags.Abstract)) {
return grammarErrorOnNode(accessor, Diagnostics.An_abstract_accessor_cannot_have_an_implementation);
}
else if (accessor.typeParameters) {
if (accessor.typeParameters) {
return grammarErrorOnNode(accessor.name, Diagnostics.An_accessor_cannot_have_type_parameters);
}
else if (!doesAccessorHaveCorrectParameterCount(accessor)) {
return grammarErrorOnNode(accessor.name,
kind === SyntaxKind.GetAccessor ?
isGetAccessorLike(accessor) ?
Diagnostics.A_get_accessor_cannot_have_parameters :
Diagnostics.A_set_accessor_must_have_exactly_one_parameter);
}
else if (kind === SyntaxKind.SetAccessor) {
else if (isSetAccessorLike(accessor)) {
if (accessor.type) {
return grammarErrorOnNode(accessor.name, Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation);
}
@@ -33080,12 +33125,12 @@ namespace ts {
* A get accessor has no parameters or a single `this` parameter.
* A set accessor has one parameter or a `this` parameter and one more parameter.
*/
function doesAccessorHaveCorrectParameterCount(accessor: AccessorDeclaration) {
return getAccessorThisParameter(accessor) || accessor.parameters.length === (accessor.kind === SyntaxKind.GetAccessor ? 0 : 1);
function doesAccessorHaveCorrectParameterCount(accessor: AccessorLike) {
return getAccessorThisParameter(accessor) || accessor.parameters.length === (isGetAccessorLike(accessor) ? 0 : 1);
}
function getAccessorThisParameter(accessor: AccessorDeclaration): ParameterDeclaration | undefined {
if (accessor.parameters.length === (accessor.kind === SyntaxKind.GetAccessor ? 1 : 2)) {
function getAccessorThisParameter(accessor: AccessorLike): ParameterDeclaration | undefined {
if (accessor.parameters.length === (isGetAccessorLike(accessor) ? 1 : 2)) {
return getThisParameter(accessor);
}
}
src/compiler/diagnosticMessages.json
+21
View File
@@ -3036,6 +3036,27 @@
"code": 4105
},
"Parameter type of setter '{0}' from exported interface has or is using name '{1}' from private module '{2}'.": {
"category": "Error",
"code": 4106
},
"Parameter type of setter '{0}' from exported interface has or is using private name '{1}'.": {
"category": "Error",
"code": 4107
},
"Return type of getter '{0}' from exported interface has or is using name '{1}' from external module {2} but cannot be named.": {
"category": "Error",
"code": 4108
},
"Return type of getter '{0}' from exported interface has or is using name '{1}' from private module '{2}'.": {
"category": "Error",
"code": 4109
},
"Return type of getter '{0}' from exported interface has or is using private name '{1}'.": {
"category": "Error",
"code": 4110
},
"The current host does not support the '{0}' option.": {
"category": "Error",
"code": 5001
src/compiler/emitter.ts
+17
View File
@@ -617,6 +617,7 @@ namespace ts {
isLiteralConstDeclaration: notImplemented,
getJsxFactoryEntity: notImplemented,
getAllAccessorDeclarations: notImplemented,
getAllAccessorSignatures: notImplemented,
getSymbolOfExternalModuleSpecifier: notImplemented,
isBindingCapturedByNode: notImplemented,
};
@@ -1211,6 +1212,9 @@ namespace ts {
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
return emitAccessorDeclaration(<AccessorDeclaration>node);
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
return emitAccessorSignature(<AccessorSignature>node);
case SyntaxKind.CallSignature:
return emitCallSignature(<CallSignatureDeclaration>node);
case SyntaxKind.ConstructSignature:
@@ -1865,6 +1869,19 @@ namespace ts {
emitSignatureAndBody(node, emitSignatureHead);
}
function emitAccessorSignature(node: AccessorSignature) {
pushNameGenerationScope(node);
emitDecorators(node, node.decorators);
emitModifiers(node, node.modifiers);
writeKeyword(node.kind === SyntaxKind.GetAccessorSignature ? "get" : "set");
writeSpace();
emit(node.name);
emitParameters(node, node.parameters);
emitTypeAnnotation(node.type);
writeTrailingSemicolon();
popNameGenerationScope(node);
}
function emitCallSignature(node: CallSignatureDeclaration) {
pushNameGenerationScope(node);
emitDecorators(node, node.decorators);
src/compiler/factory.ts
+60
View File
@@ -600,6 +600,66 @@ namespace ts {
: node;
}
export function createGetAccessorSignature(
decorators: ReadonlyArray<Decorator> | undefined,
modifiers: ReadonlyArray<Modifier> | undefined,
name: string | PropertyName,
parameters: ReadonlyArray<ParameterDeclaration>,
type: TypeNode | undefined) {
const node = <GetAccessorSignature>createSynthesizedNode(SyntaxKind.GetAccessorSignature);
node.decorators = asNodeArray(decorators);
node.modifiers = asNodeArray(modifiers);
node.name = asName(name);
node.typeParameters = undefined;
node.parameters = createNodeArray(parameters);
node.type = type;
return node;
}
export function updateGetAccessorSignature(
node: GetAccessorSignature,
decorators: ReadonlyArray<Decorator> | undefined,
modifiers: ReadonlyArray<Modifier> | undefined,
name: PropertyName,
parameters: ReadonlyArray<ParameterDeclaration>,
type: TypeNode | undefined) {
return node.decorators !== decorators
|| node.modifiers !== modifiers
|| node.name !== name
|| node.parameters !== parameters
|| node.type !== type
? updateNode(createGetAccessorSignature(decorators, modifiers, name, parameters, type), node)
: node;
}
export function createSetAccessorSignature(
decorators: ReadonlyArray<Decorator> | undefined,
modifiers: ReadonlyArray<Modifier> | undefined,
name: string | PropertyName,
parameters: ReadonlyArray<ParameterDeclaration>) {
const node = <SetAccessorSignature>createSynthesizedNode(SyntaxKind.SetAccessorSignature);
node.decorators = asNodeArray(decorators);
node.modifiers = asNodeArray(modifiers);
node.name = asName(name);
node.typeParameters = undefined;
node.parameters = createNodeArray(parameters);
return node;
}
export function updateSetAccessorSignature(
node: SetAccessorSignature,
decorators: ReadonlyArray<Decorator> | undefined,
modifiers: ReadonlyArray<Modifier> | undefined,
name: PropertyName,
parameters: ReadonlyArray<ParameterDeclaration>) {
return node.decorators !== decorators
|| node.modifiers !== modifiers
|| node.name !== name
|| node.parameters !== parameters
? updateNode(createSetAccessorSignature(decorators, modifiers, name, parameters), node)
: node;
}
export function createCallSignature(typeParameters: ReadonlyArray<TypeParameterDeclaration> | undefined, parameters: ReadonlyArray<ParameterDeclaration>, type: TypeNode | undefined) {
return createSignatureDeclaration(SyntaxKind.CallSignature, typeParameters, parameters, type) as CallSignatureDeclaration;
}
src/compiler/parser.ts
+31 -4
View File
@@ -149,6 +149,8 @@ namespace ts {
case SyntaxKind.Constructor:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.FunctionExpression:
case SyntaxKind.FunctionDeclaration:
case SyntaxKind.ArrowFunction:
@@ -2006,6 +2008,8 @@ namespace ts {
switch (node.kind) {
case SyntaxKind.ConstructSignature:
case SyntaxKind.MethodSignature:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.IndexSignature:
case SyntaxKind.PropertySignature:
case SyntaxKind.CallSignature:
@@ -2702,6 +2706,14 @@ namespace ts {
return finishNode(node);
}
function parseAccessorSignature(node: AccessorSignature, kind: AccessorSignature["kind"]): AccessorSignature {
node.kind = kind;
node.name = parsePropertyName();
fillSignature(SyntaxKind.ColonToken, SignatureFlags.Type, node);
parseTypeMemberSemicolon();
return finishNode(node);
}
function parsePropertyOrMethodSignature(node: PropertySignature | MethodSignature): PropertySignature | MethodSignature {
node.name = parsePropertyName();
node.questionToken = parseOptionalToken(SyntaxKind.QuestionToken);
@@ -2730,10 +2742,10 @@ namespace ts {
if (token() === SyntaxKind.OpenParenToken || token() === SyntaxKind.LessThanToken) {
return true;
}
let idToken = false;
let idToken: SyntaxKind | undefined;
// Eat up all modifiers, but hold on to the last one in case it is actually an identifier
while (isModifierKind(token())) {
idToken = true;
idToken = token();
nextToken();
}
// Index signatures and computed property names are type members
@@ -2742,12 +2754,17 @@ namespace ts {
}
// Try to get the first property-like token following all modifiers
if (isLiteralPropertyName()) {
idToken = true;
idToken = token();
nextToken();
}
// If we were able to get any potential identifier, check that it is
// the start of a member declaration
if (idToken) {
if (idToken !== undefined) {
// If we have a non-keyword identifier, or if we have an accessor, then it's safe to parse.
if (!isKeyword(idToken) || idToken === SyntaxKind.SetKeyword || idToken === SyntaxKind.GetKeyword) {
return true;
}
return token() === SyntaxKind.OpenParenToken ||
token() === SyntaxKind.LessThanToken ||
token() === SyntaxKind.QuestionToken ||
@@ -2765,8 +2782,18 @@ namespace ts {
if (token() === SyntaxKind.NewKeyword && lookAhead(nextTokenIsOpenParenOrLessThan)) {
return parseSignatureMember(SyntaxKind.ConstructSignature);
}
const node = <TypeElement>createNodeWithJSDoc(SyntaxKind.Unknown);
node.modifiers = parseModifiers();
if (parseContextualModifier(SyntaxKind.GetKeyword)) {
return parseAccessorSignature(<AccessorSignature>node, SyntaxKind.GetAccessorSignature);
}
if (parseContextualModifier(SyntaxKind.SetKeyword)) {
return parseAccessorSignature(<AccessorSignature>node, SyntaxKind.SetAccessorSignature);
}
if (isIndexSignature()) {
return parseIndexSignatureDeclaration(<IndexSignatureDeclaration>node);
}
src/compiler/transformers/declarations.ts
+70 -11
View File
@@ -393,7 +393,24 @@ namespace ts {
}
}
function ensureParameter(p: ParameterDeclaration, modifierMask?: ModifierFlags): ParameterDeclaration {
function ensureParameter(node: Node, p: ParameterDeclaration, modifierMask?: ModifierFlags): ParameterDeclaration {
let type: TypeNode | undefined;
let name: BindingName | undefined;
let noType = false;
if (isAccessorLike(node) && !isThisIdentifier(p.name)) {
if (!hasModifier(node, ModifierFlags.Private)) {
type = p.type || (isAccessorDeclaration(node)
? getTypeAnnotationFromAllAccessorDeclarations(node)
: getTypeAnnotationFromAllAccessorSignatures(node));
}
else {
name = createIdentifier("value");
noType = true;
}
}
else {
type = p.type;
}
let oldDiag: typeof getSymbolAccessibilityDiagnostic | undefined;
if (!suppressNewDiagnosticContexts) {
oldDiag = getSymbolAccessibilityDiagnostic;
@@ -404,9 +421,9 @@ namespace ts {
/*decorators*/ undefined,
maskModifiers(p, modifierMask),
p.dotDotDotToken,
filterBindingPatternInitializers(p.name),
name || filterBindingPatternInitializers(p.name),
resolver.isOptionalParameter(p) ? (p.questionToken || createToken(SyntaxKind.QuestionToken)) : undefined,
ensureType(p, p.type, /*ignorePrivate*/ true), // Ignore private param props, since this type is going straight back into a param
noType ? undefined : ensureType(p, type, /*ignorePrivate*/ true), // Ignore private param props, since this type is going straight back into a param
ensureNoInitializer(p)
);
if (!suppressNewDiagnosticContexts) {
@@ -435,6 +452,8 @@ namespace ts {
| ConstructSignatureDeclaration
| VariableDeclaration
| MethodSignature
| GetAccessorSignature
| SetAccessorSignature
| CallSignatureDeclaration
| ParameterDeclaration
| PropertyDeclaration
@@ -525,10 +544,10 @@ namespace ts {
}
function updateParamsList(node: Node, params: NodeArray<ParameterDeclaration>, modifierMask?: ModifierFlags) {
if (hasModifier(node, ModifierFlags.Private)) {
if (hasModifier(node, ModifierFlags.Private) && !isSetAccessorLike(node)) {
return undefined!; // TODO: GH#18217
}
const newParams = map(params, p => ensureParameter(p, modifierMask));
const newParams = map(params, p => ensureParameter(node, p, modifierMask));
if (!newParams) {
return undefined!; // TODO: GH#18217
}
@@ -847,6 +866,24 @@ namespace ts {
input.questionToken
));
}
case SyntaxKind.GetAccessorSignature: {
const accessorType = getTypeAnnotationFromAllAccessorSignatures(input);
return cleanup(updateGetAccessorSignature(
input,
/*decorators*/ undefined,
ensureModifiers(input),
input.name,
updateParamsList(input, input.parameters),
!hasModifier(input, ModifierFlags.Private) ? ensureType(input, accessorType) : undefined));
}
case SyntaxKind.SetAccessorSignature: {
return cleanup(updateSetAccessorSignature(
input,
/*decorators*/ undefined,
ensureModifiers(input),
input.name,
updateParamsList(input, input.parameters)));
}
case SyntaxKind.CallSignature: {
return cleanup(updateCallSignature(
input,
@@ -1374,17 +1411,35 @@ namespace ts {
return maskModifierFlags(node, mask, additions);
}
function ensureAccessor(node: AccessorDeclaration): PropertyDeclaration | undefined {
function getTypeAnnotationFromAllAccessorDeclarations(node: AccessorDeclaration) {
const accessors = resolver.getAllAccessorDeclarations(node);
if (node.kind !== accessors.firstAccessor.kind) {
return;
}
let accessorType = getTypeAnnotationFromAccessor(node);
if (!accessorType && accessors.secondAccessor) {
accessorType = getTypeAnnotationFromAccessor(accessors.secondAccessor);
// If we end up pulling the type from the second accessor, we also need to change the diagnostic context to get the expected error message
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(accessors.secondAccessor);
}
return accessorType;
}
function getTypeAnnotationFromAllAccessorSignatures(node: AccessorSignature) {
const accessors = resolver.getAllAccessorSignatures(node);
let accessorType = getTypeAnnotationFromAccessor(node);
if (!accessorType && accessors.secondAccessor) {
accessorType = getTypeAnnotationFromAccessor(accessors.secondAccessor);
// If we end up pulling the type from the second accessor, we also need to change the diagnostic context to get the expected error message
getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(accessors.secondAccessor);
}
return accessorType;
}
function ensureAccessor(node: AccessorDeclaration): PropertyDeclaration | undefined {
const accessors = resolver.getAllAccessorDeclarations(node);
if (node.kind !== accessors.firstAccessor.kind) {
return;
}
const accessorType = getTypeAnnotationFromAllAccessorDeclarations(node);
const prop = createProperty(/*decorators*/ undefined, maskModifiers(node, /*mask*/ undefined, (!accessors.setAccessor) ? ModifierFlags.Readonly : ModifierFlags.None), node.name, node.questionToken, ensureType(node, accessorType), /*initializer*/ undefined);
const leadingsSyntheticCommentRanges = accessors.secondAccessor && getLeadingCommentRangesOfNode(accessors.secondAccessor, currentSourceFile);
if (leadingsSyntheticCommentRanges) {
@@ -1441,9 +1496,9 @@ namespace ts {
return flags;
}
function getTypeAnnotationFromAccessor(accessor: AccessorDeclaration): TypeNode | undefined {
function getTypeAnnotationFromAccessor(accessor: AccessorLike): TypeNode | undefined {
if (accessor) {
return accessor.kind === SyntaxKind.GetAccessor
return isGetAccessorLike(accessor)
? accessor.type // Getter - return type
: accessor.parameters.length > 0
? accessor.parameters[0].type // Setter parameter type
@@ -1501,6 +1556,8 @@ namespace ts {
| MethodDeclaration
| GetAccessorDeclaration
| SetAccessorDeclaration
| GetAccessorSignature
| SetAccessorSignature
| PropertyDeclaration
| PropertySignature
| MethodSignature
@@ -1522,6 +1579,8 @@ namespace ts {
case SyntaxKind.MethodDeclaration:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.PropertySignature:
case SyntaxKind.MethodSignature:
src/compiler/transformers/declarations/diagnostics.ts
+32 -2
View File
@@ -15,6 +15,8 @@ namespace ts {
| BindingElement
| SetAccessorDeclaration
| GetAccessorDeclaration
| SetAccessorSignature
| GetAccessorSignature
| ConstructSignatureDeclaration
| CallSignatureDeclaration
| MethodDeclaration
@@ -34,8 +36,10 @@ namespace ts {
isPropertyDeclaration(node) ||
isPropertySignature(node) ||
isBindingElement(node) ||
isSetAccessor(node) ||
isGetAccessor(node) ||
isSetAccessorDeclaration(node) ||
isGetAccessorDeclaration(node) ||
isSetAccessorSignature(node) ||
isGetAccessorSignature(node) ||
isConstructSignatureDeclaration(node) ||
isCallSignatureDeclaration(node) ||
isMethodDeclaration(node) ||
@@ -131,6 +135,9 @@ namespace ts {
else if (isSetAccessor(node) || isGetAccessor(node)) {
return getAccessorDeclarationTypeVisibilityError;
}
else if (isAccessorSignature(node)) {
return getAccessorSignatureTypeVisibilityError;
}
else if (isConstructSignatureDeclaration(node) || isCallSignatureDeclaration(node) || isMethodDeclaration(node) || isMethodSignature(node) || isFunctionDeclaration(node) || isIndexSignatureDeclaration(node)) {
return getReturnTypeVisibilityError;
}
@@ -240,6 +247,29 @@ namespace ts {
};
}
function getAccessorSignatureTypeVisibilityError(symbolAccessibilityResult: SymbolAccessibilityResult): SymbolAccessibilityDiagnostic {
let diagnosticMessage: DiagnosticMessage;
if (node.kind === SyntaxKind.SetAccessorSignature) {
// Getters can infer the return type from the returned expression, but setters cannot, so the
// "_from_external_module_1_but_cannot_be_named" case cannot occur.
diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
Diagnostics.Parameter_type_of_setter_0_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
Diagnostics.Parameter_type_of_setter_0_from_exported_interface_has_or_is_using_private_name_1;
}
else {
diagnosticMessage = symbolAccessibilityResult.errorModuleName ?
symbolAccessibilityResult.accessibility === SymbolAccessibility.CannotBeNamed ?
Diagnostics.Return_type_of_getter_0_from_exported_interface_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named :
Diagnostics.Return_type_of_getter_0_from_exported_interface_has_or_is_using_name_1_from_private_module_2 :
Diagnostics.Return_type_of_getter_0_from_exported_interface_has_or_is_using_private_name_1;
}
return {
diagnosticMessage,
errorNode: (node as NamedDeclaration).name!,
typeName: (node as NamedDeclaration).name
};
}
function getReturnTypeVisibilityError(symbolAccessibilityResult: SymbolAccessibilityResult): SymbolAccessibilityDiagnostic {
let diagnosticMessage: DiagnosticMessage;
switch (node.kind) {
src/compiler/types.ts
+30
View File
@@ -295,7 +295,9 @@ namespace ts {
MethodDeclaration,
Constructor,
GetAccessor,
GetAccessorSignature,
SetAccessor,
SetAccessorSignature,
CallSignature,
ConstructSignature,
IndexSignature,
@@ -648,6 +650,7 @@ namespace ts {
| ConstructSignatureDeclaration
| MethodSignature
| PropertySignature
| AccessorSignature
| ArrowFunction
| ParenthesizedExpression
| SpreadAssignment
@@ -871,6 +874,7 @@ namespace ts {
| CallSignatureDeclaration
| ConstructSignatureDeclaration
| MethodSignature
| AccessorSignature
| IndexSignatureDeclaration
| FunctionTypeNode
| ConstructorTypeNode
@@ -1109,6 +1113,23 @@ namespace ts {
export type AccessorDeclaration = GetAccessorDeclaration | SetAccessorDeclaration;
export interface GetAccessorSignature extends SignatureDeclarationBase, TypeElement {
kind: SyntaxKind.GetAccessorSignature;
parent: ObjectTypeDeclaration;
name: PropertyName;
}
export interface SetAccessorSignature extends SignatureDeclarationBase, TypeElement {
kind: SyntaxKind.SetAccessorSignature;
parent: ObjectTypeDeclaration;
name: PropertyName;
}
export type AccessorSignature = GetAccessorSignature | SetAccessorSignature;
export type GetAccessorLike = GetAccessorDeclaration | GetAccessorSignature;
export type SetAccessorLike = SetAccessorDeclaration | SetAccessorSignature;
export type AccessorLike = AccessorDeclaration | AccessorSignature;
export interface IndexSignatureDeclaration extends SignatureDeclarationBase, ClassElement, TypeElement {
kind: SyntaxKind.IndexSignature;
parent: ObjectTypeDeclaration;
@@ -3560,6 +3581,14 @@ namespace ts {
setAccessor: SetAccessorDeclaration | undefined;
}
/* @internal */
export interface AllAccessorSignatures {
firstAccessor: AccessorSignature;
secondAccessor: AccessorSignature | undefined;
getAccessor: GetAccessorSignature | undefined;
setAccessor: SetAccessorSignature | undefined;
}
/** Indicates how to serialize the name for a TypeReferenceNode when emitting decorator metadata */
/* @internal */
export enum TypeReferenceSerializationKind {
@@ -3620,6 +3649,7 @@ namespace ts {
isLiteralConstDeclaration(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration): boolean;
getJsxFactoryEntity(location?: Node): EntityName | undefined;
getAllAccessorDeclarations(declaration: AccessorDeclaration): AllAccessorDeclarations;
getAllAccessorSignatures(declaration: AccessorSignature): AllAccessorSignatures;
getSymbolOfExternalModuleSpecifier(node: StringLiteralLike): Symbol | undefined;
isBindingCapturedByNode(node: Node, decl: VariableDeclaration | BindingElement): boolean;
}
src/compiler/utilities.ts
+84 -7
View File
@@ -746,6 +746,8 @@ namespace ts {
case SyntaxKind.CallSignature:
case SyntaxKind.ConstructSignature:
case SyntaxKind.MethodSignature:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.IndexSignature:
case SyntaxKind.FunctionType:
case SyntaxKind.ConstructorType:
@@ -921,6 +923,8 @@ namespace ts {
case SyntaxKind.MethodDeclaration:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.TypeAliasDeclaration:
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.PropertySignature:
@@ -1097,6 +1101,8 @@ namespace ts {
case SyntaxKind.MethodSignature:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
return node === (<FunctionLikeDeclaration>parent).type;
case SyntaxKind.CallSignature:
case SyntaxKind.ConstructSignature:
@@ -1400,6 +1406,8 @@ namespace ts {
case SyntaxKind.Constructor:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.CallSignature:
case SyntaxKind.ConstructSignature:
case SyntaxKind.IndexSignature:
@@ -1456,6 +1464,8 @@ namespace ts {
case SyntaxKind.Constructor:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
return node;
case SyntaxKind.Decorator:
// Decorators are always applied outside of the body of a class or method.
@@ -2520,6 +2530,8 @@ namespace ts {
case SyntaxKind.MethodSignature:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.EnumMember:
case SyntaxKind.PropertyAssignment:
case SyntaxKind.PropertyAccessExpression:
@@ -3518,7 +3530,7 @@ namespace ts {
return find(node.members, (member): member is ConstructorDeclaration & { body: FunctionBody } => isConstructorDeclaration(member) && nodeIsPresent(member.body));
}
function getSetAccessorValueParameter(accessor: SetAccessorDeclaration): ParameterDeclaration | undefined {
function getSetAccessorValueParameter(accessor: SetAccessorLike): ParameterDeclaration | undefined {
if (accessor && accessor.parameters.length > 0) {
const hasThis = accessor.parameters.length === 2 && parameterIsThisKeyword(accessor.parameters[0]);
return accessor.parameters[hasThis ? 1 : 0];
@@ -3526,7 +3538,7 @@ namespace ts {
}
/** Get the type annotation for the value parameter. */
export function getSetAccessorTypeAnnotationNode(accessor: SetAccessorDeclaration): TypeNode | undefined {
export function getSetAccessorTypeAnnotationNode(accessor: SetAccessorLike): TypeNode | undefined {
const parameter = getSetAccessorValueParameter(accessor);
return parameter && parameter.type;
}
@@ -3553,6 +3565,23 @@ namespace ts {
return id.originalKeywordKind === SyntaxKind.ThisKeyword;
}
export function getOtherAccessorLikeKind(node: AccessorLike) {
return isGetAccessorDeclaration(node) ? SyntaxKind.SetAccessor :
isGetAccessorSignature(node) ? SyntaxKind.SetAccessorSignature :
isSetAccessorDeclaration(node) ? SyntaxKind.GetAccessor :
SyntaxKind.GetAccessorSignature;
}
export function getOtherAccessorDeclarationKind(node: AccessorLike) {
return isGetAccessorLike(node) ? SyntaxKind.SetAccessor :
SyntaxKind.GetAccessor;
}
export function getOtherAccessorSignatureKind(node: AccessorLike) {
return isGetAccessorLike(node) ? SyntaxKind.SetAccessorSignature :
SyntaxKind.GetAccessorSignature;
}
export function getAllAccessorDeclarations(declarations: NodeArray<Declaration>, accessor: AccessorDeclaration): AllAccessorDeclarations {
// TODO: GH#18217
let firstAccessor!: AccessorDeclaration;
@@ -3641,7 +3670,7 @@ namespace ts {
* Gets the effective type annotation of the value parameter of a set accessor. If the node
* was parsed in a JavaScript file, gets the type annotation from JSDoc.
*/
export function getEffectiveSetAccessorTypeAnnotationNode(node: SetAccessorDeclaration): TypeNode | undefined {
export function getEffectiveSetAccessorTypeAnnotationNode(node: SetAccessorLike): TypeNode | undefined {
const parameter = getSetAccessorValueParameter(node);
return parameter && getEffectiveTypeAnnotationNode(parameter);
}
@@ -5541,6 +5570,46 @@ namespace ts {
return node.kind === SyntaxKind.SetAccessor;
}
export function isGetAccessorSignature(node: Node): node is GetAccessorSignature {
return node.kind === SyntaxKind.GetAccessorSignature;
}
export function isSetAccessorSignature(node: Node): node is SetAccessorSignature {
return node.kind === SyntaxKind.SetAccessorSignature;
}
export function isGetAccessorLike(node: Node): node is GetAccessorLike {
const kind = node.kind;
return kind === SyntaxKind.GetAccessor
|| kind === SyntaxKind.GetAccessorSignature;
}
export function isSetAccessorLike(node: Node): node is SetAccessorLike {
const kind = node.kind;
return kind === SyntaxKind.SetAccessor
|| kind === SyntaxKind.SetAccessorSignature;
}
export function isAccessorDeclaration(node: Node): node is AccessorDeclaration {
const kind = node.kind;
return kind === SyntaxKind.GetAccessor
|| kind === SyntaxKind.SetAccessor;
}
export function isAccessorSignature(node: Node): node is AccessorSignature {
const kind = node.kind;
return kind === SyntaxKind.GetAccessorSignature
|| kind === SyntaxKind.SetAccessorSignature;
}
export function isAccessorLike(node: Node): node is AccessorLike {
const kind = node.kind;
return kind === SyntaxKind.GetAccessor
|| kind === SyntaxKind.GetAccessorSignature
|| kind === SyntaxKind.SetAccessor
|| kind === SyntaxKind.SetAccessorSignature;
}
export function isCallSignatureDeclaration(node: Node): node is CallSignatureDeclaration {
return node.kind === SyntaxKind.CallSignature;
}
@@ -5553,9 +5622,10 @@ namespace ts {
return node.kind === SyntaxKind.IndexSignature;
}
/** @deprecated Use `isAccessorDeclaration` instead. */
/* @internal */
export function isGetOrSetAccessorDeclaration(node: Node): node is AccessorDeclaration {
return node.kind === SyntaxKind.SetAccessor || node.kind === SyntaxKind.GetAccessor;
return isAccessorDeclaration(node);
}
// Type
@@ -6347,6 +6417,8 @@ namespace ts {
export function isFunctionLikeKind(kind: SyntaxKind): boolean {
switch (kind) {
case SyntaxKind.MethodSignature:
case SyntaxKind.GetAccessorSignature:
case SyntaxKind.SetAccessorSignature:
case SyntaxKind.CallSignature:
case SyntaxKind.JSDocSignature:
case SyntaxKind.ConstructSignature:
@@ -6381,8 +6453,9 @@ namespace ts {
return node && (node.kind === SyntaxKind.ClassDeclaration || node.kind === SyntaxKind.ClassExpression);
}
/** @deprecated Use `isAccessorDeclaration` instead. */
export function isAccessor(node: Node): node is AccessorDeclaration {
return node && (node.kind === SyntaxKind.GetAccessor || node.kind === SyntaxKind.SetAccessor);
return isAccessorDeclaration(node);
}
/* @internal */
@@ -6405,6 +6478,8 @@ namespace ts {
|| kind === SyntaxKind.CallSignature
|| kind === SyntaxKind.PropertySignature
|| kind === SyntaxKind.MethodSignature
|| kind === SyntaxKind.GetAccessorSignature
|| kind === SyntaxKind.SetAccessorSignature
|| kind === SyntaxKind.IndexSignature;
}
@@ -6955,12 +7030,14 @@ namespace ts {
return node.kind >= SyntaxKind.FirstJSDocTagNode && node.kind <= SyntaxKind.LastJSDocTagNode;
}
/** @deprecated Use `isSetAccessorDeclaration` instead. */
export function isSetAccessor(node: Node): node is SetAccessorDeclaration {
return node.kind === SyntaxKind.SetAccessor;
return isSetAccessorDeclaration(node);
}
/** @deprecated Use `isGetAccessorDeclaration` instead. */
export function isGetAccessor(node: Node): node is GetAccessorDeclaration {
return node.kind === SyntaxKind.GetAccessor;
return isGetAccessorDeclaration(node);
}
/** True if has jsdoc nodes attached to it. */
src/compiler/visitor.ts
+44 -5
View File
@@ -317,6 +317,21 @@ namespace ts {
visitParameterList((<SetAccessorDeclaration>node).parameters, visitor, context, nodesVisitor),
visitFunctionBody((<SetAccessorDeclaration>node).body!, visitor, context));
case SyntaxKind.GetAccessorSignature:
return updateGetAccessorSignature(<GetAccessorSignature>node,
nodesVisitor((<GetAccessorSignature>node).decorators, visitor, isDecorator),
nodesVisitor((<GetAccessorSignature>node).modifiers, visitor, isModifier),
visitNode((<GetAccessorSignature>node).name, visitor, isPropertyName),
nodesVisitor((<GetAccessorSignature>node).parameters, visitor, isParameter),
visitNode((<GetAccessorSignature>node).type, visitor, isTypeNode));
case SyntaxKind.SetAccessorSignature:
return updateSetAccessorSignature(<SetAccessorSignature>node,
nodesVisitor((<SetAccessorSignature>node).decorators, visitor, isDecorator),
nodesVisitor((<SetAccessorSignature>node).modifiers, visitor, isModifier),
visitNode((<SetAccessorSignature>node).name, visitor, isPropertyName),
visitNodes((<SetAccessorSignature>node).parameters, visitor, isParameter));
case SyntaxKind.CallSignature:
return updateCallSignature(<CallSignatureDeclaration>node,
nodesVisitor((<CallSignatureDeclaration>node).typeParameters, visitor, isTypeParameterDeclaration),
@@ -1034,6 +1049,15 @@ namespace ts {
result = reduceNode((<PropertyDeclaration>node).initializer, cbNode, result);
break;
case SyntaxKind.MethodSignature:
result = reduceNodes((<MethodSignature>node).decorators, cbNodes, result);
result = reduceNodes((<MethodSignature>node).modifiers, cbNodes, result);
result = reduceNode((<MethodSignature>node).name, cbNode, result);
result = reduceNodes((<MethodSignature>node).typeParameters, cbNodes, result);
result = reduceNodes((<MethodSignature>node).parameters, cbNodes, result);
result = reduceNode((<MethodSignature>node).type, cbNode, result);
break;
case SyntaxKind.MethodDeclaration:
result = reduceNodes((<MethodDeclaration>node).decorators, cbNodes, result);
result = reduceNodes((<MethodDeclaration>node).modifiers, cbNodes, result);
@@ -1060,11 +1084,26 @@ namespace ts {
break;
case SyntaxKind.SetAccessor:
result = reduceNodes((<GetAccessorDeclaration>node).decorators, cbNodes, result);
result = reduceNodes((<GetAccessorDeclaration>node).modifiers, cbNodes, result);
result = reduceNode((<GetAccessorDeclaration>node).name, cbNode, result);
result = reduceNodes((<GetAccessorDeclaration>node).parameters, cbNodes, result);
result = reduceNode((<GetAccessorDeclaration>node).body, cbNode, result);
result = reduceNodes((<SetAccessorDeclaration>node).decorators, cbNodes, result);
result = reduceNodes((<SetAccessorDeclaration>node).modifiers, cbNodes, result);
result = reduceNode((<SetAccessorDeclaration>node).name, cbNode, result);
result = reduceNodes((<SetAccessorDeclaration>node).parameters, cbNodes, result);
result = reduceNode((<SetAccessorDeclaration>node).body, cbNode, result);
break;
case SyntaxKind.GetAccessorSignature:
result = reduceNodes((<GetAccessorSignature>node).decorators, cbNodes, result);
result = reduceNodes((<GetAccessorSignature>node).modifiers, cbNodes, result);
result = reduceNode((<GetAccessorSignature>node).name, cbNode, result);
result = reduceNodes((<GetAccessorSignature>node).parameters, cbNodes, result);
result = reduceNode((<GetAccessorSignature>node).type, cbNode, result);
break;
case SyntaxKind.SetAccessorSignature:
result = reduceNodes((<SetAccessorSignature>node).decorators, cbNodes, result);
result = reduceNodes((<SetAccessorSignature>node).modifiers, cbNodes, result);
result = reduceNode((<SetAccessorSignature>node).name, cbNode, result);
result = reduceNodes((<SetAccessorSignature>node).parameters, cbNodes, result);
break;
// Binding patterns