// Class declarations in Typescript do not allow property declarations

const parentSymbol = lookupSymbolForPropertyAccess(lhs.expression);

if (!isInJavaScriptFile(node) && !isFunctionSymbol(parentSymbol)) {

return;

}

function getInitializerTypeFromSpecialDeclarations(symbol: Symbol, resolvedSymbol: Symbol | undefined, expression: BinaryExpression, special: SpecialPropertyAssignmentKind) {

const type = resolvedSymbol ? getTypeOfSymbol(resolvedSymbol) : getWidenedLiteralType(checkExpressionCached(expression.right));

if (type.flags & TypeFlags.Object &&

special === SpecialPropertyAssignmentKind.ModuleExports &&

symbol.escapedName === InternalSymbolName.ExportEquals) {

const exportedType = resolveStructuredTypeMembers(type as ObjectType);

const members = createSymbolTable();

copyEntries(exportedType.members, members);

if (resolvedSymbol && !resolvedSymbol.exports) {

resolvedSymbol.exports = createSymbolTable();

(resolvedSymbol || symbol).exports!.forEach((s, name) => {

if (members.has(name)) {

const exportedMember = exportedType.members.get(name)!;

const union = createSymbol(s.flags | exportedMember.flags, name);

union.type = getUnionType([getTypeOfSymbol(s), getTypeOfSymbol(exportedMember)]);

members.set(name, union);

else {

members.set(name, s);

}

});

const result = createAnonymousType(

exportedType.symbol,

members,

exportedType.callSignatures,

exportedType.constructSignatures,

exportedType.stringIndexInfo,

exportedType.numberIndexInfo);

result.objectFlags |= (getObjectFlags(type) & ObjectFlags.JSLiteral); // Propagate JSLiteral flag

return result;

}

if (isEmptyArrayLiteralType(type)) {

if (noImplicitAny) {

reportImplicitAnyError(expression, anyArrayType);

return anyArrayType;

return type;

type = isBinaryExpression(declaration.parent) ?

getWidenedTypeFromJSPropertyAssignments(symbol) :

tryGetTypeFromEffectiveTypeNode(declaration) || anyType;

if (!binaryExpression.left.symbol) {

return true;

}

else {

const decl = binaryExpression.left.symbol.valueDeclaration;

if (!decl) {

return false;

}

if (isInJavaScriptFile(decl)) {

return !!getJSDocTypeTag(decl);

}

else if (isIdentifier((binaryExpression.left as PropertyAccessExpression).expression)) {

const id = (binaryExpression.left as PropertyAccessExpression).expression as Identifier;

const parentSymbol = resolveName(id, id.escapedText, SymbolFlags.Value, undefined, id.escapedText, /*isUse*/ true);

return !isFunctionSymbol(parentSymbol);

}

return true;

}

if (!node.parent) {

if (!isInJavaScriptFile(node) && !isVarConst(node.parent)) {

return undefined;

}

const special = getSpecialPropertyAssignmentKindWorker(expr);

return special === SpecialPropertyAssignmentKind.Property || isInJavaScriptFile(expr) ? special : SpecialPropertyAssignmentKind.None;

}

function getSpecialPropertyAssignmentKindWorker(expr: BinaryExpression): SpecialPropertyAssignmentKind {

if (expr.operatorToken.kind !== SyntaxKind.EqualsToken ||

export function isFunctionSymbol(symbol: Symbol | undefined) {

if (!symbol || !symbol.valueDeclaration) {

return false;

}

const decl = symbol.valueDeclaration;

return decl.kind === SyntaxKind.FunctionDeclaration || isVariableDeclaration(decl) && decl.initializer && isFunctionLike(decl.initializer);

}

return isBinaryExpression(binExp) &&

getSpecialPropertyAssignmentKind(binExp) !== SpecialPropertyAssignmentKind.None &&

(binExp.left.symbol || binExp.symbol) &&

getNameOfDeclaration(binExp) === name;

==== tests/cases/conformance/fixSignatureCaching.ts (59 errors) ====

})());