initializer: Expression | undefined

) => T, methodKind: SyntaxKind, useAccessors: boolean): (p: Symbol, isStatic: boolean, baseType: Type | undefined) => (T | AccessorDeclaration | (T | AccessorDeclaration)[]) {

return function serializePropertySymbol(p: Symbol, isStatic: boolean, baseType: Type | undefined) {

if (isStatic && (p.flags & (SymbolFlags.Type | SymbolFlags.Namespace | SymbolFlags.Alias))) {

// Only value-only-meaning symbols can be correctly encoded as class statics, type/namespace/alias meaning symbols

// need to be merged namespace members

&& isTypeIdenticalTo(getTypeOfSymbol(p), getTypeOfPropertyOfType(baseType, p.escapedName)!))) {

return [];

}

const name = getPropertyNameNodeForSymbol(p, context);

const firstPropertyLikeDecl = find(p.declarations, or(isPropertyDeclaration, isAccessor, isVariableDeclaration, isPropertySignature, isBinaryExpression, isPropertyAccessExpression));

if (p.flags & SymbolFlags.Accessor && useAccessors) {

const result: AccessorDeclaration[] = [];

if (p.flags & SymbolFlags.SetAccessor) {

result.push(setTextRange(createSetAccessor(

/*decorators*/ undefined,

name,

[createParameter(

/*decorators*/ undefined,

/*modifiers*/ undefined,

/*dotDotDotToken*/ undefined,

"arg",

/*questionToken*/ undefined,

)],

/*body*/ undefined

), find(p.declarations, isSetAccessor) || firstPropertyLikeDecl));

}

if (p.flags & SymbolFlags.GetAccessor) {

result.push(setTextRange(createGetAccessor(

/*decorators*/ undefined,

name,

[],

/*body*/ undefined

), find(p.declarations, isGetAccessor) || firstPropertyLikeDecl));

}

else if (p.flags & (SymbolFlags.Property | SymbolFlags.Variable)) {

return setTextRange(createProperty(

/*decorators*/ undefined,

name,

p.flags & SymbolFlags.Optional ? createToken(SyntaxKind.QuestionToken) : undefined,

// TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357

// interface members can't have initializers, however class members _can_

/*initializer*/ undefined

if (p.flags & (SymbolFlags.Method | SymbolFlags.Function)) {

const type = getTypeOfSymbol(p);

const signatures = getSignaturesOfType(type, SignatureKind.Call);

const results = [];

for (const sig of signatures) {

// Each overload becomes a separate method declaration, in order

const decl = signatureToSignatureDeclarationHelper(sig, methodKind, context) as MethodDeclaration;

decl.name = name; // TODO: Clone

}

if (p.flags & SymbolFlags.Optional) {

decl.questionToken = createToken(SyntaxKind.QuestionToken);

}

}

}

}

const results = [];

return forEach((node as JSDocTypeLiteral).jsDocPropertyTags, cbNode);

case SyntaxKind.JSDocTag:

case SyntaxKind.JSDocClassTag:

return visitNode(cbNode, (node as JSDocTag).tagName);

case SyntaxKind.PartiallyEmittedExpression:

return visitNode(cbNode, (<PartiallyEmittedExpression>node).expression);

// FormalParameter [Yield,Await]:

// BindingElement[?Yield,?Await]

node.name = parseIdentifierOrPattern();

// in cases like

// 'use strict'

// function foo(static)

return undefined;

}

// If we have an arrow, then try to parse the body. Even if not, try to parse if we

// have an opening brace, just in case we're in an error state.

function parseParenthesizedArrowFunctionExpressionHead(allowAmbiguity: boolean): ArrowFunction | undefined {

const node = <ArrowFunction>createNodeWithJSDoc(SyntaxKind.ArrowFunction);

node.modifiers = parseModifiersForArrowFunction();

// Arrow functions are never generators.

//

// If we're speculatively parsing a signature for a parenthesized arrow function, then

node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);

const isGenerator = node.asteriskToken ? SignatureFlags.Yield : SignatureFlags.None;

node.name =

isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalIdentifier) :

isGenerator ? doInYieldContext(parseOptionalIdentifier) :

node.kind = SyntaxKind.FunctionDeclaration;

parseExpected(SyntaxKind.FunctionKeyword);

node.asteriskToken = parseOptionalToken(SyntaxKind.AsteriskToken);

const isGenerator = node.asteriskToken ? SignatureFlags.Yield : SignatureFlags.None;

fillSignature(SyntaxKind.ColonToken, isGenerator | isAsync, node);

node.body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, Diagnostics.or_expected);

return finishNode(node);

node.kind = SyntaxKind.MethodDeclaration;

node.asteriskToken = asteriskToken;

const isGenerator = asteriskToken ? SignatureFlags.Yield : SignatureFlags.None;

fillSignature(SyntaxKind.ColonToken, isGenerator | isAsync, node);

node.body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, diagnosticMessage);

return finishNode(node);

}

function isAnExternalModuleIndicatorNode(node: Node) {

|| node.kind === SyntaxKind.ImportEqualsDeclaration && (<ImportEqualsDeclaration>node).moduleReference.kind === SyntaxKind.ExternalModuleReference

|| node.kind === SyntaxKind.ImportDeclaration

|| node.kind === SyntaxKind.ExportAssignment

return isImportMeta(node) ? node : forEachChild(node, walkTreeForExternalModuleIndicators);

}

function isImportMeta(node: Node): boolean {

return isMetaProperty(node) && node.keywordToken === SyntaxKind.ImportKeyword && node.name.escapedText === "meta";

}

break;

case "class":

case "constructor":

break;

case "this":

tag = parseThisTag(start, tagName);

return node;

}

tag.tagName = tagName;

return finishNode(tag);

}

ensureType(input, input.type)

));

case SyntaxKind.Constructor: {

// A constructor declaration may not have a type annotation

const ctor = createSignatureDeclaration(

SyntaxKind.Constructor,

/*type*/ undefined

);

ctor.modifiers = createNodeArray(ensureModifiers(input));

return cleanup(sig);

}

case SyntaxKind.GetAccessor: {

const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));

return cleanup(updateGetAccessor(

input,

/*decorators*/ undefined,

ensureModifiers(input),

input.name,

/*body*/ undefined));

}

case SyntaxKind.SetAccessor: {

ensureModifiers(input),

input.name,

input.questionToken,

ensureNoInitializer(input)

));

case SyntaxKind.PropertySignature:

ensureModifiers(input),

input.name,

input.questionToken,

ensureNoInitializer(input)

));

case SyntaxKind.MethodSignature: {

JSDocAugmentsTag,

JSDocAuthorTag,

JSDocClassTag,

JSDocCallbackTag,

JSDocEnumTag,

JSDocParameterTag,

kind: SyntaxKind.JSDocClassTag;

}

export interface JSDocEnumTag extends JSDocTag, Declaration {

parent: JSDoc;

kind: SyntaxKind.JSDocEnumTag;

}

}

if (node.flags & NodeFlags.NestedNamespace || (node.kind === SyntaxKind.Identifier && (<Identifier>node).isInJSDocNamespace)) {

flags |= ModifierFlags.Export;

}