Merge remote-tracking branch 'origin/master' into explicitly_included_globs

2025-11-18 17:21:48 +00:00 · 2016-07-12 11:21:53 -07:00
commit fd2caf6e48
@@ -17,6 +17,7 @@ tests/baselines/reference/projectOutput/*
 tests/baselines/local/projectOutput/*
 tests/services/baselines/prototyping/local/*
 tests/services/browser/typescriptServices.js
+scripts/authors.js
 scripts/configureNightly.js
 scripts/processDiagnosticMessages.d.ts
 scripts/processDiagnosticMessages.js
@@ -50,3 +51,4 @@ internal/
 !**/.vscode/tasks.json
 !tests/cases/projects/projectOption/**/node_modules
 !tests/cases/projects/NodeModulesSearch/**/*
+!tests/baselines/reference/project/nodeModules*/**/*
@@ -125,6 +125,7 @@ Stan Thomas <stmsdn@norvil.net>
 Stanislav Sysoev <d4rkr00t@gmail.com>
 Steve Lucco <steveluc@users.noreply.github.com> steveluc <steveluc@microsoft.com>
 Tarik <tarik@pushmote.com> # Tarik Ozket
+Tetsuharu OHZEKI <saneyuki.snyk@gmail.com> # Tetsuharu Ohzeki
 Tien Nguyen <tihoanh@microsoft.com> tien <hoanhtien@users.noreply.github.com> unknown <tihoanh@microsoft.com> #Tien Hoanhtien
 Tim Perry <pimterry@gmail.com>
 Tim Viiding-Spader <viispade@users.noreply.github.com>
@@ -11,8 +11,11 @@ import newer = require("gulp-newer");
 import tsc = require("gulp-typescript");
 declare module "gulp-typescript" {
    interface Settings {
-        stripInternal?: boolean;
+        pretty?: boolean;
        newLine?: string;
+        noImplicitThis?: boolean;
+        stripInternal?: boolean;
+        types?: string[];
    }
    interface CompileStream extends NodeJS.ReadWriteStream {} // Either gulp or gulp-typescript has some odd typings which don't reflect reality, making this required
 }
@@ -82,12 +85,9 @@ let host = cmdLineOptions["host"];

 // Constants
 const compilerDirectory = "src/compiler/";
-const servicesDirectory = "src/services/";
-const serverDirectory = "src/server/";
 const harnessDirectory = "src/harness/";
 const libraryDirectory = "src/lib/";
 const scriptsDirectory = "scripts/";
-const unittestsDirectory = "tests/cases/unittests/";
 const docDirectory = "doc/";

 const builtDirectory = "built/";
@@ -104,69 +104,6 @@ const nodeModulesPathPrefix = path.resolve("./node_modules/.bin/");
 const isWin = /^win/.test(process.platform);
 const mocha = path.join(nodeModulesPathPrefix, "mocha") + (isWin ? ".cmd" : "");

