let fileName = "tsconfig.json";

while (true) {

if (fileExists(fileName)) {

return fileName;

}

const parentPath = getDirectoryPath(searchPath);

if (parentPath === searchPath) {

break;

}

searchPath = parentPath;

fileName = "../" + fileName;

}

return undefined;

const basePath = getDirectoryPath(containingFile);

const referencedFileName = isRootedDiskPath(moduleName) ? moduleName : combinePaths(basePath, moduleName);

return normalizePath(referencedFileName);

const moduleResolution = compilerOptions.moduleResolution !== undefined

? compilerOptions.moduleResolution

: compilerOptions.module === ModuleKind.CommonJS ? ModuleResolutionKind.NodeJs : ModuleResolutionKind.Classic;

switch (moduleResolution) {

case ModuleResolutionKind.NodeJs: return nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host);

case ModuleResolutionKind.Classic: return classicNameResolver(moduleName, containingFile, compilerOptions, host);

}

const containingDirectory = getDirectoryPath(containingFile);

const supportedExtensions = getSupportedExtensions(compilerOptions);

if (getRootLength(moduleName) !== 0 || nameStartsWithDotSlashOrDotDotSlash(moduleName)) {

const failedLookupLocations: string[] = [];

const candidate = normalizePath(combinePaths(containingDirectory, moduleName));

let resolvedFileName = loadNodeModuleFromFile(supportedExtensions, candidate, failedLookupLocations, host);

if (resolvedFileName) {

return { resolvedModule: { resolvedFileName }, failedLookupLocations };

}

resolvedFileName = loadNodeModuleFromDirectory(supportedExtensions, candidate, failedLookupLocations, host);

return resolvedFileName

? { resolvedModule: { resolvedFileName }, failedLookupLocations }

: { resolvedModule: undefined, failedLookupLocations };

}

else {

return loadModuleFromNodeModules(moduleName, containingDirectory, host);

}

return forEach(extensions, tryLoad);

function tryLoad(ext: string): string {

const fileName = fileExtensionIs(candidate, ext) ? candidate : candidate + ext;

if (host.fileExists(fileName)) {

return fileName;

}

else {

failedLookupLocation.push(fileName);

return undefined;

}

}

const packageJsonPath = combinePaths(candidate, "package.json");

if (host.fileExists(packageJsonPath)) {

let jsonContent: { typings?: string };

try {

const jsonText = host.readFile(packageJsonPath);

jsonContent = jsonText ? <{ typings?: string }>JSON.parse(jsonText) : { typings: undefined };

}

catch (e) {

// gracefully handle if readFile fails or returns not JSON

jsonContent = { typings: undefined };

}

if (typeof jsonContent.typings === "string") {

const result = loadNodeModuleFromFile(extensions, normalizePath(combinePaths(candidate, jsonContent.typings)), failedLookupLocation, host);

if (result) {

return result;

}

}

}

else {

// record package json as one of failed lookup locations - in the future if this file will appear it will invalidate resolution results

failedLookupLocation.push(packageJsonPath);

}

return loadNodeModuleFromFile(extensions, combinePaths(candidate, "index"), failedLookupLocation, host);

const failedLookupLocations: string[] = [];

directory = normalizeSlashes(directory);

while (true) {

const baseName = getBaseFileName(directory);

if (baseName !== "node_modules") {

const nodeModulesFolder = combinePaths(directory, "node_modules");

const candidate = normalizePath(combinePaths(nodeModulesFolder, moduleName));

// Load only typescript files irrespective of allowJs option if loading from node modules

let result = loadNodeModuleFromFile(supportedTypeScriptExtensions, candidate, failedLookupLocations, host);

if (result) {

return { resolvedModule: { resolvedFileName: result, isExternalLibraryImport: true }, failedLookupLocations };

}

result = loadNodeModuleFromDirectory(supportedTypeScriptExtensions, candidate, failedLookupLocations, host);

if (result) {

return { resolvedModule: { resolvedFileName: result, isExternalLibraryImport: true }, failedLookupLocations };

}

}

const parentPath = getDirectoryPath(directory);

if (parentPath === directory) {

break;

}

directory = parentPath;

}

return { resolvedModule: undefined, failedLookupLocations };

// module names that contain '!' are used to reference resources and are not resolved to actual files on disk

if (moduleName.indexOf("!") != -1) {

return { resolvedModule: undefined, failedLookupLocations: [] };

}

let searchPath = getDirectoryPath(containingFile);

let searchName: string;

