// TYPE CHECKING

function isTypeIdenticalTo(source: Type, target: Type): boolean {

}

function compareTypes(source: Type, target: Type): Ternary {

}

function isTypeSubtypeOf(source: Type, target: Type): boolean {

return checkTypeSubtypeOf(source, target, /*errorNode*/ undefined);

}

function isTypeAssignableTo(source: Type, target: Type): boolean {

}

function checkTypeSubtypeOf(source: Type, target: Type, errorNode: Node, headMessage?: DiagnosticMessage, containingMessageChain?: DiagnosticMessageChain): boolean {

}

}

function isSignatureAssignableTo(source: Signature, target: Signature): boolean {

return checkTypeRelatedTo(sourceType, targetType, assignableRelation, /*errorNode*/ undefined);

}

function checkTypeRelatedTo(

source: Type,

target: Type,

relation: Map<RelationComparisonResult>,

headMessage?: DiagnosticMessage,

let errorInfo: DiagnosticMessageChain;

let sourceStack: ObjectType[];

typeArgumentsAreAssignable = checkTypeAssignableTo(

typeArgument,

constraint,

reportErrors ? typeArgNode : undefined,

typeArgumentHeadMessage,

errorInfo);

// Use argument expression as error location when reporting errors

let errorNode = reportErrors ? getEffectiveArgumentErrorNode(node, i, arg) : undefined;

let headMessage = Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1;

return false;

}

}

if (produceDiagnostics && targetType !== unknownType) {

let widenedType = getWidenedType(exprType);

if (!(isTypeAssignableTo(targetType, widenedType))) {

}

}

return targetType;

else {

let exprType = checkExpression(<Expression>node.body);

if (node.type) {

}

checkFunctionAndClassExpressionBodies(node.body);

}

function checkReferenceAssignment(target: Expression, sourceType: Type, contextualMapper?: TypeMapper): Type {

let targetType = checkExpression(target, contextualMapper);

if (checkReferenceExpression(target, Diagnostics.Invalid_left_hand_side_of_assignment_expression, Diagnostics.Left_hand_side_of_assignment_expression_cannot_be_a_constant)) {

}

return sourceType;

}

// Use default messages

if (ok) {

// to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported

}

}

}

if (func.type) {

let signatureElementType = getElementTypeOfIterableIterator(getTypeFromTypeNode(func.type)) || anyType;

if (nodeIsYieldStar) {

}

else {

}

}

}

else {

checkTypeAssignableTo(typePredicate.type,

getTypeAtLocation(node.parameters[typePredicate.parameterIndex]),

}

}

else if (typePredicateNode.parameterName) {

// interface BadGenerator extends Iterable<number>, Iterator<string> { }

// function* g(): BadGenerator { } // Iterable and Iterator have different types!

//

}

}

}

let constraint = getConstraintOfTypeParameter(typeParameters[i]);

if (constraint) {

let typeArgument = typeArguments[i];

}

}

return result;

checkTypeAssignableTo(

returnType,

expectedReturnType,

node,

headMessage,

errorInfo);

// For a binding pattern, validate the initializer and exit

if (isBindingPattern(node.name)) {

if (node.initializer) {

checkParameterInitializer(node);

}

return;

if (node === symbol.valueDeclaration) {

// Node is the primary declaration of the symbol, just validate the initializer

if (node.initializer) {

checkParameterInitializer(node);

}

}

error(node.name, Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2, declarationNameToString(node.name), typeToString(type), typeToString(declarationType));

}

if (node.initializer) {

}

}

if (node.kind !== SyntaxKind.PropertyDeclaration && node.kind !== SyntaxKind.PropertySignature) {

function checkExpressionStatement(node: ExpressionStatement) {

// Grammar checking

checkExpression(node.expression);

}

// because we accessed properties from anyType, or it may have led to an error inside

// getElementTypeOfIterable.

if (iteratedType) {

}

}

}

// Now even though we have extracted the iteratedType, we will have to validate that the type

// passed in is actually an Iterable.

if (errorNode && elementType) {

}

return elementType || anyType;

}

}

else if (func.type || isGetAccessorWithAnnotatatedSetAccessor(func) || signature.typePredicate) {

}

}

}

let caseType = checkExpression(caseClause.expression);

if (!isTypeAssignableTo(expressionType, caseType)) {

// check 'expressionType isAssignableTo caseType' failed, try the reversed check and report errors if it fails

}

}

forEach(clause.statements, checkSourceElement);

}

}

}

Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);

if (!(staticBaseType.symbol && staticBaseType.symbol.flags & SymbolFlags.Class)) {

// When the static base type is a "class-like" constructor function (but not actually a class), we verify

if (t !== unknownType) {

let declaredType = (t.flags & TypeFlags.Reference) ? (<TypeReference>t).target : t;

if (declaredType.flags & (TypeFlags.Class | TypeFlags.Interface)) {

}

else {

error(typeRefNode, Diagnostics.A_class_may_only_implement_another_class_or_interface);

// run subsequent checks only if first set succeeded

if (checkInheritedPropertiesAreIdentical(type, node.name)) {

forEach(getBaseTypes(type), baseType => {

});

checkIndexConstraints(type);

}

// If it is a constant value (not undefined), it is syntactically constrained to be a number.

// Also, we do not need to check this for ambients because there is already

// a syntax error if it is not a constant.

}

}

else if (enumIsConst) {