-const compilerSources = require("./src/compiler/tsconfig.json").files.map((file) => path.join(compilerDirectory, file));
-
-const servicesSources = require("./src/services/tsconfig.json").files.map((file) => path.join(servicesDirectory, file));
-
-const serverCoreSources = require("./src/server/tsconfig.json").files.map((file) => path.join(serverDirectory, file));
-
-const languageServiceLibrarySources = [
-    "editorServices.ts",
-    "protocol.d.ts",
-    "session.ts"
-].map(function (f) {
-    return path.join(serverDirectory, f);
-}).concat(servicesSources);
-
-const harnessCoreSources = [
-    "harness.ts",
-    "sourceMapRecorder.ts",
-    "harnessLanguageService.ts",
-    "fourslash.ts",
-    "runnerbase.ts",
-    "compilerRunner.ts",
-    "typeWriter.ts",
-    "fourslashRunner.ts",
-    "projectsRunner.ts",
-    "loggedIO.ts",
-    "rwcRunner.ts",
-    "test262Runner.ts",
-    "runner.ts"
-].map(function (f) {
-    return path.join(harnessDirectory, f);
-});
-
-const harnessSources = harnessCoreSources.concat([
-    "incrementalParser.ts",
-    "jsDocParsing.ts",
-    "services/colorization.ts",
-    "services/documentRegistry.ts",
-    "services/preProcessFile.ts",
-    "services/patternMatcher.ts",
-    "session.ts",
-    "versionCache.ts",
-    "convertToBase64.ts",
-    "transpile.ts",
-    "reuseProgramStructure.ts",
-    "cachingInServerLSHost.ts",
-    "moduleResolution.ts",
-    "tsconfigParsing.ts",
-    "commandLineParsing.ts",
-    "convertCompilerOptionsFromJson.ts",
-    "convertTypingOptionsFromJson.ts",
-    "tsserverProjectSystem.ts",
-    "matchFiles.ts",
-].map(function (f) {
-    return path.join(unittestsDirectory, f);
-})).concat([
-    "protocol.d.ts",
-    "session.ts",
-    "client.ts",
-    "editorServices.ts"
-].map(function (f) {
-    return path.join(serverDirectory, f);
-}));
-
 const es2015LibrarySources = [
    "es2015.core.d.ts",
    "es2015.collection.d.ts",
@@ -306,6 +243,11 @@ function needsUpdate(source: string | string[], dest: string | string[]): boolea

 function getCompilerSettings(base: tsc.Settings, useBuiltCompiler?: boolean): tsc.Settings {
    const copy: tsc.Settings = {};
+    copy.noEmitOnError = true;
+    copy.noImplicitAny = true;
+    copy.noImplicitThis = true;
+    copy.pretty = true;
+    copy.types = [];
    for (const key in base) {
        copy[key] = base[key];
    }
@@ -492,21 +434,18 @@ const tsserverLibraryFile = path.join(builtLocalDirectory, "tsserverlibrary.js")
 const tsserverLibraryDefinitionFile = path.join(builtLocalDirectory, "tsserverlibrary.d.ts");

 gulp.task(tsserverLibraryFile, false, [servicesFile], (done) => {
-    const settings: tsc.Settings = getCompilerSettings({
-        declaration: true,
-        outFile: tsserverLibraryFile
-    }, /*useBuiltCompiler*/ true);
-    const {js, dts}: {js: NodeJS.ReadableStream, dts: NodeJS.ReadableStream} = gulp.src(languageServiceLibrarySources)
+    const serverLibraryProject = tsc.createProject("src/server/tsconfig.library.json", getCompilerSettings({}, /*useBuiltCompiler*/ true));
+    const {js, dts}: {js: NodeJS.ReadableStream, dts: NodeJS.ReadableStream} = serverLibraryProject.src()
        .pipe(sourcemaps.init())
        .pipe(newer(tsserverLibraryFile))
-        .pipe(tsc(settings));
+        .pipe(tsc(serverLibraryProject));

    return merge2([
        js.pipe(prependCopyright())
          .pipe(sourcemaps.write("."))
-          .pipe(gulp.dest(".")),
+          .pipe(gulp.dest(builtLocalDirectory)),
        dts.pipe(prependCopyright())
-        .pipe(gulp.dest("."))
+        .pipe(gulp.dest(builtLocalDirectory))
    ]);
 });

@@ -575,15 +514,13 @@ gulp.task("LKG", "Makes a new LKG out of the built js files", ["clean", "dontUse
 // Task to build the tests infrastructure using the built compiler
 const run = path.join(builtLocalDirectory, "run.js");
 gulp.task(run, false, [servicesFile], () => {
-    const settings: tsc.Settings = getCompilerSettings({
-        outFile: run
-    }, /*useBuiltCompiler*/ true);
-    return gulp.src(harnessSources)
+    const testProject = tsc.createProject("src/harness/tsconfig.json", getCompilerSettings({}, /*useBuiltCompiler*/true));
+    return testProject.src()
        .pipe(newer(run))
        .pipe(sourcemaps.init())
-        .pipe(tsc(settings))
+        .pipe(tsc(testProject))
        .pipe(sourcemaps.write(".", { includeContent: false, sourceRoot: "../../" }))
-        .pipe(gulp.dest("."));
+        .pipe(gulp.dest(builtLocalDirectory));
 });

 const internalTests = "internal/";
@@ -758,13 +695,11 @@ gulp.task(nodeServerOutFile, false, [servicesFile], () => {
 });

 gulp.task("browserify", "Runs browserify on run.js to produce a file suitable for running tests in the browser", [servicesFile], (done) => {
-    const settings: tsc.Settings = getCompilerSettings({
-        outFile: "built/local/bundle.js"
-    }, /*useBuiltCompiler*/ true);
-    return gulp.src(harnessSources)
+    const testProject = tsc.createProject("src/harness/tsconfig.json", getCompilerSettings({ outFile: "built/local/bundle.js" }, /*useBuiltCompiler*/ true));
+    return testProject.src()
        .pipe(newer("built/local/bundle.js"))
        .pipe(sourcemaps.init())
-        .pipe(tsc(settings))
+        .pipe(tsc(testProject))
        .pipe(through2.obj((file, enc, next) => {
            browserify(intoStream(file.contents))
                .bundle((err, res) => {
@@ -1005,36 +940,37 @@ function lintFile(options, path) {
    return lintFileContents(options, path, contents);
 }

-const lintTargets = ["Gulpfile.ts"]
-    .concat(compilerSources)
-    .concat(harnessSources)
-    // Other harness sources
-    .concat(["instrumenter.ts"].map(function(f) { return path.join(harnessDirectory, f); }))
-    .concat(serverCoreSources)
-    .concat(tslintRulesFiles)
-    .concat(servicesSources);
+const lintTargets = [
+    "Gulpfile.ts",
+    "src/compiler/**/*.ts",
+    "src/harness/**/*.ts",
+    "!src/harness/unittests/services/formatting/**/*.ts",
+    "src/server/**/*.ts",
+    "scripts/tslint/**/*.ts",
+    "src/services/**/*.ts",
+];


 gulp.task("lint", "Runs tslint on the compiler sources. Optional arguments are: --f[iles]=regex", ["build-rules"], () => {
+    const fileMatcher = RegExp(cmdLineOptions["files"]);
    const lintOptions = getLinterOptions();
    let failed = 0;
-    const fileMatcher = RegExp(cmdLineOptions["files"]);
-    const done = {};
-    for (const i in lintTargets) {
-        const target = lintTargets[i];
-        if (!done[target] && fileMatcher.test(target)) {
-            const result = lintFile(lintOptions, target);
+    return gulp.src(lintTargets)
+        .pipe(insert.transform((contents, file) => {
+            if (!fileMatcher.test(file.path)) return contents;
+            const result = lintFile(lintOptions, file.path);
            if (result.failureCount > 0) {
                console.log(result.output);
                failed += result.failureCount;
            }
-            done[target] = true;
-        }
-    }
-    if (failed > 0) {
-        console.error("Linter errors.");
-        process.exit(1);
-    }
+            return contents; // TODO (weswig): Automatically apply fixes? :3
+        }))
+        .on("end", () => {
+            if (failed > 0) {
+                console.error("Linter errors.");
+                process.exit(1);
+            }
+        });
 });


@@ -14,7 +14,7 @@ var serverDirectory = "src/server/";
 var harnessDirectory = "src/harness/";
 var libraryDirectory = "src/lib/";
 var scriptsDirectory = "scripts/";
-var unittestsDirectory = "tests/cases/unittests/";
+var unittestsDirectory = "src/harness/unittests/";
 var docDirectory = "doc/";

 var builtDirectory = "built/";
@@ -100,7 +100,6 @@ var servicesSources = [
 }));

 var serverCoreSources = [
-    "node.d.ts",
    "editorServices.ts",
    "protocol.d.ts",
    "session.ts",
@@ -279,13 +278,18 @@ var builtLocalCompiler = path.join(builtLocalDirectory, compilerFilename);
    * @param {boolean} opts.stripInternal: true if compiler should remove declarations marked as @internal
    * @param {boolean} opts.noMapRoot: true if compiler omit mapRoot option
    * @param {boolean} opts.inlineSourceMap: true if compiler should inline sourceMap
+    * @param {Array} opts.types: array of types to include in compilation
    * @param callback: a function to execute after the compilation process ends
    */
 function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, opts, callback) {
    file(outFile, prereqs, function() {
-        var compilerPath = useBuiltCompiler ? builtLocalCompiler : LKGCompiler;
-        var options = "--noImplicitAny --noEmitOnError --types --pretty";
        opts = opts || {};
+        var compilerPath = useBuiltCompiler ? builtLocalCompiler : LKGCompiler;
+        var options = "--noImplicitAny --noImplicitThis --noEmitOnError --types " 
+        if (opts.types) {
+            options += opts.types.join(",");
+        }
+        options += " --pretty";
        // Keep comments when specifically requested
        // or when in debug mode.
        if (!(opts.keepComments || useDebugMode)) {
@@ -548,8 +552,7 @@ compileFile(
     });

 var serverFile = path.join(builtLocalDirectory, "tsserver.js");
-compileFile(serverFile, serverSources,[builtLocalDirectory, copyright].concat(serverSources), /*prefixes*/ [copyright], /*useBuiltCompiler*/ true);
-
+compileFile(serverFile, serverSources,[builtLocalDirectory, copyright].concat(serverSources), /*prefixes*/ [copyright], /*useBuiltCompiler*/ true, { types: ["node"] });
 var tsserverLibraryFile = path.join(builtLocalDirectory, "tsserverlibrary.js");
 var tsserverLibraryDefinitionFile = path.join(builtLocalDirectory, "tsserverlibrary.d.ts");
 compileFile(
@@ -652,7 +655,7 @@ compileFile(
    /*prereqs*/ [builtLocalDirectory, tscFile].concat(libraryTargets).concat(harnessSources),
    /*prefixes*/ [],
    /*useBuiltCompiler:*/ true,
-    /*opts*/ { inlineSourceMap: true });
+    /*opts*/ { inlineSourceMap: true, types: ["node", "mocha", "chai"] });

 var internalTests = "internal/";

@@ -2,7 +2,7 @@
    "name": "typescript",
    "author": "Microsoft Corp.",
    "homepage": "http://typescriptlang.org/",
-    "version": "2.0.0",
+    "version": "2.1.0",
    "license": "Apache-2.0",
    "description": "TypeScript is a language for application scale JavaScript development",
    "keywords": [
@@ -30,6 +30,7 @@
    },
    "devDependencies": {
        "@types/browserify": "latest",
+        "@types/chai": "latest",
        "@types/del": "latest",
        "@types/glob": "latest",
        "@types/gulp": "latest",
@@ -42,6 +43,7 @@
        "@types/minimatch": "latest",
        "@types/minimist": "latest",
        "@types/mkdirp": "latest",
+        "@types/mocha": "latest",
        "@types/node": "latest",
        "@types/q": "latest",
        "@types/run-sequence": "latest",
@@ -3166,17 +3166,17 @@ namespace ts {
                }

                let type: Type = undefined;
-                // Handle module.exports = expr or this.p = expr
-                if (declaration.kind === SyntaxKind.BinaryExpression) {
-                    type = getUnionType(map(symbol.declarations, (decl: BinaryExpression) => checkExpressionCached(decl.right)));
-                }
-                else if (declaration.kind === SyntaxKind.PropertyAccessExpression) {
-                    // Declarations only exist for property access expressions for certain
-                    // special assignment kinds
-                    if (declaration.parent.kind === SyntaxKind.BinaryExpression) {
-                        // Handle exports.p = expr  or className.prototype.method = expr
-                        type = checkExpressionCached((<BinaryExpression>declaration.parent).right);
-                    }
+                // Handle certain special assignment kinds, which happen to union across multiple declarations:
+                // * module.exports = expr
+                // * exports.p = expr
+                // * this.p = expr
+                // * className.prototype.method = expr
+                if (declaration.kind === SyntaxKind.BinaryExpression ||
+                    declaration.kind === SyntaxKind.PropertyAccessExpression && declaration.parent.kind === SyntaxKind.BinaryExpression) {
+                    type = getUnionType(map(symbol.declarations,
+                                            decl => decl.kind === SyntaxKind.BinaryExpression ?
+                                                        checkExpressionCached((<BinaryExpression>decl).right) :
+                                                        checkExpressionCached((<BinaryExpression>decl.parent).right)));
                }

                if (type === undefined) {
@@ -11673,7 +11673,7 @@ namespace ts {
        function getInferredClassType(symbol: Symbol) {
            const links = getSymbolLinks(symbol);
            if (!links.inferredClassType) {
-                links.inferredClassType = createAnonymousType(undefined, symbol.members, emptyArray, emptyArray, /*stringIndexType*/ undefined, /*numberIndexType*/ undefined);
+                links.inferredClassType = createAnonymousType(symbol, symbol.members, emptyArray, emptyArray, /*stringIndexType*/ undefined, /*numberIndexType*/ undefined);
            }
            return links.inferredClassType;
        }
@@ -1271,20 +1271,20 @@ namespace ts {
        getSignatureConstructor(): new (checker: TypeChecker) => Signature;
    }

-    function Symbol(flags: SymbolFlags, name: string) {
+    function Symbol(this: Symbol, flags: SymbolFlags, name: string) {
        this.flags = flags;
        this.name = name;
        this.declarations = undefined;
    }

-    function Type(checker: TypeChecker, flags: TypeFlags) {
+    function Type(this: Type, checker: TypeChecker, flags: TypeFlags) {
        this.flags = flags;
    }

    function Signature(checker: TypeChecker) {
    }

-    function Node(kind: SyntaxKind, pos: number, end: number) {
+    function Node(this: Node, kind: SyntaxKind, pos: number, end: number) {
        this.kind = kind;
        this.pos = pos;
        this.end = end;
@@ -6374,6 +6374,9 @@ namespace ts {
                                case SyntaxKind.AtToken:
                                    if (canParseTag) {
                                        parentTagTerminated = !tryParseChildTag(jsDocTypeLiteral);
+                                        if (!parentTagTerminated) {
+                                            resumePos = scanner.getStartPos();
+                                        }
                                    }
                                    seenAsterisk = false;
                                    break;
@@ -9,7 +9,7 @@ namespace ts {
    /* @internal */ export let ioWriteTime = 0;

    /** The version of the TypeScript compiler release */
-    export const version = "2.0.0";
+    export const version = "2.1.0";

    const emptyArray: any[] = [];

@@ -1095,13 +1095,13 @@ namespace ts {
        // As all these operations happen - and are nested - within the createProgram call, they close over the below variables.
        // The current resolution depth is tracked by incrementing/decrementing as the depth first search progresses.
        const maxNodeModulesJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 2;
-        let currentNodeModulesJsDepth = 0;
+        let currentNodeModulesDepth = 0;

        // If a module has some of its imports skipped due to being at the depth limit under node_modules, then track
        // this, as it may be imported at a shallower depth later, and then it will need its skipped imports processed.
        const modulesWithElidedImports: Map<boolean> = {};

-        // Track source files that are JavaScript files found by searching under node_modules, as these shouldn't be compiled.
+        // Track source files that are source files found by searching under node_modules, as these shouldn't be compiled.
        const sourceFilesFoundSearchingNodeModules: Map<boolean> = {};

        const start = new Date().getTime();
@@ -1399,7 +1399,7 @@ namespace ts {
        }

        function emit(sourceFile?: SourceFile, writeFileCallback?: WriteFileCallback, cancellationToken?: CancellationToken): EmitResult {
-            return runWithCancellationToken(() => emitWorker(this, sourceFile, writeFileCallback, cancellationToken));
+            return runWithCancellationToken(() => emitWorker(program, sourceFile, writeFileCallback, cancellationToken));
        }

        function isEmitBlocked(emitFileName: string): boolean {
@@ -1918,9 +1918,21 @@ namespace ts {
                    reportFileNamesDifferOnlyInCasingError(fileName, file.fileName, refFile, refPos, refEnd);
                }

+                // If the file was previously found via a node_modules search, but is now being processed as a root file,
+                // then everything it sucks in may also be marked incorrectly, and needs to be checked again.
+                if (file && lookUp(sourceFilesFoundSearchingNodeModules, file.path) && currentNodeModulesDepth == 0) {
+                    sourceFilesFoundSearchingNodeModules[file.path] = false;
+                    if (!options.noResolve) {
+                        processReferencedFiles(file, getDirectoryPath(fileName), isDefaultLib);
+                        processTypeReferenceDirectives(file);
+                    }
+
+                    modulesWithElidedImports[file.path] = false;
+                    processImportedModules(file, getDirectoryPath(fileName));
+                }
                // See if we need to reprocess the imports due to prior skipped imports
-                if (file && lookUp(modulesWithElidedImports, file.path)) {
-                    if (currentNodeModulesJsDepth < maxNodeModulesJsDepth) {
+                else if (file && lookUp(modulesWithElidedImports, file.path)) {
+                    if (currentNodeModulesDepth < maxNodeModulesJsDepth) {
                        modulesWithElidedImports[file.path] = false;
                        processImportedModules(file, getDirectoryPath(fileName));
                    }
@@ -1942,6 +1954,7 @@ namespace ts {

            filesByName.set(path, file);
            if (file) {
+                sourceFilesFoundSearchingNodeModules[path] = (currentNodeModulesDepth > 0);
                file.path = path;

                if (host.useCaseSensitiveFileNames()) {
@@ -2075,13 +2088,10 @@ namespace ts {
                    const isJsFileFromNodeModules = isFromNodeModulesSearch && hasJavaScriptFileExtension(resolution.resolvedFileName);

                    if (isFromNodeModulesSearch) {
-                        sourceFilesFoundSearchingNodeModules[resolvedPath] = true;
-                    }
-                    if (isJsFileFromNodeModules) {
-                        currentNodeModulesJsDepth++;
+                        currentNodeModulesDepth++;
                    }

-                    const elideImport = isJsFileFromNodeModules && currentNodeModulesJsDepth > maxNodeModulesJsDepth;
+                    const elideImport = isJsFileFromNodeModules && currentNodeModulesDepth > maxNodeModulesJsDepth;
                    const shouldAddFile = resolution && !options.noResolve && i < file.imports.length && !elideImport;

                    if (elideImport) {
@@ -2096,8 +2106,8 @@ namespace ts {
                                file.imports[i].end);
                    }

-                    if (isJsFileFromNodeModules) {
-                        currentNodeModulesJsDepth--;
+                    if (isFromNodeModulesSearch) {
+                        currentNodeModulesDepth--;
                    }
                }
            }
@@ -182,7 +182,7 @@ namespace ts {
                return matchFiles(path, extensions, excludes, includes, /*useCaseSensitiveFileNames*/ false, shell.CurrentDirectory, getAccessibleFileSystemEntries);
            }

-            return {
+            const wscriptSystem: System = {
                args,
                newLine: "\r\n",
                useCaseSensitiveFileNames: false,
@@ -201,7 +201,7 @@ namespace ts {
                    return fso.FolderExists(path);
                },
                createDirectory(directoryName: string) {
-                    if (!this.directoryExists(directoryName)) {
+                    if (!wscriptSystem.directoryExists(directoryName)) {
                        fso.CreateFolder(directoryName);
                    }
                },
@@ -221,6 +221,7 @@ namespace ts {
                    }
                }
            };
+            return wscriptSystem;
        }

        function getNodeSystem(): System {
@@ -439,7 +440,7 @@ namespace ts {
                return filter<string>(_fs.readdirSync(path), p => fileSystemEntryExists(combinePaths(path, p), FileSystemEntryKind.Directory));
            }

-            return {
+            const nodeSystem: System = {
                args: process.argv.slice(2),
                newLine: _os.EOL,
                useCaseSensitiveFileNames: useCaseSensitiveFileNames,
@@ -501,7 +502,7 @@ namespace ts {
                fileExists,
                directoryExists,
                createDirectory(directoryName: string) {
-                    if (!this.directoryExists(directoryName)) {
+                    if (!nodeSystem.directoryExists(directoryName)) {
                        _fs.mkdirSync(directoryName);
                    }
                },
@@ -549,6 +550,7 @@ namespace ts {
                    return _fs.realpathSync(path);
                }
            };
+            return nodeSystem;
        }

        function getChakraSystem(): System {
@@ -1,8 +1,10 @@
 {
    "compilerOptions": {
        "noImplicitAny": true,
+        "noImplicitThis": true,
        "removeComments": true,
        "preserveConstEnums": true,
+        "pretty": true,
        "outFile": "../../built/local/tsc.js",
        "sourceMap": true,
        "declaration": true,
@@ -1,179 +0,0 @@
-// Type definitions for chai 1.7.2
-// Project: http://chaijs.com/
-// Definitions by: Jed Hunsaker <https://github.com/jedhunsaker/>
-// DefinitelyTyped: https://github.com/borisyankov/DefinitelyTyped
-
-
-declare module chai {
-
-    function expect(target: any, message?: string): Expect;
-
-    // Provides a way to extend the internals of Chai
-    function use(fn: (chai: any, utils: any) => void): any;
-
-    interface ExpectStatic {
-        (target: any): Expect;
-    }
-
-    interface Assertions {
-        attr(name: string, value?: string): any;
-        css(name: string, value?: string): any;
-        data(name: string, value?: string): any;
-        class(className: string): any;
-        id(id: string): any;
-        html(html: string): any;
-        text(text: string): any;
-        value(value: string): any;
-        visible: any;
-        hidden: any;
-        selected: any;
-        checked: any;
-        disabled: any;
-        empty: any;
-        exist: any;
-    }
-
-    interface Expect extends LanguageChains, NumericComparison, TypeComparison, Assertions {
-        not: Expect;
-        deep: Deep;
-        a: TypeComparison;
-        an: TypeComparison;
-        include: Include;
-        contain: Include;
-        ok: Expect;
-        true: Expect;
-        false: Expect;
-        null: Expect;
-        undefined: Expect;
-        exist: Expect;
-        empty: Expect;
-        arguments: Expect;
-        Arguments: Expect;
-        equal: Equal;
-        equals: Equal;
-        eq: Equal;
-        eql: Equal;
-        eqls: Equal;
-        property: Property;
-        ownProperty: OwnProperty;
-        haveOwnProperty: OwnProperty;
-        length: Length;
-        lengthOf: Length;
-        match(RegularExpression: RegExp, message?: string): Expect;
-        string(string: string, message?: string): Expect;
-        keys: Keys;
-        key(string: string): Expect;
-        throw: Throw;
-        throws: Throw;
-        Throw: Throw;
-        respondTo(method: string, message?: string): Expect;
-        itself: Expect;
-        satisfy(matcher: Function, message?: string): Expect;
-        closeTo(expected: number, delta: number, message?: string): Expect;
-        members: Members;
-    }
-
-    interface LanguageChains {
-        to: Expect;
-        be: Expect;
-        been: Expect;
-        is: Expect;
-        that: Expect;
-        and: Expect;
-        have: Expect;
-        with: Expect;
-        at: Expect;
-        of: Expect;
-        same: Expect;
-    }
-
-    interface NumericComparison {
-        above: NumberComparer;
-        gt: NumberComparer;
-        greaterThan: NumberComparer;
-        least: NumberComparer;
-        gte: NumberComparer;
-        below: NumberComparer;
-        lt: NumberComparer;
-        lessThan: NumberComparer;
-        most: NumberComparer;
-        lte: NumberComparer;
-        within(start: number, finish: number, message?: string): Expect;
-    }
-
-    interface NumberComparer {
-        (value: number, message?: string): Expect;
-    }
-
-    interface TypeComparison {
-        (type: string, message?: string): Expect;
-        instanceof: InstanceOf;
-        instanceOf: InstanceOf;
-    }
-
-    interface InstanceOf {
-        (constructor: Object, message?: string): Expect;
-    }
-
-    interface Deep {
-        equal: Equal;
-        property: Property;
-    }
-
-    interface Equal {
-        (value: any, message?: string): Expect;
-    }
-
-    interface Property {
-        (name: string, value?: any, message?: string): Expect;
-    }
-
-    interface OwnProperty {
-        (name: string, message?: string): Expect;
-    }
-
-    interface Length extends LanguageChains, NumericComparison {
-        (length: number, message?: string): Expect;
-    }
-
-    interface Include {
-        (value: Object, message?: string): Expect;
-        (value: string, message?: string): Expect;
-        (value: number, message?: string): Expect;
-        keys: Keys;
-        members: Members;
-    }
-
-    interface Keys {
-        (...keys: string[]): Expect;
-        (keys: any[]): Expect;
-    }
-
-    interface Members {
-        (set: any[], message?: string): Expect;
-    }
-
-    interface Throw {
-        (): Expect;
-        (expected: string, message?: string): Expect;
-        (expected: RegExp, message?: string): Expect;
-        (constructor: Error, expected?: string, message?: string): Expect;
-        (constructor: Error, expected?: RegExp, message?: string): Expect;
-        (constructor: Function, expected?: string, message?: string): Expect;
-        (constructor: Function, expected?: RegExp, message?: string): Expect;
-    }
-
-    function assert(expression: any, message?: string): void;
-    module assert {
-        function equal(actual: any, expected: any, message?: string): void;
-        function notEqual(actual: any, expected: any, message?: string): void;
-        function deepEqual<T>(actual: T, expected: T, message?: string): void;
-        function notDeepEqual<T>(actual: T, expected: T, message?: string): void;
-        function lengthOf(object: any[], length: number, message?: string): void;
-        function isTrue(value: any, message?: string): void;
-        function isFalse(value: any, message?: string): void;
-        function isOk(actual: any, message?: string): void;
-        function isUndefined(value: any, message?: string): void;
-        function isDefined(value: any, message?: string): void;
-    }
-}
@@ -1,45 +0,0 @@
-// Type definitions for mocha 1.9.0
-// Project: http://visionmedia.github.io/mocha/
-// Definitions by: Kazi Manzur Rashid <https://github.com/kazimanzurrashid/>
-// DefinitelyTyped: https://github.com/borisyankov/DefinitelyTyped
-
-declare var describe : {
-    (description: string, spec: () => void): void;
-    only(description: string, spec: () => void): void;
-    skip(description: string, spec: () => void): void;
-    timeout(ms: number): void;
-}
-
-declare var it: {
-    (expectation: string, assertion?: () => void): void;
-    (expectation: string, assertion?: (done: () => void) => void): void;
-    only(expectation: string, assertion?: () => void): void;
-    only(expectation: string, assertion?: (done: () => void) => void): void;
-    skip(expectation: string, assertion?: () => void): void;
-    skip(expectation: string, assertion?: (done: () => void) => void): void;
-    timeout(ms: number): void;
-};
-
-/** Runs once before any 'it' blocks in the current 'describe' are run */
-declare function before(action: () => void): void;
-
-/** Runs once before any 'it' blocks in the current 'describe' are run */
-declare function before(action: (done: () => void) => void): void;
-
-/** Runs once after all 'it' blocks in the current 'describe' are run */
-declare function after(action: () => void): void;
-
-/** Runs once after all 'it' blocks in the current 'describe' are run */
-declare function after(action: (done: () => void) => void): void;
-
-/** Runs before each individual 'it' block in the current 'describe' is run */
-declare function beforeEach(action: () => void): void;
-
-/** Runs before each individual 'it' block in the current 'describe' is run */
-declare function beforeEach(action: (done: () => void) => void): void;
-
-/** Runs after each individual 'it' block in the current 'describe' is run */
-declare function afterEach(action: () => void): void;
-
-/** Runs after each individual 'it' block in the current 'describe' is run */
-declare function afterEach(action: (done: () => void) => void): void;
@@ -18,12 +18,13 @@
 /// <reference path="..\services\shims.ts" />
 /// <reference path="..\server\session.ts" />
 /// <reference path="..\server\client.ts" />
-/// <reference path="..\server\node.d.ts" />
-/// <reference path="external\mocha.d.ts"/>
-/// <reference path="external\chai.d.ts"/>
 /// <reference path="sourceMapRecorder.ts"/>
 /// <reference path="runnerbase.ts"/>
 /// <reference path="virtualFileSystem.ts" />
+/// <reference types="node" />
+/// <reference types="mocha" />
+/// <reference types="chai" />
+

 // Block scoped definitions work poorly for global variables, temporarily enable var
 /* tslint:disable:no-var-keyword */
@@ -32,7 +33,13 @@
 var _chai: typeof chai = require("chai");
 var assert: typeof _chai.assert = _chai.assert;
 declare var __dirname: string; // Node-specific
-var global = <any>Function("return this").call(undefined);
+var global: NodeJS.Global = <any>Function("return this").call(undefined);
+declare namespace NodeJS {
+    export interface Global {
+        WScript: typeof WScript;
+        ActiveXObject: typeof ActiveXObject;
+    }
+}
 /* tslint:enable:no-var-keyword */

 namespace Utils {
@@ -57,7 +64,7 @@ namespace Utils {

    export let currentExecutionEnvironment = getExecutionEnvironment();

-    const Buffer: BufferConstructor = currentExecutionEnvironment !== ExecutionEnvironment.Browser
+    const Buffer: typeof global.Buffer = currentExecutionEnvironment !== ExecutionEnvironment.Browser
        ? require("buffer").Buffer
        : undefined;

@@ -127,7 +134,7 @@ namespace Utils {
    export function memoize<T extends Function>(f: T): T {
        const cache: { [idx: string]: any } = {};

-        return <any>(function() {
+        return <any>(function(this: any) {
            const key = Array.prototype.join.call(arguments);
            const cachedResult = cache[key];
            if (cachedResult) {
@@ -479,17 +479,27 @@ class ProjectRunner extends RunnerBase {

                    it("Baseline of emitted result (" + moduleNameToString(moduleKind) + "): " + testCaseFileName, () => {
                        if (testCase.baselineCheck) {
+                            const errs: Error[] = [];
                            ts.forEach(compilerResult.outputFiles, outputFile => {
-
-                                Harness.Baseline.runBaseline("Baseline of emitted result (" + moduleNameToString(compilerResult.moduleKind) + "): " + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + outputFile.fileName, () => {
-                                    try {
-                                        return Harness.IO.readFile(getProjectOutputFolder(outputFile.fileName, compilerResult.moduleKind));
-                                    }
-                                    catch (e) {
-                                        return undefined;
-                                    }
-                                });
+                                // There may be multiple files with different baselines. Run all and report at the end, else
+                                // it stops copying the remaining emitted files from 'local/projectOutput' to 'local/project'.
+                                try {
+                                    Harness.Baseline.runBaseline("Baseline of emitted result (" + moduleNameToString(compilerResult.moduleKind) + "): " + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + outputFile.fileName, () => {
+                                        try {
+                                            return Harness.IO.readFile(getProjectOutputFolder(outputFile.fileName, compilerResult.moduleKind));
+                                        }
+                                        catch (e) {
+                                            return undefined;
+                                        }
+                                    });
+                                }
+                                catch (e) {
+                                    errs.push(e);
+                                }
                            });
+                            if (errs.length) {
+                                throw Error(errs.join("\n     "));
+                            }
                        }
                    });

@@ -0,0 +1,93 @@
+{
+    "compilerOptions": {
+        "noImplicitAny": true,
+        "pretty": true,
+        "removeComments": false,
+        "preserveConstEnums": true,
+        "outFile": "../../built/local/run.js",
+        "sourceMap": true,
+        "declaration": false,
+        "stripInternal": true,
+        "types": [
+            "node", "mocha", "chai"
+        ]
+    },
+    "files": [
+        "../compiler/core.ts",
+        "../compiler/sys.ts",
+        "../compiler/types.ts",
+        "../compiler/scanner.ts",
+        "../compiler/parser.ts",
+        "../compiler/utilities.ts",
+        "../compiler/binder.ts",
+        "../compiler/checker.ts",
+        "../compiler/sourcemap.ts",
+        "../compiler/declarationEmitter.ts",
+        "../compiler/emitter.ts",
+        "../compiler/program.ts",
+        "../compiler/commandLineParser.ts",
+        "../compiler/diagnosticInformationMap.generated.ts",
+        "../services/breakpoints.ts",
+        "../services/navigateTo.ts",
+        "../services/navigationBar.ts",
+        "../services/outliningElementsCollector.ts",
+        "../services/patternMatcher.ts",
+        "../services/services.ts",
+        "../services/shims.ts",
+        "../services/signatureHelp.ts",
+        "../services/utilities.ts",
+        "../services/jsTyping.ts",
+        "../services/formatting/formatting.ts",
+        "../services/formatting/formattingContext.ts",
+        "../services/formatting/formattingRequestKind.ts",
+        "../services/formatting/formattingScanner.ts",
+        "../services/formatting/references.ts",
+        "../services/formatting/rule.ts",
+        "../services/formatting/ruleAction.ts",
+        "../services/formatting/ruleDescriptor.ts",
+        "../services/formatting/ruleFlag.ts",
+        "../services/formatting/ruleOperation.ts",
+        "../services/formatting/ruleOperationContext.ts",
+        "../services/formatting/rules.ts",
+        "../services/formatting/rulesMap.ts",
+        "../services/formatting/rulesProvider.ts",
+        "../services/formatting/smartIndenter.ts",
+        "../services/formatting/tokenRange.ts",
+        "harness.ts",
+        "sourceMapRecorder.ts",
+        "harnessLanguageService.ts",
+        "fourslash.ts",
+        "runnerbase.ts",
+        "compilerRunner.ts",
+        "typeWriter.ts",
+        "fourslashRunner.ts",
+        "projectsRunner.ts",
+        "loggedIO.ts",
+        "rwcRunner.ts",
+        "test262Runner.ts",
+        "runner.ts",
+        "../server/protocol.d.ts",
+        "../server/session.ts",
+        "../server/client.ts",
+        "../server/editorServices.ts",
+        "./unittests/incrementalParser.ts",
+        "./unittests/jsDocParsing.ts",
+        "./unittests/services/colorization.ts",
+        "./unittests/services/documentRegistry.ts",
+        "./unittests/services/preProcessFile.ts",
+        "./unittests/services/patternMatcher.ts",
+        "./unittests/session.ts",
+        "./unittests/versionCache.ts",
+        "./unittests/convertToBase64.ts",
+        "./unittests/transpile.ts",
+        "./unittests/reuseProgramStructure.ts",
+        "./unittests/cachingInServerLSHost.ts",
+        "./unittests/moduleResolution.ts",
+        "./unittests/tsconfigParsing.ts",
+        "./unittests/commandLineParsing.ts",
+        "./unittests/convertCompilerOptionsFromJson.ts",
+        "./unittests/convertTypingOptionsFromJson.ts",
+        "./unittests/tsserverProjectSystem.ts",
+        "./unittests/matchFiles.ts"
+    ]
+}
@@ -1,4 +1,4 @@
-/// <reference path="..\..\..\src\harness\harness.ts" />
+/// <reference path="..\harness.ts" />

 namespace ts {
    interface File {
@@ -1,5 +1,5 @@
-/// <reference path="..\..\..\src\harness\harness.ts" />
-/// <reference path="..\..\..\src\compiler\commandLineParser.ts" />
+/// <reference path="..\harness.ts" />
+/// <reference path="..\..\compiler\commandLineParser.ts" />

 namespace ts {
    describe("parseCommandLine", () => {
@@ -1,5 +1,5 @@
-/// <reference path="..\..\..\src\harness\harness.ts" />
-/// <reference path="..\..\..\src\compiler\commandLineParser.ts" />
+/// <reference path="..\harness.ts" />
+/// <reference path="..\..\compiler\commandLineParser.ts" />

 namespace ts {
    describe("convertCompilerOptionsFromJson", () => {
@@ -1,4 +1,4 @@
-/// <reference path="..\..\..\src\harness\harness.ts" />
+/// <reference path="..\harness.ts" />

 namespace ts {
    describe("convertToBase64", () => {
@@ -1,5 +1,5 @@
-/// <reference path="..\..\..\src\harness\harness.ts" />
-/// <reference path="..\..\..\src\compiler\commandLineParser.ts" />
+/// <reference path="..\harness.ts" />
+/// <reference path="..\..\compiler\commandLineParser.ts" />

 namespace ts {
    describe("convertTypingOptionsFromJson", () => {
@@ -1,5 +1,5 @@
-/// <reference path="..\..\..\src\harness\external\mocha.d.ts" />
-/// <reference path="..\..\..\src\compiler\parser.ts" />
+/// <reference path="..\harness.ts" />
+/// <reference path="..\..\compiler\parser.ts" />

 namespace ts {
    ts.disableIncrementalParsing = false;
@@ -1,7 +1,5 @@
-/// <reference path="..\..\..\src\harness\external\mocha.d.ts" />
-/// <reference path="..\..\..\src\harness\external\chai.d.ts" />
-/// <reference path="..\..\..\src\compiler\parser.ts" />
-/// <reference path="..\..\..\src\harness\harness.ts" />
+/// <reference path="..\..\compiler\parser.ts" />
+/// <reference path="..\harness.ts" />

 namespace ts {
    describe("JSDocParsing", () => {
@@ -986,7 +984,7 @@ namespace ts {
        });

        describe("DocComments", () => {
-            function parsesCorrectly(content: string, expected: string) {
+            function parsesCorrectly(content: string, expected: string | {}) {
                const comment = parseIsolatedJSDocComment(content);
                if (!comment) {
                    Debug.fail("Comment failed to parse entirely");
@@ -995,30 +993,46 @@ namespace ts {
                    Debug.fail("Comment has at least one diagnostic: " + comment.diagnostics[0].messageText);
                }

-                const result = JSON.stringify(comment.jsDocComment, (k, v) => {
-                    return v && v.pos !== undefined
-                        ? JSON.parse(Utils.sourceFileToJSON(v))
-                        : v;
-                }, 4);
+                const result = toJsonString(comment.jsDocComment);

-                if (result !== expected) {
+                const expectedString = typeof expected === "string"
+                    ? expected
+                    : toJsonString(expected);
+                if (result !== expectedString) {
                    // Turn on a human-readable diff
                    if (typeof require !== "undefined") {
                        const chai = require("chai");
                        chai.config.showDiff = true;
-                        chai.expect(JSON.parse(result)).equal(JSON.parse(expected));
+                        // Use deep equal to compare key value data instead of the two objects
+                        chai.expect(JSON.parse(result)).deep.equal(JSON.parse(expectedString));
                    }
                    else {
-                        assert.equal(result, expected);
+                        assert.equal(result, expectedString);
                    }
                }
            }

+            function toJsonString(obj: {}) {
+                return JSON.stringify(obj, (k, v) => {
+                    return v && v.pos !== undefined
+                        ? JSON.parse(Utils.sourceFileToJSON(v))
+                        : v;
+                }, 4);
+            }
+
            function parsesIncorrectly(content: string) {
                const type = parseIsolatedJSDocComment(content);
                assert.isTrue(!type || type.diagnostics.length > 0);
            }

+            function reIndentJSDocComment(jsdocComment: string) {
+                const result = jsdocComment
+                    .replace(/[\t ]*\/\*\*/, "/**")
+                    .replace(/[\t ]*\*\s?@/g, "  * @")
+                    .replace(/[\t ]*\*\s?\//, "  */");
+                return result;
+            }
+
            describe("parsesIncorrectly", () => {
                it("emptyComment", () => {
                    parsesIncorrectly("/***/");
@@ -2216,6 +2230,152 @@ namespace ts {
    }
 }`);
                });
+
+                it("typedefTagWithChildrenTags", () => {
+                    const content =
+                    `/**
+                      * @typedef People
+                      * @type {Object}
+                      * @property {number} age
+                      * @property {string} name
+                      */`;
+                    const expected = {
+                        "end": 102,
+                        "kind": "JSDocComment",
+                        "pos": 0,
+                        "tags": {
+                            "0": {
+                                "atToken": {
+                                    "end": 9,
+                                    "kind": "AtToken",
+                                    "pos": 8
+                                },
+                                "end": 97,
+                                "jsDocTypeLiteral": {
+                                    "end": 97,
+                                    "jsDocPropertyTags": [
+                                        {
+                                            "atToken": {
+                                                "end": 48,
+                                                "kind": "AtToken",
+                                                "pos": 46
+                                            },
+                                            "end": 69,
+                                            "kind": "JSDocPropertyTag",
+                                            "name": {
+                                                "end": 69,
+                                                "kind": "Identifier",
+                                                "pos": 66,
+                                                "text": "age"
+                                            },
+                                            "pos": 46,
+                                            "tagName": {
+                                                "end": 56,
+                                                "kind": "Identifier",
+                                                "pos": 48,
+                                                "text": "property"
+                                            },
+                                            "typeExpression": {
+                                                "end": 65,
+                                                "kind": "JSDocTypeExpression",
+                                                "pos": 57,
+                                                "type": {
+                                                    "end": 64,
+                                                    "kind": "NumberKeyword",
+                                                    "pos": 58
+                                                }
+                                            }
+                                        },
+                                        {
+                                            "atToken": {
+                                                "end": 75,
+                                                "kind": "AtToken",
+                                                "pos": 73
+                                            },
+                                            "end": 97,
+                                            "kind": "JSDocPropertyTag",
+                                            "name": {
+                                                "end": 97,
+                                                "kind": "Identifier",
+                                                "pos": 93,
+                                                "text": "name"
+                                            },
+                                            "pos": 73,
+                                            "tagName": {
+                                                "end": 83,
+                                                "kind": "Identifier",
+                                                "pos": 75,
+                                                "text": "property"
+                                            },
+                                            "typeExpression": {
+                                                "end": 92,
+                                                "kind": "JSDocTypeExpression",
+                                                "pos": 84,
+                                                "type": {
+                                                    "end": 91,
+                                                    "kind": "StringKeyword",
+                                                    "pos": 85
+                                                }
+                                            }
+                                        }
+                                    ],
+                                    "jsDocTypeTag": {
+                                        "atToken": {
+                                            "end": 29,
+                                            "kind": "AtToken",
+                                            "pos": 27
+                                        },
+                                        "end": 42,
+                                        "kind": "JSDocTypeTag",
+                                        "pos": 27,
+                                        "tagName": {
+                                            "end": 33,
+                                            "kind": "Identifier",
+                                            "pos": 29,
+                                            "text": "type"
+                                        },
+                                        "typeExpression": {
+                                            "end": 42,
+                                            "kind": "JSDocTypeExpression",
+                                            "pos": 34,
+                                            "type": {
+                                                "end": 41,
+                                                "kind": "JSDocTypeReference",
+                                                "name": {
+                                                    "end": 41,
+                                                    "kind": "Identifier",
+                                                    "pos": 35,
+                                                    "text": "Object"
+                                                },
+                                                "pos": 35
+                                            }
+                                        }
+                                    },
+                                    "kind": "JSDocTypeLiteral",
+                                    "pos": 23
+                                },
+                                "kind": "JSDocTypedefTag",
+                                "name": {
+                                    "end": 23,
+                                    "kind": "Identifier",
+                                    "pos": 17,
+                                    "text": "People"
+                                },
+                                "pos": 8,
+                                "tagName": {
+                                    "end": 16,
+                                    "kind": "Identifier",
+                                    "pos": 9,
+                                    "text": "typedef"
+                                }
+                            },
+                            "end": 97,
+                            "length": 1,
+                            "pos": 8
+                        }
+                    };
+                    parsesCorrectly(reIndentJSDocComment(content), expected);
+                });
            });
        });
    });
@@ -1,6 +1,5 @@
-/// <reference path="..\..\..\src\harness\external\mocha.d.ts" />
-/// <reference path="..\..\..\src\harness\harness.ts" />
-/// <reference path="..\..\..\src\harness\virtualFileSystem.ts" />
+/// <reference path="..\harness.ts" />
+/// <reference path="..\virtualFileSystem.ts" />

 namespace ts {
    const caseInsensitiveBasePath = "c:/dev/";
@@ -1,11 +1,4 @@
-/// <reference path="..\..\..\src\harness\external\mocha.d.ts" />
-/// <reference path='..\..\..\src\harness\harness.ts' />
-
-declare namespace chai.assert {
-    /* tslint:disable no-unused-variable */
-    function deepEqual(actual: any, expected: any): void;
-    /* tslint:enable no-unused-variable */
-}
+/// <reference path="..\harness.ts" />

 namespace ts {
    function diagnosticToString(diagnostic: Diagnostic) {
@@ -1,6 +1,5 @@
-/// <reference path="..\..\..\src\harness\external\mocha.d.ts" />
-/// <reference path='..\..\..\src\harness\harness.ts' />
-/// <reference path="..\..\..\src\harness\harnessLanguageService.ts" />
+/// <reference path="..\harness.ts" />
+/// <reference path="..\..\harness\harnessLanguageService.ts" />

 namespace ts {

@@ -1,5 +1,4 @@
-/// <reference path="..\..\..\..\src\harness\external\mocha.d.ts" />
-/// <reference path="..\..\..\..\src\harness\harnessLanguageService.ts" />
+/// <reference path="..\..\harnessLanguageService.ts" />

 interface ClassificationEntry {
    value: any;
@@ -1,4 +1,4 @@
-///<reference path='..\..\..\..\src\harness\harness.ts' />
+/// <reference path="..\..\harness.ts" />

 describe("DocumentRegistry", () => {
    it("documents are shared between projects", () => {