const failedLookupLocations: string[] = [];

let referencedSourceFile: string;

const supportedExtensions = getSupportedExtensions(compilerOptions);

while (true) {

searchName = normalizePath(combinePaths(searchPath, moduleName));

referencedSourceFile = forEach(supportedExtensions, extension => {

if (extension === ".tsx" && !compilerOptions.jsx) {

// resolve .tsx files only if jsx support is enabled

// 'logical not' handles both undefined and None cases

return undefined;

}

const candidate = searchName + extension;

if (host.fileExists(candidate)) {

return candidate;

}

else {

failedLookupLocations.push(candidate);

}

});

if (referencedSourceFile) {

break;

}

const parentPath = getDirectoryPath(searchPath);

if (parentPath === searchPath) {

break;

}

searchPath = parentPath;

}

return referencedSourceFile

? { resolvedModule: { resolvedFileName: referencedSourceFile }, failedLookupLocations }

: { resolvedModule: undefined, failedLookupLocations };

const existingDirectories: Map<boolean> = {};

function getCanonicalFileName(fileName: string): string {

// if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form.

// otherwise use toLowerCase as a canonical form.

return sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();

}

// returned by CScript sys environment

const unsupportedFileEncodingErrorCode = -2147024809;

function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile {

let text: string;

try {

const start = new Date().getTime();

text = sys.readFile(fileName, options.charset);

ioReadTime += new Date().getTime() - start;

}

catch (e) {

if (onError) {

onError(e.number === unsupportedFileEncodingErrorCode

? createCompilerDiagnostic(Diagnostics.Unsupported_file_encoding).messageText

: e.message);

}

text = "";

}

return text !== undefined ? createSourceFile(fileName, text, languageVersion, setParentNodes) : undefined;

}

function directoryExists(directoryPath: string): boolean {

if (hasProperty(existingDirectories, directoryPath)) {

return true;

}

if (sys.directoryExists(directoryPath)) {

existingDirectories[directoryPath] = true;

return true;

}

return false;

}

function ensureDirectoriesExist(directoryPath: string) {

if (directoryPath.length > getRootLength(directoryPath) && !directoryExists(directoryPath)) {

const parentDirectory = getDirectoryPath(directoryPath);

ensureDirectoriesExist(parentDirectory);

sys.createDirectory(directoryPath);

}

}

function writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) {

try {

const start = new Date().getTime();

ensureDirectoriesExist(getDirectoryPath(normalizePath(fileName)));

sys.writeFile(fileName, data, writeByteOrderMark);

ioWriteTime += new Date().getTime() - start;

}

catch (e) {

if (onError) {

onError(e.message);

}

}

}

const newLine = getNewLineCharacter(options);

return {

getSourceFile,

getDefaultLibFileName: options => combinePaths(getDirectoryPath(normalizePath(sys.getExecutingFilePath())), getDefaultLibFileName(options)),

writeFile,

getCurrentDirectory: memoize(() => sys.getCurrentDirectory()),

useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames,

getCanonicalFileName,

getNewLine: () => newLine,

fileExists: fileName => sys.fileExists(fileName),

readFile: fileName => sys.readFile(fileName)

};

let diagnostics = program.getOptionsDiagnostics(cancellationToken).concat(

program.getSyntacticDiagnostics(sourceFile, cancellationToken),

program.getGlobalDiagnostics(cancellationToken),

program.getSemanticDiagnostics(sourceFile, cancellationToken));

if (program.getCompilerOptions().declaration) {

diagnostics = diagnostics.concat(program.getDeclarationDiagnostics(sourceFile, cancellationToken));

}

return sortAndDeduplicateDiagnostics(diagnostics);

if (typeof messageText === "string") {

return messageText;

}

else {

let diagnosticChain = messageText;

let result = "";

let indent = 0;

while (diagnosticChain) {

if (indent) {

result += newLine;

for (let i = 0; i < indent; i++) {

result += " ";

}

}

result += diagnosticChain.messageText;

indent++;

diagnosticChain = diagnosticChain.next;

}

return result;

}

let program: Program;

let files: SourceFile[] = [];

let fileProcessingDiagnostics = createDiagnosticCollection();

const programDiagnostics = createDiagnosticCollection();

let commonSourceDirectory: string;

let diagnosticsProducingTypeChecker: TypeChecker;

let noDiagnosticsTypeChecker: TypeChecker;

let classifiableNames: Map<string>;

let skipDefaultLib = options.noLib;

