Project References Core Support by RyanCavanaugh · Pull Request #22420 · microsoft/TypeScript

RyanCavanaugh · 2018-03-08T23:57:57Z

Fixes most of #3469

There are two separable but intertwined concepts present in this PR: Project references, and composite projects.

A project reference is an entry in a tsconfig file that points to another tsconfig file:

/* tsconfig.json */
{
   // ...
       "projectReferences": [
           /* Looks for ../other/dir/tsconfig.json */
           /* Could also be a filename rather than directory */
           { "path": "../other/dir" }
       ]
}

A project reference in a tsconfig file performs a redirection when resolving module names. Writing writing:

   import expr from "../other/dir/mod"

If a project reference subsumes ../other or ../other/dir, instead of looking for mod.ts/mod.tsx files in ../other/dir, we look for .d.ts files in the outDir of the referenced project.

In this PR, project references may not be circular.

Project references may include prepend: true in outFile compilations. The output of a prepend: true is prepended to the output of the outFile of the current project. Additionally, we write a .bundle_info file indicating where "this" project's JS starts so that tools (see tsbuild below) can re-use the downstream project JS if the upstream project JS changes without modifying its .d.ts content.

In order to be referenced, a tsconfig file must be a composite project. This is done by setting "composite": true (including possibly in a base tsconfig file). Composite projects are subject to additional constraints:

rootDir is inferred differently if not specified
The list of compiled files must be calculable without parsing any actual source files
Declaration emit must be enabled
outFile and module compilation may not be mixed

These rules define an additional property of composite projects: They can be trivially determined to be up-to-date or not, because the set of input files and output files can be determined without reading any source files from disk.

tsbuild leverages these properties to enable extremely fast rebuilds of large solutions. The projectReferencesDogfood branch demonstrates what this looks like for an outFile compilation.

DanielRosenwasser · 2018-03-14T18:54:24Z

As discussed offline, we need to handle scenarios with two tsconfig.jsons that model projects with side-by-side .spec.ts or .test.ts files.

mhegazy · 2018-04-05T22:47:43Z

src/compiler/commandLineParser.ts

            category: Diagnostics.Module_Resolution_Options,
            description: Diagnostics.Type_declaration_files_to_be_included_in_compilation
        },
