if (isBindingPattern(declaration.parent)) {

return getTypeForBindingElement(<BindingElement>declaration);

}

// Use type from type annotation if one is present

if (declaration.type) {

return getTypeFromTypeNode(declaration.type);

return type;

}

}

// Use the type of the initializer expression if one is present

if (declaration.initializer) {

return checkExpressionCached(declaration.initializer);

}

// If it is a short-hand property assignment, use the type of the identifier

if (declaration.kind === SyntaxKind.ShorthandPropertyAssignment) {

return checkIdentifier(<Identifier>declaration.name);

// tools see the actual type.

return declaration.kind !== SyntaxKind.PropertyAssignment ? getWidenedType(type) : type;

}

// Rest parameters default to type any[], other parameters default to type any

type = declaration.dotDotDotToken ? anyArrayType : anyType;

// Report implicit any errors unless this is a private property within an ambient declaration

if (reportErrors && compilerOptions.noImplicitAny) {

let root = getRootDeclaration(declaration);

}

return t;

};

mapper.context = context;

return mapper;

}

// We know *exactly* where things went wrong when comparing the types.

// Use this property as the error node as this will be more helpful in

// reasoning about what went wrong.

reportError(Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1,

symbolToString(prop),

typeToString(target));

if (kind === SignatureKind.Construct) {

// Only want to compare the construct signatures for abstractness guarantees.

// Because the "abstractness" of a class is the same across all construct signatures

// (internally we are checking the corresponding declaration), it is enough to perform

// the check and report an error once over all pairs of source and target construct signatures.

return getUnionType(assignableConstituents);

}

}

if (isTypeAssignableTo(narrowedTypeCandidate, originalType)) {

// Narrow to the target type if it's assignable to the current type

return narrowedTypeCandidate;

let classType = classDeclaration && <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration));

let baseClassType = classType && getBaseTypes(classType)[0];

let needToCaptureLexicalThis = false;

// adjust the container reference in case if super is used inside arrow functions with arbitrary deep nesting

while (container && container.kind === SyntaxKind.ArrowFunction) {

container = getSuperContainer(container, /*includeFunctions*/ true);

needToCaptureLexicalThis = languageVersion < ScriptTarget.ES6;

}

}

let canUseSuperExpression = isLegalUsageOfSuperExpression(container);

let nodeCheckFlag: NodeCheckFlags = 0;

// always set NodeCheckFlags for 'super' expression node

if ((container.flags & NodeFlags.Static) || isCallExpression) {

nodeCheckFlag = NodeCheckFlags.SuperStatic;

}

else {

nodeCheckFlag = NodeCheckFlags.SuperInstance;

}

getNodeLinks(node).flags |= nodeCheckFlag;

if (needToCaptureLexicalThis) {

// call expressions are allowed only in constructors so they should always capture correct 'this'

// super property access expressions can also appear in arrow functions -

// in this case they should also use correct lexical this

captureLexicalThis(node.parent, container);

}

if (!baseClassType) {

if (!classDeclaration || !getClassExtendsHeritageClauseElement(classDeclaration)) {

error(node, Diagnostics.super_can_only_be_referenced_in_a_derived_class);

}

}

if (!canUseSuperExpression) {

if (container && container.kind === SyntaxKind.ComputedPropertyName) {

error(node, Diagnostics.super_cannot_be_referenced_in_a_computed_property_name);

else {

error(node, Diagnostics.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class);

}

return unknownType;

}

if (container.kind === SyntaxKind.Constructor && isInConstructorArgumentInitializer(node, container)) {

// issue custom error message for super property access in constructor arguments (to be aligned with old compiler)

error(node, Diagnostics.super_cannot_be_referenced_in_constructor_arguments);

return unknownType;

}

return nodeCheckFlag === NodeCheckFlags.SuperStatic

? getBaseConstructorTypeOfClass(classType)

: baseClassType;

function isLegalUsageOfSuperExpression(container: Node): boolean {

if (!container) {

return false;

}

}

}

return false;

}

// Return contextual type of parameter or undefined if no contextual type is available

}

}

}

}

