if (symbol) {

const isConstructorObject = getObjectFlags(type) & ObjectFlags.Anonymous && type.symbol && type.symbol.flags & SymbolFlags.Class;

id = (isConstructorObject ? "+" : "") + getSymbolId(symbol);

// Instance and static types share the same symbol; only add 'typeof' for the static side.

const isInstanceType = type === getInferredClassType(symbol) ? SymbolFlags.Type : SymbolFlags.Value;

return symbolToTypeNode(symbol, context, isInstanceType);

const constraint = getBaseConstraintOfType(type);

return !!constraint && isValidBaseType(constraint) && isMixinConstructorType(constraint);

}

}

function getBaseTypeNodeOfClass(type: InterfaceType): ExpressionWithTypeArguments | undefined {

function getConstructorsForTypeArguments(type: Type, typeArgumentNodes: ReadonlyArray<TypeNode> | undefined, location: Node): ReadonlyArray<Signature> {

const typeArgCount = length(typeArgumentNodes);

return filter(getSignaturesOfType(type, SignatureKind.Construct),

}

function getInstantiatedConstructorsForTypeArguments(type: Type, typeArgumentNodes: ReadonlyArray<TypeNode> | undefined, location: Node): ReadonlyArray<Signature> {

else if (baseConstructorType.flags & TypeFlags.Any) {

baseType = baseConstructorType;

}

else {

// The class derives from a "class-like" constructor function, check that we have at least one construct signature

// with a matching number of type parameters and use the return type of the first instantiated signature. Elsewhere

}

}

let outerTypeParameters = getOuterTypeParameters(declaration, /*includeThisTypes*/ true);

const templateTagParameters = getTypeParametersFromDeclaration(declaration as DeclarationWithTypeParameters);

outerTypeParameters = addRange(outerTypeParameters, templateTagParameters);

}

function getTypeWithoutSignatures(type: Type): Type {

if (type.flags & TypeFlags.Object) {

const resolved = resolveStructuredTypeMembers(<ObjectType>type);

const result = createObjectType(ObjectFlags.Anonymous, type.symbol);

result.members = resolved.members;

result.properties = resolved.properties;

}

if (!ignoreReturnTypes) {

if (targetReturnType === voidType) {

return result;

}

// The following block preserves behavior forbidding boolean returning functions from being assignable to type guard returning functions

const targetTypePredicate = getTypePredicateOfSignature(target);

return Ternary.True;

}

const sourceSignatures = getSignaturesOfType(source, (sourceIsJSConstructor && kind === SignatureKind.Construct) ?

SignatureKind.Call : kind);

// * /** @constructor */ var x = function() { ... }

else if ((container.kind === SyntaxKind.FunctionExpression || container.kind === SyntaxKind.FunctionDeclaration) &&

getJSDocClassTag(container)) {

if (classType) {

return getFlowTypeOfReference(node, classType);

}

const callSignatures = getSignaturesOfType(expressionType, SignatureKind.Call);

if (callSignatures.length) {

const signature = resolveCall(node, callSignatures, candidatesOutArray, isForSignatureHelp);

error(node, Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword);

}

if (getThisTypeOfSignature(signature) === voidType) {

* Indicates whether a declaration can be treated as a constructor in a JavaScript

* file.

*/

if (node && isInJavaScriptFile(node)) {

// If the node has a @class tag, treat it like a constructor.

if (getJSDocClassTag(node)) return true;

return false;

}

let inferred: Type | undefined;

inferred = getInferredClassType(symbol);

}

const assigned = getAssignedClassType(symbol);

const valueType = getTypeOfSymbol(symbol);

inferred = getInferredClassType(valueType.symbol);

}

return assigned && inferred ?

if (!funcSymbol && node.expression.kind === SyntaxKind.Identifier) {

funcSymbol = getResolvedSymbol(node.expression as Identifier);

}

if (type) {

return signature.target ? instantiateType(type, signature.mapper) : type;

}

return undefined;

}

if (strictNullChecks && aggregatedTypes.length && hasReturnWithNoExpression &&

// Javascript "callable constructors", containing eg `if (!(this instanceof A)) return new A()` should not add undefined

pushIfUnique(aggregatedTypes, undefinedType);

}

// that all instantiated base constructor signatures return the same type. We can simply compare the type

// references (as opposed to checking the structure of the types) because elsewhere we have already checked

// that the base type is a class or interface type (and not, for example, an anonymous object type).

const constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode);

error(baseTypeNode.expression, Diagnostics.Base_constructors_must_all_have_the_same_return_type);

}

}