+        {


i think this should be one level higher. it is similar to includes, excludes and files more than a compiler option.

Additionally, having a references list implies composite, right? Can we combine the two, eg composite: [ /**/ ] for stuff with dependencies but composite: true or composite: [] for leaf nodes?

Edit from @RyanCavanaugh as I can't reply to this (???) - recycling bits:

References does not imply composite. Leaf-node projects may choose to have references without being composite (for example, it makes no sense to be forced to emit tsc.d.ts, but tsc's tsconfig reasonably has references to checker, etc.).

one other reason why this should not be here is do not think we want tsc --references a\tsconfig.json to work... or is that a scenario we should support?

👍 for moving this up a level.

References does not imply composite. Leaf-node projects may choose to have references without being composite (for example, it makes no sense to be forced to emit tsc.d.ts, but tsc's tsconfig reasonably has references to checker, etc.).

Definitely no references on the commandline.

mhegazy · 2018-04-05T22:48:22Z

src/compiler/commandLineParser.ts

                        type: "string"
                    }
                },
+                {


so we have this in both places?

Removed option from compilerOptions

mhegazy · 2018-04-05T23:04:52Z

src/compiler/program.ts

                    context += resetEscapeSequence;
                }

-                output += formatColorAndReset(relativeFileName, ForegroundColorEscapeSequences.Cyan);


so why did we change these?

I'm guessing merge error or some kind?

mhegazy · 2018-04-05T23:07:48Z

src/compiler/program.ts

        Debug.assert(!!missingFilePaths);

+        // List of collected files is complete; validate exhautiveness if this is a project with a file list
+        if (options.composite && rootNames.length < files.length) {


we have done most of these project validation type checks in verifyCompilerOptions

mhegazy · 2018-04-05T23:11:59Z

src/compiler/program.ts

+                    // Project compilations never infer their root from the input source paths
+                    commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir || getDirectoryPath(normalizeSlashes(options.configFilePath)), currentDirectory);
+                }
+                else if (options.rootDir && checkSourceFilesBelongToPath(emittedFiles, options.rootDir)) {


so what happenes if we set it if rootDir is set? we will report the error later on any ways..

the reason i ask, is it will make more sense to write it as:

if (options.rootDir) { commonSourceDirectory = getNormalizedAbsolutePath(options.rootDir, currentDirectory); } else if (options.composite) { commonSourceDirectory = getDirectoryPath(normalizeSlashes(options.configFilePath) } else { commonSourceDirectory = computeCommonSourceDirectory(emittedFiles); }

Changed to something similar

mhegazy · 2018-04-05T23:13:49Z

src/compiler/program.ts

            if (commonSourceDirectory === undefined) {
                const emittedFiles = filter(files, file => sourceFileMayBeEmitted(file, options, isSourceFileFromExternalLibrary));
-                if (options.rootDir && checkSourceFilesBelongToPath(emittedFiles, options.rootDir)) {
+                if (options.composite) {


should we check that we have a configFilePath? since if you have niether, normalizeSlashes will get undefined.

Added an assert

mhegazy · 2018-04-05T23:14:55Z

src/compiler/program.ts

            };
        }

+        function getPrependNodes(): PrependNode[] {


ReadonlyArray<PrependNode>?

mhegazy · 2018-04-05T23:17:15Z

src/compiler/program.ts

+            walkProjectReferenceGraph(host, options, (_file, proj, opts) => {
+                if (opts.prepend) {
+                    const dtsFilename = changeExtension(proj.outFile, ".d.ts");
+                    const js = host.readFile(proj.outFile) || `/* Input file ${proj.outFile} was missing */\r\n`;


if the file does not exist, should we error?

Added an error upstream

mhegazy · 2018-04-05T23:20:26Z

src/compiler/program.ts

                createDiagnosticForOptionName(Diagnostics.Option_paths_cannot_be_used_without_specifying_baseUrl_option, "paths");
            }

+            if (options.composite) {


it should be an error not to have --rootDir or a config file with composite as well. right?

composite is config only, so it's not an error to not have rootDir - composite just changes how it behaves

mhegazy · 2018-04-05T23:35:07Z

src/compiler/program.ts

+    export function walkProjectReferenceGraph(host: CompilerHost, rootOptions: CompilerOptions,
+        callback: (resolvedFile: string, referencedProject: CompilerOptions, settings: ProjectReference) => void,
+        errorCallback?: (failedLocation: string) => void) {
+        if (rootOptions.references === undefined) return;


we already check this in getProjectReferenceFileNames, no need to redo it.

mhegazy · 2018-04-05T23:41:08Z

src/compiler/program.ts

+        errorCallback?: (failedLocation: string) => void) {
+        if (rootOptions.references === undefined) return;
+
+        const references = getProjectReferenceFileNames(host, rootOptions);


we are going to call resolveProjectReferencePath on every entry a few lines after this, why do we need this pre pass?

mhegazy · 2018-04-05T23:44:37Z

src/compiler/program.ts

+            }
+            const referenceJsonSource = parseJsonText(refPath, text);
+            const cmdLine = parseJsonSourceFileConfigFileContent(referenceJsonSource, configHost, getDirectoryPath(refPath), /*existingOptions*/ undefined, refPath);
+            cmdLine.options.configFilePath = refPath;


so why not pass the filepath to parseJsonSourceFileConfigFileContent instead?

mhegazy · 2018-04-05T23:46:19Z

src/compiler/program.ts

+        };
+    }
+
+    export function getProjectReferenceFileNames(host: CompilerHost, rootOptions: CompilerOptions): string[] | undefined {


do we even need this function? why not just expose walkProjectReferenceGraph, seems more efficient for most scenarios, and can decide what to do on missing references.

mhegazy · 2018-04-06T00:02:32Z

src/compiler/program.ts

+        return refPath;
+    }
+
+    export function walkProjectReferenceGraph(host: CompilerHost, rootOptions: CompilerOptions,


for consistency with similar routines in the code base i would call this forEachReference or forEachProjectReference

mhegazy · 2018-04-06T00:08:18Z

src/compiler/program.ts

+                // Note: We don't enumerate the input files to try to find corresponding .d.ts
+                // files because we can't know from the outside whether they're modules or not
+                if (referencedProject.outFile) {
+                    const outFile = combinePaths(referencedProject.outDir, changeExtension(referencedProject.outFile, ".d.ts"));


the outFile is not relative to the outDir. it is relative to the tsconfig.json file.. maybe i do not understand the rational here.

it can also depend on declarationDir.

weswigham

Mostly looks like it needs to handle declarationDir all over (probably needs tests for that, too) - the rest is mostly just suggestions for improvements/opinions.

weswigham · 2018-04-05T23:25:09Z

src/compiler/commandLineParser.ts

            category: Diagnostics.Module_Resolution_Options,
            description: Diagnostics.Type_declaration_files_to_be_included_in_compilation
        },
+        {


Additionally, having a references list implies composite, right? Can we combine the two, eg composite: [ /**/ ] for stuff with dependencies but composite: true or composite: [] for leaf nodes?

Edit from @RyanCavanaugh as I can't reply to this (???) - recycling bits:

References does not imply composite. Leaf-node projects may choose to have references without being composite (for example, it makes no sense to be forced to emit tsc.d.ts, but tsc's tsconfig reasonably has references to checker, etc.).

weswigham · 2018-04-05T23:39:10Z

src/compiler/declarationEmitter.ts

@@ -0,0 +1,2058 @@
+/// <reference path="checker.ts"/>


This file shouldn't be here.

weswigham · 2018-04-05T23:40:27Z

src/compiler/diagnosticMessages.json

+        "category": "Message",
+        "code": 6300
+    },
+    "Referenced project '{0}' must have 'declaration': true": {


Or itself be composite (which implies this)? Should be mentioned in the error.

Removed this since it's vestigial from before we put everything under composite

weswigham · 2018-04-05T23:41:40Z

src/compiler/diagnosticMessages.json

+        "category": "Error",
+        "code": 6202
+    },
+    "Projects may not disable declaration emit.": {


Ehhhhhhh...... I'd rather we just silently ate the declaration: false in this case and output the declarations into a temp folder, so the user never sees them (so as far as they're concerned, it is off).

We'd have to figure out what that would look like. tsc doesn't have an arbitrary other-place to drop things to. e.g. What happens if you have 2 checkouts of the same repo and do that - how do we tell them apart? Mirror the entire path from the root into your temp folder? Unlikely to work in Windows, at least, given path length limitations

A dotfolder in the root of the compilation output, just like the bundle info?

weswigham · 2018-04-05T23:47:32Z

src/compiler/emitter.ts

            const declarationFilePath = (forceDtsPaths || options.declaration) ? removeFileExtension(jsFilePath) + Extension.Dts : undefined;
            const declarationMapPath = getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined;
-            return { jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath };
+            const bundleInfoPath = options.references && jsFilePath && (removeFileExtension(jsFilePath) + ".bundle_info");


Style: .tsbundle or maybe .tsbundledata instead of .bundle_info - because 1. I don't think people will know where a .bundle_info came from (and may delete it), and 2. I dislike underscore in extensions.

Actually - it might make sense to output into a .tscache folder adjacent to the output (and then the file can be named whatever), so the folder can be easily blanket-gitignored.

Changed to .tsbundleinfo

weswigham · 2018-04-05T23:52:43Z

src/compiler/program.ts

                    context += resetEscapeSequence;
                }

-                output += formatColorAndReset(relativeFileName, ForegroundColorEscapeSequences.Cyan);


I'm guessing merge error or some kind?

weswigham · 2018-04-05T23:55:28Z

src/compiler/program.ts

+                    return undefined;
+                }
+                if (normalized.indexOf(k) === 0) {
+                    result = changeExtension(fileName.replace(k, v), ".d.ts");


This seems ignorant of the target project's declarationDir setting - that seems important.

weswigham · 2018-04-06T00:00:29Z

src/compiler/program.ts

+            const nodes: PrependNode[] = [];
+            walkProjectReferenceGraph(host, options, (_file, proj, opts) => {
+                if (opts.prepend) {
+                    const dtsFilename = changeExtension(proj.outFile, ".d.ts");


This needs to account for declarationDir, and/or outDir, right?

outFile and declarationDir cannot be combined; ref #12405

outFile with outDir - doesn't matter; the output .d.ts file is dropped next to the output .js file

Need an error for a prepended reference that doesn't use outFile, though

weswigham · 2018-04-06T00:01:24Z

src/compiler/program.ts

+
+            function createMapping(resolvedFile: string, referencedProject: CompilerOptions, reference: ProjectReference) {
+                const rootDir = normalizePath(referencedProject.rootDir || getDirectoryPath(resolvedFile));
+                result.set(rootDir, referencedProject.outDir);


Also declarationDir.

weswigham · 2018-04-06T00:11:48Z

src/compiler/program.ts

        Debug.assert(!!missingFilePaths);

+        // List of collected files is complete; validate exhautiveness if this is a project with a file list
+        if (options.composite && rootNames.length < files.length) {


You might be able to relax/remove this check by using preProcessFile (from preProcess.ts) from the services layer on the importing side to get the files a given file depends on (recursively) without doing a full parse (just a scan), for the most part. Still definitely a good practice to explicitly list all your files, but that could reduce friction in adopting the composite flag.

When I did the dogfooding conversion, I just used --listFiles to fix the files list manually - seemed to be good enough.

Any projects that depend on node modules for declarations and/or have a few hundred files I would think may not enjoy managing a list themselves - especially as the exact files in their modules shift under then.

.d.ts files are not subject to this restriction

If you have a few hundred files, then your tsconfig would almost certainly be globbing. I'd look askance at anyone not globbing in that situation - detecting an orphaned .ts file that didn't get imported by anyone would be a big pit of failure.

mhegazy · 2018-04-06T00:25:10Z

src/compiler/program.ts

+
+            function createMapping(resolvedFile: string, referencedProject: CompilerOptions, reference: ProjectReference) {
+                const rootDir = normalizePath(referencedProject.rootDir || getDirectoryPath(resolvedFile));
+                result.set(rootDir, referencedProject.outDir);


outDir can be empty. do we want to add a mapping to undefined?

mhegazy · 2018-04-06T00:28:01Z

src/compiler/program.ts

+                    return undefined;
+                }
+                if (normalized.indexOf(k) === 0) {
+                    result = changeExtension(fileName.replace(k, v), ".d.ts");


we do have a function to get the declaration file path, can we use that instead?

getDeclarationEmitOutputFilePath is what i was referring to.

That function accepts a SourceFile, which we definitely don't have

But it would be easy to modify since only sourceFile.fileName is used in there anyways.

mhegazy · 2018-04-06T00:30:40Z

src/compiler/program.ts


+        const referencedProjectOutFiles: Path[] = [];
+        const projectReferenceRedirects = createProjectReferenceRedirects(options);
+        checkProjectReferenceGraph();


can we do this in verifyCompilerOptions instead.

RyanCavanaugh · 2018-04-06T21:50:54Z

src/compiler/commandLineParser.ts

+                    }
+                },
+                {
+                    name: "projects",


RyanCavanaugh

Wrong button

RyanCavanaugh · 2018-04-06T23:06:30Z

src/compiler/program.ts

            };
        }

+        function getPrependNodes(): PrependNode[] {


RyanCavanaugh · 2018-05-01T21:12:57Z

@weswigham @mhegazy I believe I've addressed all the comments (as well as offline discussion) - please have a 👀

weswigham

Some quick fixes to maybe look at/style comments, but otherwise looks OK.

weswigham · 2018-05-03T00:02:40Z

src/compiler/program.ts


+            if (options.composite) {
+                if (options.declaration === false) {
+                    createDiagnosticForOptionName(Diagnostics.Projects_may_not_disable_declaration_emit, "declaration");


Projects -> Composite projects?

weswigham · 2018-05-03T00:04:27Z

src/compiler/program.ts


+    function parseConfigHostFromCompilerHost(host: CompilerHost): ParseConfigFileHost {
+        return {
+            fileExists: host.fileExists,


fileExists(f): f => host.fileExists(f)

in case the host uses this.

weswigham · 2018-05-03T00:04:44Z

src/compiler/program.ts

+        return {
+            fileExists: host.fileExists,
+            readDirectory: () => [],
+            readFile: host.readFile,


Should be an arrow in case the host uses this.

weswigham · 2018-05-03T00:04:50Z

src/compiler/program.ts

+            readDirectory: () => [],
+            readFile: host.readFile,
+            useCaseSensitiveFileNames: host.useCaseSensitiveFileNames(),
+            getCurrentDirectory: host.getCurrentDirectory,


Should be an arrow in case the host uses this.

✔️ for all

weswigham · 2018-05-03T00:06:30Z

src/compiler/transformers/utilities.ts

+        }
+
+        function transformBundle(node: Bundle) {
+            return createBundle(node.sourceFiles.map(transformSourceFile), node.prepends);


Maybe map(node.sourceFiles, transformSourceFile) instead of node.sourceFiles.map(transformSourceFile) in case someone decides to do something crazy like an emit with only unparsed sources.

weswigham · 2018-05-03T00:08:12Z

src/compiler/types.ts

        ES2017 = 4,
        ES2018 = 5,
        ESNext = 6,
+        JSON = 100,


Interesting choice of number.

Seemed like we should keep the ES versions adjacent 🤷‍♂️

weswigham · 2018-05-03T00:10:21Z

src/compiler/parser.ts

        performance.mark("beforeParse");
-        const result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes, scriptKind);
+        let result: SourceFile;
+        if (languageVersion === ScriptTarget.JSON) {


There's already a ScriptKind.JSON, and there's already a scriptKind parameter - maybe this should just use that?

The relevant incoming call stack here is via host.getSourceFile, which only accepts ScriptTarget rather than ScriptKind

I think you want to handle it like in https://github.com/Microsoft/TypeScript/pull/22167/files#diff-ead24f0f0f59c0ea9c1c511052e8884bL671

@sheetalkamat that seems like the wrong place. Parser exposes parseSourceFile and parseJsonText separately, if someone wants to get back a JSON file they can call parseJsonText instead instead of having parseSourceFile reroute it

weswigham · 2018-05-03T00:19:10Z

src/server/session.ts

@@ -699,12 +699,14 @@ namespace ts.server {
        }

        private toFileSpan(fileName: string, textSpan: TextSpan, project: Project): protocol.FileSpan {


Are there other bits relying on script infos for line mapping that also need to be swapped?

rbuckton · 2018-05-03T00:24:21Z

@RyanCavanaugh I still owe you feedback on this. I should be able to submit comments by tomorrow.

sheetalkamat · 2018-05-03T21:52:43Z

src/compiler/commandLineParser.ts


        const literalFiles = arrayFrom(literalFileMap.values());
        const wildcardFiles = arrayFrom(wildcardFileMap.values());
+        const projectReferences = spec.referencesSpecs && spec.referencesSpecs.map((r): ProjectReference => {


Why do you need this here? This would get updated only when there is update to tsconfig.json. So you shouldnt want this in here?

I don't understand the comment - can you expand on that?

sheetalkamat · 2018-05-03T21:53:59Z

src/compiler/commandLineParser.ts

+                    for (const ref of raw.references) {
+                        if (typeof ref.path !== "string") {
+                            createCompilerDiagnosticOnlyIfJson(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "reference.path", "string");
+                        }


this wont show up error at all in JSON file (with new api) do you have test case to verify this.

I wasn't sure how to test this. This call seems to match all the others in the file - what is the new API / what would cause this to not show up?

sheetalkamat · 2018-05-04T18:24:19Z

src/compiler/program.ts

            }

+            // Check if any referenced project tsconfig files are different
+            if (createProgramOptions.projectReferences) {


just projectReferences instead ?

sheetalkamat · 2018-05-04T18:25:14Z

src/compiler/program.ts


+            // Check if any referenced project tsconfig files are different
+            if (createProgramOptions.projectReferences) {
+                for (let i = 0; i < createProgramOptions.projectReferences.length; i++) {


Need a check when !projectReferences and oldProgram.projectReferences ?

sheetalkamat · 2018-05-04T18:28:20Z

src/compiler/program.ts

+            // Check if any referenced project tsconfig files are different
+            if (createProgramOptions.projectReferences) {
+                for (let i = 0; i < createProgramOptions.projectReferences.length; i++) {
+                    const oldRef = resolvedProjectReferences[i];


How is resolvedProjectReferences[i] is an oldRef?

Good catch - fixed

sheetalkamat · 2018-05-04T18:34:56Z

src/compiler/program.ts

+            const refPath = resolveProjectReferencePath(host, ref);
+            // An absolute path pointing to the containing directory of the config file
+            const basePath = getNormalizedAbsolutePath(getDirectoryPath(refPath), host.getCurrentDirectory());
+            const sourceFile = host.getSourceFile(refPath, ScriptTarget.JSON) as JsonSourceFile;


Why not use: getParsedCommandLineOfConfigFile instead ?

Feedback from Mohamed was that we want to pass around SourceFiles instead of filenames so that in-memory editing of referenced projects would work

sheetalkamat · 2018-05-04T18:38:10Z

src/compiler/tsc.ts

@@ -120,7 +120,7 @@ namespace ts {
                createWatchOfConfigFile(configParseResult, commandLineOptions);


I am assuming you arent adding this portion in this PR. Can you add a TODO and create a issue tracking that. Thanks

rbuckton · 2018-05-03T23:41:05Z

src/compiler/core.ts

+    /**
+     * Normalizes a path including its leading drive letter (if any)
+     */
+    export function normalizePathAndRoot(path: string): string {


All of the places I can find that reference this immediately call toLowerCase() on the result. I would just replace those calls with calls to normalizePath (or resolvePath) instead.

rbuckton · 2018-05-03T23:51:28Z

src/compiler/emitter.ts

+
+            for (const prepend of bundle.prepends) {
+                print(EmitHint.Unspecified, prepend, /*sourceFile*/ undefined);
+                write("\n");


writeLine()

rbuckton · 2018-05-03T23:53:03Z

src/compiler/emitter.ts

                case EmitHint.MappedTypeParameter: return emitMappedTypeParameter(cast(node, isTypeParameterDeclaration));
                case EmitHint.Unspecified: return pipelineEmitUnspecified(node);
+                default:
+                    return Debug.assertNever(hint, `Unhandled EmitHint: ${(ts as any).EmitHint ? (ts as any).EmitHint[hint] : hint }`);


take a look at how formatSyntaxKind works in utilities.ts and possibly add a format function for this.

chriseppstein · 2018-05-07T22:02:25Z

🎉🎉

RyanCavanaugh added 2 commits March 29, 2018 13:33

Project References

dfbd4f3

Merge with master

f83ad4c

RyanCavanaugh force-pushed the projectReferencesPR branch from 97a93b1 to f83ad4c Compare March 29, 2018 22:42

mhegazy reviewed Apr 5, 2018

View reviewed changes

mhegazy reviewed Apr 6, 2018

View reviewed changes

weswigham requested changes Apr 6, 2018

View reviewed changes

mhegazy reviewed Apr 6, 2018

View reviewed changes

RyanCavanaugh commented Apr 6, 2018

View reviewed changes

src/compiler/commandLineParser.ts Outdated

}

},

{

name: "projects",

Copy link

Member Author

RyanCavanaugh Apr 6, 2018

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Removed

RyanCavanaugh added 5 commits April 6, 2018 15:31

Move 'references' up to the 'files' level

b0d49f9

baseline-accept

df8df9f

Remove bad file

4dfe4ee

Remove unuseful error

f237834

Prepend -> UnparsedSource; fix other emitter bugs; bundle_info -> ??

d9a354f

RyanCavanaugh commented Apr 6, 2018

View reviewed changes

src/compiler/program.ts Outdated

};

}

function getPrependNodes(): PrependNode[] {

Copy link

Member Author

RyanCavanaugh Apr 6, 2018

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

✔️

RyanCavanaugh added 7 commits April 30, 2018 13:51

Merge branch 'master' into projectReferencesPR

31da17b

Properly handle "simplified" results in most places

8bcea60

Write newlines between prepends; re-order helpers

c63de04

Chain through bundling logic in emitter

f79c496

Move newline

ad3d50e

Lint

431c02d

Move file check to verifyCompilerOptions

4bb2e5a

weswigham approved these changes May 3, 2018

View reviewed changes

RyanCavanaugh added 3 commits May 3, 2018 13:34

PR feedback

8e76544

Update test

3346659

Merge branch 'master' into projectReferencesPR

6b174af

sheetalkamat reviewed May 3, 2018

View reviewed changes

RyanCavanaugh added 3 commits May 3, 2018 15:26

Add readDirectory as optional to CompilerHost; update to vfsys

5c61fb3

lint

8fa80af

Merge branch 'master' into projectReferencesPR

103bd81

sheetalkamat reviewed May 4, 2018

View reviewed changes

rbuckton suggested changes May 4, 2018

View reviewed changes

RyanCavanaugh added 3 commits May 7, 2018 12:22

PR comments

dfbb6a2

Merge

521cff2

Merge branch 'master' into projectReferencesPR

784c924

RyanCavanaugh closed this May 7, 2018

microsoft locked and limited conversation to collaborators Jul 31, 2018

		@@ -699,12 +699,14 @@ namespace ts.server {
		}

		private toFileSpan(fileName: string, textSpan: TextSpan, project: Project): protocol.FileSpan {

		@@ -120,7 +120,7 @@ namespace ts {
		createWatchOfConfigFile(configParseResult, commandLineOptions);

Conversation

RyanCavanaugh commented Mar 8, 2018

Uh oh!

DanielRosenwasser commented Mar 14, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

weswigham Apr 5, 2018 • edited by RyanCavanaugh Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

mhegazy Apr 6, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

mhegazy Apr 5, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

mhegazy Apr 6, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

DanielRosenwasser commented Mar 14, 2018 •

edited

Loading

weswigham Apr 5, 2018 •

edited by RyanCavanaugh

Loading

mhegazy Apr 6, 2018 •

edited

Loading

mhegazy Apr 5, 2018 •

edited

Loading

mhegazy Apr 6, 2018 •

edited

Loading

weswigham Apr 5, 2018 •

edited by RyanCavanaugh

Loading