function isNumericName(name: DeclarationName): boolean {

// Maybe there's a string indexer?

let indexerType = getIndexTypeOfType(elementAttributesType, IndexKind.String);

if (indexerType) {

}

else {

// If there's no corresponding property with this name, error

if (!links.resolvedSymbol) {

if (isJsxIntrinsicIdentifier(node.tagName)) {

links.resolvedSymbol = lookupIntrinsicTag(node);

links.resolvedSymbol = lookupClassTag(node);

}

}

function reorderCandidates(signatures: Signature[], result: Signature[]): void {

let lastParent: Node;

let lastSymbol: Symbol;

let index: number;

let spliceIndex: number;

Debug.assert(!result.length);

for (let signature of signatures) {

}

if (!superCallStatement) {

error(node, Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_or_has_parameter_properties);

else {

// In such a required super call, it is a compile-time error for argument expressions to reference this.

markThisReferencesAsErrors(superCallStatement.expression);

// Spaces for anyting not declared a 'default export'.

let nonDefaultExportedDeclarationSpaces = exportedDeclarationSpaces | nonExportedDeclarationSpaces;

let commonDeclarationSpacesForExportsAndLocals = exportedDeclarationSpaces & nonExportedDeclarationSpaces;

let commonDeclarationSpacesForDefaultAndNonDefault = defaultExportedDeclarationSpaces & nonDefaultExportedDeclarationSpaces;

if (commonDeclarationSpacesForExportsAndLocals || commonDeclarationSpacesForDefaultAndNonDefault) {

// declaration spaces for exported and non-exported declarations intersect

for (let d of symbol.declarations) {

let declarationSpaces = getDeclarationSpaces(d);

// Only error on the declarations that conributed to the intersecting spaces.

if (declarationSpaces & commonDeclarationSpacesForDefaultAndNonDefault) {

error(d.name, Diagnostics.Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead, declarationNameToString(d.name));

function checkGrammarDisallowedModifiersOnObjectLiteralExpressionMethod(node: Node) {

// We only disallow modifier on a method declaration if it is a property of object-literal-expression

if (isAsyncFunctionLike(node)) {

if (node.modifiers.length > 1) {

return grammarErrorOnFirstToken(node, Diagnostics.Modifiers_cannot_appear_here);

}

const previousEnumMemberIsNonConstant = autoValue === undefined;

let initializer = member.initializer;

if (initializer) {

autoValue = computeConstantValueForEnumMemberInitializer(initializer, enumType, enumIsConst, ambient);

}

else if (ambient) {

error(initializer, Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression);

else {

// Only here do we need to check that the initializer is assignable to the enum type.

checkTypeAssignableTo(checkExpression(initializer), enumType, initializer, /*headMessage*/ undefined);

Debug.assert(node.kind === SyntaxKind.Identifier);

return <Identifier>node;

}

function checkExternalImportOrExportDeclaration(node: ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration): boolean {

let moduleName = getExternalModuleName(node);

if (!nodeIsMissing(moduleName) && moduleName.kind !== SyntaxKind.StringLiteral) {

}

break;

}

if (introducesArgumentsExoticObject(location)) {

copySymbol(argumentsSymbol, meaning);

}

memberFlags = location.flags;

location = location.parent;

}

}

// const enums and modules that contain only const enums are not considered values from the emit perespective

// unless 'preserveConstEnums' option is set to true

(compilerOptions.preserveConstEnums || !isConstEnumOrConstEnumOnlyModule(target));

}

function isFunctionType(type: Type): boolean {

return type.flags & TypeFlags.ObjectType && getSignaturesOfType(type, SignatureKind.Call).length > 0;

}

function getTypeReferenceSerializationKind(typeName: EntityName): TypeReferenceSerializationKind {

// Resolve the symbol as a value to ensure the type can be reached at runtime during emit.

let valueSymbol = resolveEntityName(typeName, SymbolFlags.Value, /*ignoreErrors*/ true);

let typeSymbol = resolveEntityName(typeName, SymbolFlags.Type, /*ignoreErrors*/ true);

// We might not be able to resolve type symbol so use unknown type in that case (eg error case)

if (!typeSymbol) {

}

let type = getDeclaredTypeOfSymbol(typeSymbol);

if (type === unknownType) {