const supportedExtensions = getSupportedExtensions(options);

const start = new Date().getTime();

host = host || createCompilerHost(options);

// Map storing if there is emit blocking diagnostics for given input

const hasEmitBlockingDiagnostics = createFileMap<boolean>(getCanonicalFileName);

const currentDirectory = host.getCurrentDirectory();

const resolveModuleNamesWorker = host.resolveModuleNames

? ((moduleNames: string[], containingFile: string) => host.resolveModuleNames(moduleNames, containingFile))

: ((moduleNames: string[], containingFile: string) => map(moduleNames, moduleName => resolveModuleName(moduleName, containingFile, options, host).resolvedModule));

const filesByName = createFileMap<SourceFile>();

// stores 'filename -> file association' ignoring case

// used to track cases when two file names differ only in casing

const filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? createFileMap<SourceFile>(fileName => fileName.toLowerCase()) : undefined;

if (oldProgram) {

// check properties that can affect structure of the program or module resolution strategy

// if any of these properties has changed - structure cannot be reused

const oldOptions = oldProgram.getCompilerOptions();

if ((oldOptions.module !== options.module) ||

(oldOptions.noResolve !== options.noResolve) ||

(oldOptions.target !== options.target) ||

(oldOptions.noLib !== options.noLib) ||

(oldOptions.jsx !== options.jsx) ||

(oldOptions.allowJs !== options.allowJs)) {

oldProgram = undefined;

}

}

if (!tryReuseStructureFromOldProgram()) {

forEach(rootNames, name => processRootFile(name, /*isDefaultLib*/ false));

// Do not process the default library if:

// - The '--noLib' flag is used.

// - A 'no-default-lib' reference comment is encountered in

// processing the root files.

if (!skipDefaultLib) {

processRootFile(host.getDefaultLibFileName(options), /*isDefaultLib*/ true);

}

}

// unconditionally set oldProgram to undefined to prevent it from being captured in closure

oldProgram = undefined;

program = {

getRootFileNames: () => rootNames,

getSourceFile,

getSourceFiles: () => files,

getCompilerOptions: () => options,

getSyntacticDiagnostics,

getOptionsDiagnostics,

getGlobalDiagnostics,

getSemanticDiagnostics,

getDeclarationDiagnostics,

getTypeChecker,

getClassifiableNames,

getDiagnosticsProducingTypeChecker,

getCommonSourceDirectory,

emit,

getCurrentDirectory: () => currentDirectory,

getNodeCount: () => getDiagnosticsProducingTypeChecker().getNodeCount(),

getIdentifierCount: () => getDiagnosticsProducingTypeChecker().getIdentifierCount(),

getSymbolCount: () => getDiagnosticsProducingTypeChecker().getSymbolCount(),

getTypeCount: () => getDiagnosticsProducingTypeChecker().getTypeCount(),

getFileProcessingDiagnostics: () => fileProcessingDiagnostics

};

verifyCompilerOptions();

programTime += new Date().getTime() - start;

return program;

function getCommonSourceDirectory() {

if (typeof commonSourceDirectory === "undefined") {

if (options.rootDir && checkSourceFilesBelongToPath(files, options.rootDir)) {

// If a rootDir is specified and is valid use it as the commonSourceDirectory

commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir, currentDirectory);

}

else {

commonSourceDirectory = computeCommonSourceDirectory(files);

}

if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== directorySeparator) {

// Make sure directory path ends with directory separator so this string can directly

// used to replace with "" to get the relative path of the source file and the relative path doesn't

// start with / making it rooted path

commonSourceDirectory += directorySeparator;

}

}

return commonSourceDirectory;

}

function getClassifiableNames() {

if (!classifiableNames) {

// Initialize a checker so that all our files are bound.

getTypeChecker();

classifiableNames = {};

for (const sourceFile of files) {

copyMap(sourceFile.classifiableNames, classifiableNames);

}

}

return classifiableNames;

}

