/// If fullTypeCheck === true, then the typechecker should do every possible check to produce all errors

/// If fullTypeCheck === false, the typechecker can take shortcuts and skip checks that only produce errors.

/// NOTE: checks that somehow affect decisions being made during typechecking should be executed in both cases.

var Symbol = objectAllocator.getSymbolConstructor();

var Type = objectAllocator.getTypeConstructor();

var Signature = objectAllocator.getSignatureConstructor();

}

function reportErrorsFromWidening(declaration: Declaration, type: Type) {

// Report implicit any error within type if possible, otherwise report error on declaration

if (!reportWideningErrorsInType(type)) {

reportImplicitAnyError(declaration, type);

// Pick the first candidate that matches the arity. This way we can get a contextual type for cases like:

// declare function f(a: { xa: number; xb: number; });

// f({ |

for (var i = 0, n = candidates.length; i < n; i++) {

if (hasCorrectArity(node, args, candidates[i])) {

return candidates[i];

function checkTypeAssertion(node: TypeAssertion): Type {

var exprType = checkExpression(node.expression);

var targetType = getTypeFromTypeNode(node.type);

var widenedType = getWidenedType(exprType);

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

checkTypeAssignableTo(exprType, targetType, node, Diagnostics.Neither_type_0_nor_type_1_is_assignable_to_the_other);

// must have at least one return statement somewhere in its body.

// An exception to this rule is if the function implementation consists of a single 'throw' statement.

function checkIfNonVoidFunctionHasReturnExpressionsOrSingleThrowStatment(func: FunctionLikeDeclaration, returnType: Type): void {

return;

}

}

}

checkCollisionWithCapturedSuperVariable(node, (<FunctionExpression>node).name);

checkCollisionWithCapturedThisVariable(node,(<FunctionExpression>node).name);

}

}

function checkAssignmentOperator(valueType: Type): void {

// TypeScript 1.0 spec (April 2014): 4.17

// An assignment of the form

// VarExpr = ValueExpr

function checkTypeParameter(node: TypeParameterDeclaration) {

checkSourceElement(node.constraint);

checkTypeParameterHasIllegalReferencesInConstraint(node);

checkTypeNameIsReserved(node.name, Diagnostics.Type_parameter_name_cannot_be_0);

}

if (node.type) {

checkSourceElement(node.type);

}

checkCollisionWithArgumentsInGeneratedCode(node);

if (compilerOptions.noImplicitAny && !node.type) {

switch (node.kind) {

return;

}

return;

}

}

function checkAccessorDeclaration(node: AccessorDeclaration) {

if (node.kind === SyntaxKind.GetAccessor) {

if (!isInAmbientContext(node) && node.body && !(bodyContainsAReturnStatement(<Block>node.body) || bodyContainsSingleThrowStatement(<Block>node.body))) {

error(node.name, Diagnostics.A_get_accessor_must_return_a_value_or_consist_of_a_single_throw_statement);

for (var i = 0; i < len; i++) {

checkSourceElement(node.typeArguments[i]);

var constraint = getConstraintOfTypeParameter((<TypeReference>type).target.typeParameters[i]);

var typeArgument = (<TypeReference>type).typeArguments[i];

checkTypeAssignableTo(typeArgument, constraint, node, Diagnostics.Type_0_does_not_satisfy_the_constraint_1);

}

function checkTypeLiteral(node: TypeLiteralNode) {

forEach(node.members, checkSourceElement);

var type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);

checkIndexConstraints(type);

checkTypeForDuplicateIndexSignatures(node);

}

function checkSpecializedSignatureDeclaration(signatureDeclarationNode: SignatureDeclaration): void {

return;

}

var signature = getSignatureFromDeclaration(signatureDeclarationNode);

}

function checkFunctionOrConstructorSymbol(symbol: Symbol): void {

return;

}

}

function checkExportsOnMergedDeclarations(node: Node): void {

return;

}

function checkFunctionDeclaration(node: FunctionDeclaration): void {

checkFunctionLikeDeclaration(node);

checkCollisionWithCapturedSuperVariable(node, node.name);

checkCollisionWithCapturedThisVariable(node, node.name);

checkCollisionWithRequireExportsInGeneratedCode(node, node.name);

function checkSwitchStatement(node: SwitchStatement) {

var expressionType = checkExpression(node.expression);

forEach(node.clauses, clause => {

var caseClause = <CaseClause>clause;

// TypeScript 1.0 spec (April 2014):5.9

// In a 'switch' statement, each 'case' expression must be of a type that is assignable to or from the type of the 'switch' expression.

var node = typeParameterDeclarations[i];

checkTypeParameter(node);

for (var j = 0; j < i; j++) {

if (typeParameterDeclarations[j].symbol === node.symbol) {

error(node.name, Diagnostics.Duplicate_identifier_0, declarationNameToString(node.name));

checkTypeReference(baseTypeNode);

}

if (type.baseTypes.length) {

var baseType = type.baseTypes[0];

checkTypeAssignableTo(type, baseType, node.name, Diagnostics.Class_0_incorrectly_extends_base_class_1);

var staticBaseType = getTypeOfSymbol(baseType.symbol);

if (implementedTypeNodes) {

forEach(implementedTypeNodes, typeRefNode => {

checkTypeReference(typeRefNode);

var t = getTypeFromTypeReferenceNode(typeRefNode);

if (t !== unknownType) {

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

}

forEach(node.members, checkSourceElement);

checkIndexConstraints(type);

checkTypeForDuplicateIndexSignatures(node);

}

function checkInterfaceDeclaration(node: InterfaceDeclaration) {

checkTypeParameters(node.typeParameters);

checkTypeNameIsReserved(node.name, Diagnostics.Interface_name_cannot_be_0);

checkExportsOnMergedDeclarations(node);

forEach(getInterfaceBaseTypeNodes(node), checkTypeReference);

forEach(node.members, checkSourceElement);

checkTypeForDuplicateIndexSignatures(node);

}

}

}

function checkEnumDeclaration(node: EnumDeclaration) {

return;

}

}

function checkModuleDeclaration(node: ModuleDeclaration) {

checkCollisionWithCapturedThisVariable(node, node.name);

checkCollisionWithRequireExportsInGeneratedCode(node, node.name);

checkExportsOnMergedDeclarations(node);

}

function getSortedDiagnostics(): Diagnostic[]{

if (diagnosticsModified) {

diagnostics.sort(compareDiagnostics);

return diagnostics;

}

if (sourceFile) {

checkSourceFile(sourceFile);

return filter(getSortedDiagnostics(), d => d.file === sourceFile);

return getSortedDiagnostics();

}

return filter(getSortedDiagnostics(), d => !d.file);

}

// Language service support

function isInsideWithStatementBody(node: Node): boolean {

verifyCompilerOptions();

errors.sort(compareDiagnostics);

}

else {

}

}

return program;

function getDeclarationDiagnostics(targetSourceFile: SourceFile): Diagnostic[]{

fullTypeChecker.getDiagnostics(targetSourceFile);

var resolver = fullTypeChecker.getEmitResolver();

return ts.getDeclarationDiagnostics(program, resolver, targetSourceFile);

}

function invokeEmitter(targetSourceFile?: SourceFile) {

return emitFiles(resolver, targetSourceFile);

}

getGlobalDiagnostics(): Diagnostic[];

getDeclarationDiagnostics(sourceFile: SourceFile): Diagnostic[];

getCommonSourceDirectory(): string;

emitFiles(targetSourceFile?: SourceFile): EmitResult;

}

ts.sys.useCaseSensitiveFileNames);

// TODO (drosen): We need to enforce checking on these tests.

var program = ts.createProgram([Harness.Compiler.fourslashFilename, fileName], { out: "fourslashTestOutput.js", noResolve: true, target: ts.ScriptTarget.ES3 }, host);

var errors = program.getDiagnostics().concat(checker.getDiagnostics());

if (errors.length > 0) {

options.target,

useCaseSensitiveFileNames));

var isEmitBlocked = checker.isEmitBlocked();

var errors = program.getDiagnostics();

var sourceMapData: ts.SourceMapData[] = null;

if (!errors.length) {

errors = checker.getDiagnostics();

var emitResult = program.emitFiles();

errors = ts.concatenate(errors, emitResult.diagnostics);