function tryReuseStructureFromOldProgram(): boolean {

if (!oldProgram) {

return false;

}

Debug.assert(!oldProgram.structureIsReused);

// there is an old program, check if we can reuse its structure

const oldRootNames = oldProgram.getRootFileNames();

if (!arrayIsEqualTo(oldRootNames, rootNames)) {

return false;

}

// check if program source files has changed in the way that can affect structure of the program

const newSourceFiles: SourceFile[] = [];

const filePaths: Path[] = [];

const modifiedSourceFiles: SourceFile[] = [];

for (const oldSourceFile of oldProgram.getSourceFiles()) {

let newSourceFile = host.getSourceFile(oldSourceFile.fileName, options.target);

if (!newSourceFile) {

return false;

}

newSourceFile.path = oldSourceFile.path;

filePaths.push(newSourceFile.path);

if (oldSourceFile !== newSourceFile) {

if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) {

// value of no-default-lib has changed

// this will affect if default library is injected into the list of files

return false;

}

// check tripleslash references

if (!arrayIsEqualTo(oldSourceFile.referencedFiles, newSourceFile.referencedFiles, fileReferenceIsEqualTo)) {

// tripleslash references has changed

return false;

}

// check imports

collectExternalModuleReferences(newSourceFile);

if (!arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) {

// imports has changed

return false;

}

if (resolveModuleNamesWorker) {

const moduleNames = map(newSourceFile.imports, name => name.text);

const resolutions = resolveModuleNamesWorker(moduleNames, getNormalizedAbsolutePath(newSourceFile.fileName, currentDirectory));

// ensure that module resolution results are still correct

for (let i = 0; i < moduleNames.length; i++) {

const newResolution = resolutions[i];

const oldResolution = getResolvedModule(oldSourceFile, moduleNames[i]);

const resolutionChanged = oldResolution

? !newResolution ||

oldResolution.resolvedFileName !== newResolution.resolvedFileName ||

!!oldResolution.isExternalLibraryImport !== !!newResolution.isExternalLibraryImport

: newResolution;

if (resolutionChanged) {

return false;

}

}

}

// pass the cache of module resolutions from the old source file

newSourceFile.resolvedModules = oldSourceFile.resolvedModules;

modifiedSourceFiles.push(newSourceFile);

}

else {

// file has no changes - use it as is

newSourceFile = oldSourceFile;

}

// if file has passed all checks it should be safe to reuse it

newSourceFiles.push(newSourceFile);

}

// update fileName -> file mapping

for (let i = 0, len = newSourceFiles.length; i < len; i++) {

filesByName.set(filePaths[i], newSourceFiles[i]);

}

files = newSourceFiles;

fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics();

for (const modifiedFile of modifiedSourceFiles) {

fileProcessingDiagnostics.reattachFileDiagnostics(modifiedFile);

}

oldProgram.structureIsReused = true;

return true;

}

function getEmitHost(writeFileCallback?: WriteFileCallback): EmitHost {

return {

getCanonicalFileName,

getCommonSourceDirectory: program.getCommonSourceDirectory,

getCompilerOptions: program.getCompilerOptions,

getCurrentDirectory: () => currentDirectory,

getNewLine: () => host.getNewLine(),

getSourceFile: program.getSourceFile,

getSourceFiles: program.getSourceFiles,

writeFile: writeFileCallback || (

(fileName, data, writeByteOrderMark, onError) => host.writeFile(fileName, data, writeByteOrderMark, onError)),

isEmitBlocked,

};

}

function getDiagnosticsProducingTypeChecker() {

return diagnosticsProducingTypeChecker || (diagnosticsProducingTypeChecker = createTypeChecker(program, /*produceDiagnostics:*/ true));

}

function getTypeChecker() {

return noDiagnosticsTypeChecker || (noDiagnosticsTypeChecker = createTypeChecker(program, /*produceDiagnostics:*/ false));

}

// TODO: needs to have this: Program

function emit(sourceFile?: SourceFile, writeFileCallback?: WriteFileCallback, cancellationToken?: CancellationToken): EmitResult {

return runWithCancellationToken(() => emitWorker((<any>this), sourceFile, writeFileCallback, cancellationToken));

}

function isEmitBlocked(emitFileName: string): boolean {

return hasEmitBlockingDiagnostics.contains(toPath(emitFileName, currentDirectory, getCanonicalFileName));

}

function emitWorker(program: Program, sourceFile: SourceFile, writeFileCallback: WriteFileCallback, cancellationToken: CancellationToken): EmitResult {

// If the noEmitOnError flag is set, then check if we have any errors so far. If so,

// immediately bail out. Note that we pass 'undefined' for 'sourceFile' so that we

// get any preEmit diagnostics, not just the ones

if (options.noEmitOnError) {

const preEmitDiagnostics = getPreEmitDiagnostics(program, /*sourceFile:*/ undefined, cancellationToken);

if (preEmitDiagnostics.length > 0) {

return { diagnostics: preEmitDiagnostics, sourceMaps: undefined, emitSkipped: true };

}

}

// Create the emit resolver outside of the "emitTime" tracking code below. That way

// any cost associated with it (like type checking) are appropriate associated with

// the type-checking counter.

//

// If the -out option is specified, we should not pass the source file to getEmitResolver.

// This is because in the -out scenario all files need to be emitted, and therefore all

// files need to be type checked. And the way to specify that all files need to be type

// checked is to not pass the file to getEmitResolver.

const emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile);

const start = new Date().getTime();

const emitResult = emitFiles(

emitResolver,

getEmitHost(writeFileCallback),

sourceFile);

emitTime += new Date().getTime() - start;

return emitResult;

}

function getSourceFile(fileName: string): SourceFile {

return filesByName.get(toPath(fileName, currentDirectory, getCanonicalFileName));

}

function getDiagnosticsHelper(

sourceFile: SourceFile,

getDiagnostics: (sourceFile: SourceFile, cancellationToken: CancellationToken) => Diagnostic[],

cancellationToken: CancellationToken): Diagnostic[] {

if (sourceFile) {

return getDiagnostics(sourceFile, cancellationToken);

}

const allDiagnostics: Diagnostic[] = [];

forEach(program.getSourceFiles(), sourceFile => {

if (cancellationToken) {

cancellationToken.throwIfCancellationRequested();

}

addRange(allDiagnostics, getDiagnostics(sourceFile, cancellationToken));

});

return sortAndDeduplicateDiagnostics(allDiagnostics);

}

function getSyntacticDiagnostics(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {

return getDiagnosticsHelper(sourceFile, getSyntacticDiagnosticsForFile, cancellationToken);

}

function getSemanticDiagnostics(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {

return getDiagnosticsHelper(sourceFile, getSemanticDiagnosticsForFile, cancellationToken);

}

function getDeclarationDiagnostics(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {

return getDiagnosticsHelper(sourceFile, getDeclarationDiagnosticsForFile, cancellationToken);

}

function getSyntacticDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {

return sourceFile.parseDiagnostics;

}

function runWithCancellationToken<T>(func: () => T): T {

try {

return func();

}

catch (e) {

if (e instanceof OperationCanceledException) {

// We were canceled while performing the operation. Because our type checker

// might be a bad state, we need to throw it away.

//

// Note: we are overly agressive here. We do not actually *have* to throw away

// the "noDiagnosticsTypeChecker". However, for simplicity, i'd like to keep

// the lifetimes of these two TypeCheckers the same. Also, we generally only

// cancel when the user has made a change anyways. And, in that case, we (the

// program instance) will get thrown away anyways. So trying to keep one of

// these type checkers alive doesn't serve much purpose.

noDiagnosticsTypeChecker = undefined;

diagnosticsProducingTypeChecker = undefined;

}

throw e;

}

}

function getSemanticDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {

return runWithCancellationToken(() => {

const typeChecker = getDiagnosticsProducingTypeChecker();

Debug.assert(!!sourceFile.bindDiagnostics);

const bindDiagnostics = sourceFile.bindDiagnostics;

// For JavaScript files, we don't want to report the normal typescript semantic errors.

// Instead, we just report errors for using TypeScript-only constructs from within a

// JavaScript file.

const checkDiagnostics = isSourceFileJavaScript(sourceFile) ?

getJavaScriptSemanticDiagnosticsForFile(sourceFile, cancellationToken) :

typeChecker.getDiagnostics(sourceFile, cancellationToken);

const fileProcessingDiagnosticsInFile = fileProcessingDiagnostics.getDiagnostics(sourceFile.fileName);

const programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName);

return bindDiagnostics.concat(checkDiagnostics).concat(fileProcessingDiagnosticsInFile).concat(programDiagnosticsInFile);

});

}

function getJavaScriptSemanticDiagnosticsForFile(sourceFile: SourceFile, cancellationToken: CancellationToken): Diagnostic[] {

return runWithCancellationToken(() => {

const diagnostics: Diagnostic[] = [];

walk(sourceFile);

return diagnostics;

function walk(node: Node): boolean {

if (!node) {

return false;

}

switch (node.kind) {

case SyntaxKind.ImportEqualsDeclaration:

diagnostics.push(createDiagnosticForNode(node, Diagnostics.import_can_only_be_used_in_a_ts_file));

return true;

case SyntaxKind.ExportAssignment:

diagnostics.push(createDiagnosticForNode(node, Diagnostics.export_can_only_be_used_in_a_ts_file));

return true;

case SyntaxKind.ClassDeclaration:

let classDeclaration = <ClassDeclaration>node;

if (checkModifiers(classDeclaration.modifiers) ||

checkTypeParameters(classDeclaration.typeParameters)) {

return true;

}

break;

case SyntaxKind.HeritageClause:

let heritageClause = <HeritageClause>node;

if (heritageClause.token === SyntaxKind.ImplementsKeyword) {

diagnostics.push(createDiagnosticForNode(node, Diagnostics.implements_clauses_can_only_be_used_in_a_ts_file));

return true;

}

break;

case SyntaxKind.InterfaceDeclaration:

diagnostics.push(createDiagnosticForNode(node, Diagnostics.interface_declarations_can_only_be_used_in_a_ts_file));

return true;

case SyntaxKind.ModuleDeclaration:

diagnostics.push(createDiagnosticForNode(node, Diagnostics.module_declarations_can_only_be_used_in_a_ts_file));

return true;

case SyntaxKind.TypeAliasDeclaration:

diagnostics.push(createDiagnosticForNode(node, Diagnostics.type_aliases_can_only_be_used_in_a_ts_file));

return true;

case SyntaxKind.MethodDeclaration:

case SyntaxKind.MethodSignature:

case SyntaxKind.Constructor:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

case SyntaxKind.FunctionExpression:

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.ArrowFunction:

case SyntaxKind.FunctionDeclaration:

const functionDeclaration = <FunctionLikeDeclaration>node;

if (checkModifiers(functionDeclaration.modifiers) ||

checkTypeParameters(functionDeclaration.typeParameters) ||

checkTypeAnnotation(functionDeclaration.type)) {

return true;

}

break;

case SyntaxKind.VariableStatement:

const variableStatement = <VariableStatement>node;

if (checkModifiers(variableStatement.modifiers)) {

return true;

}

break;

case SyntaxKind.VariableDeclaration:

const variableDeclaration = <VariableDeclaration>node;

if (checkTypeAnnotation(variableDeclaration.type)) {

return true;

}

break;

case SyntaxKind.CallExpression:

case SyntaxKind.NewExpression:

const expression = <CallExpression>node;

if (expression.typeArguments && expression.typeArguments.length > 0) {

const start = expression.typeArguments.pos;

diagnostics.push(createFileDiagnostic(sourceFile, start, expression.typeArguments.end - start,

Diagnostics.type_arguments_can_only_be_used_in_a_ts_file));

return true;

}

break;

case SyntaxKind.Parameter:

const parameter = <ParameterDeclaration>node;

if (parameter.modifiers) {

const start = parameter.modifiers.pos;

diagnostics.push(createFileDiagnostic(sourceFile, start, parameter.modifiers.end - start,

Diagnostics.parameter_modifiers_can_only_be_used_in_a_ts_file));

return true;

}

if (parameter.questionToken) {

diagnostics.push(createDiagnosticForNode(parameter.questionToken, Diagnostics._0_can_only_be_used_in_a_ts_file, "?"));

return true;

}

if (parameter.type) {

diagnostics.push(createDiagnosticForNode(parameter.type, Diagnostics.types_can_only_be_used_in_a_ts_file));

return true;

}

break;

case SyntaxKind.PropertyDeclaration:

diagnostics.push(createDiagnosticForNode(node, Diagnostics.property_declarations_can_only_be_used_in_a_ts_file));

return true;

case SyntaxKind.EnumDeclaration:

diagnostics.push(createDiagnosticForNode(node, Diagnostics.enum_declarations_can_only_be_used_in_a_ts_file));

return true;

case SyntaxKind.TypeAssertionExpression:

let typeAssertionExpression = <TypeAssertion>node;

diagnostics.push(createDiagnosticForNode(typeAssertionExpression.type, Diagnostics.type_assertion_expressions_can_only_be_used_in_a_ts_file));

return true;

case SyntaxKind.Decorator:

diagnostics.push(createDiagnosticForNode(node, Diagnostics.decorators_can_only_be_used_in_a_ts_file));

return true;

}

return forEachChild(node, walk);

}

function checkTypeParameters(typeParameters: NodeArray<TypeParameterDeclaration>): boolean {

if (typeParameters) {

const start = typeParameters.pos;

diagnostics.push(createFileDiagnostic(sourceFile, start, typeParameters.end - start, Diagnostics.type_parameter_declarations_can_only_be_used_in_a_ts_file));

return true;

}

return false;

}

function checkTypeAnnotation(type: TypeNode): boolean {