Merge branch 'master' into nodeFactory

# Conflicts:
#	src/compiler/checker.ts
#	src/compiler/emitter.ts
#	src/compiler/factory.ts
#	src/compiler/factoryPublic.ts
#	src/compiler/parser.ts
#	src/compiler/transformers/module/esnextAnd2015.ts
#	src/compiler/transformers/module/module.ts
#	src/compiler/transformers/ts.ts
#	src/compiler/types.ts
#	src/compiler/visitorPublic.ts
#	src/services/refactors/extractSymbol.ts
#	src/services/refactors/generateGetAccessorAndSetAccessor.ts
#	src/services/signatureHelp.ts
#	src/testRunner/unittests/printer.ts
#	tests/baselines/reference/api/tsserverlibrary.d.ts
#	tests/baselines/reference/api/typescript.d.ts

package.json

@@ -96,7 +96,7 @@
         "source-map-support": "latest",
         "through2": "latest",
         "travis-fold": "latest",
-        "typescript": "next",
+        "typescript": "^3.9.3",
         "vinyl": "latest",
         "vinyl-sourcemaps-apply": "latest",
         "xml2js": "^0.4.19"

src/compiler/binder.ts

@@ -950,7 +950,7 @@ namespace ts {
             return initFlowNode({ flags: FlowFlags.SwitchClause, antecedent, switchStatement, clauseStart, clauseEnd });
         }
 
-        function createFlowMutation(flags: FlowFlags, antecedent: FlowNode, node: Node): FlowNode {
+        function createFlowMutation(flags: FlowFlags, antecedent: FlowNode, node: Expression | VariableDeclaration | ArrayBindingElement): FlowNode {
             setFlowNodeReferenced(antecedent);
             const result = initFlowNode({ flags, antecedent, node });
             if (currentExceptionTarget) {
@@ -1302,7 +1302,7 @@ namespace ts {
             // is potentially an assertion and is therefore included in the control flow.
             if (node.expression.kind === SyntaxKind.CallExpression) {
                 const call = <CallExpression>node.expression;
-                if (isDottedName(call.expression)) {
+                if (isDottedName(call.expression) && call.expression.kind !== SyntaxKind.SuperKeyword) {
                     currentFlow = createFlowCall(currentFlow, call);
                 }
             }
@@ -1680,6 +1680,9 @@ namespace ts {
                 }
                 else {
                     bindEachChild(node);
+                    if (node.expression.kind === SyntaxKind.SuperKeyword) {
+                        currentFlow = createFlowCall(currentFlow, node);
+                    }
                 }
             }
             if (node.expression.kind === SyntaxKind.PropertyAccessExpression) {
@@ -2397,6 +2400,9 @@ namespace ts {
                         node.flowNode = currentFlow;
                     }
                     return checkStrictModeIdentifier(<Identifier>node);
+                case SyntaxKind.SuperKeyword:
+                    node.flowNode = currentFlow;
+                    break;
                 case SyntaxKind.PrivateIdentifier:
                     return checkPrivateIdentifier(node as PrivateIdentifier);
                 case SyntaxKind.PropertyAccessExpression:

src/compiler/builder.ts

@@ -148,7 +148,7 @@ namespace ts {
         /**
          * true if build info is emitted
          */
-        emittedBuildInfo?: boolean;
+        buildInfoEmitPending: boolean;
         /**
          * Already seen emitted files
          */
@@ -173,7 +173,7 @@ namespace ts {
         const compilerOptions = newProgram.getCompilerOptions();
         state.compilerOptions = compilerOptions;
         // With --out or --outFile, any change affects all semantic diagnostics so no need to cache them
-        if (!compilerOptions.outFile && !compilerOptions.out) {
+        if (!outFile(compilerOptions)) {
             state.semanticDiagnosticsPerFile = createMap<readonly Diagnostic[]>();
         }
         state.changedFilesSet = createMap<true>();
@@ -197,7 +197,7 @@ namespace ts {
             if (changedFilesSet) {
                 copyEntries(changedFilesSet, state.changedFilesSet);
             }
-            if (!compilerOptions.outFile && !compilerOptions.out && oldState!.affectedFilesPendingEmit) {
+            if (!outFile(compilerOptions) && oldState!.affectedFilesPendingEmit) {
                 state.affectedFilesPendingEmit = oldState!.affectedFilesPendingEmit.slice();
                 state.affectedFilesPendingEmitKind = cloneMapOrUndefined(oldState!.affectedFilesPendingEmitKind);
                 state.affectedFilesPendingEmitIndex = oldState!.affectedFilesPendingEmitIndex;
@@ -250,14 +250,14 @@ namespace ts {
             BuilderState.getAllFilesExcludingDefaultLibraryFile(state, newProgram, /*firstSourceFile*/ undefined)
                 .forEach(file => state.changedFilesSet.set(file.resolvedPath, true));
         }
-        else if (oldCompilerOptions && compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions)) {
+        else if (oldCompilerOptions && !outFile(compilerOptions) && compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions)) {
             // Add all files to affectedFilesPendingEmit since emit changed
             newProgram.getSourceFiles().forEach(f => addToAffectedFilesPendingEmit(state, f.resolvedPath, BuilderFileEmit.Full));
             Debug.assert(!state.seenAffectedFiles || !state.seenAffectedFiles.size);
             state.seenAffectedFiles = state.seenAffectedFiles || createMap<true>();
         }
 
-        state.emittedBuildInfo = !state.changedFilesSet.size && !state.affectedFilesPendingEmit;
+        state.buildInfoEmitPending = !!state.changedFilesSet.size;
         return state;
     }
 
@@ -374,7 +374,7 @@ namespace ts {
             // so operations are performed directly on program, return program
             const program = Debug.checkDefined(state.program);
             const compilerOptions = program.getCompilerOptions();
-            if (compilerOptions.outFile || compilerOptions.out) {
+            if (outFile(compilerOptions)) {
                 Debug.assert(!state.semanticDiagnosticsPerFile);
                 return program;
             }
@@ -611,7 +611,7 @@ namespace ts {
         isBuildInfoEmit?: boolean
     ) {
         if (isBuildInfoEmit) {
-            state.emittedBuildInfo = true;
+            state.buildInfoEmitPending = false;
         }
         else if (affected === state.program) {
             state.changedFilesSet.clear();
@@ -624,6 +624,7 @@ namespace ts {
             }
             if (isPendingEmit) {
                 state.affectedFilesPendingEmitIndex!++;
+                state.buildInfoEmitPending = true;
             }
             else {
                 state.affectedFilesIndex!++;
@@ -688,19 +689,21 @@ namespace ts {
     }
 
     export type ProgramBuildInfoDiagnostic = string | [string, readonly ReusableDiagnostic[]];
+    export type ProgramBuilderInfoFilePendingEmit = [string, BuilderFileEmit];
     export interface ProgramBuildInfo {
         fileInfos: MapLike<BuilderState.FileInfo>;
         options: CompilerOptions;
         referencedMap?: MapLike<string[]>;
         exportedModulesMap?: MapLike<string[]>;
         semanticDiagnosticsPerFile?: ProgramBuildInfoDiagnostic[];
+        affectedFilesPendingEmit?: ProgramBuilderInfoFilePendingEmit[];
     }
 
     /**
      * Gets the program information to be emitted in buildInfo so that we can use it to create new program
      */
     function getProgramBuildInfo(state: Readonly<ReusableBuilderProgramState>, getCanonicalFileName: GetCanonicalFileName): ProgramBuildInfo | undefined {
-        if (state.compilerOptions.outFile || state.compilerOptions.out) return undefined;
+        if (outFile(state.compilerOptions)) return undefined;
         const currentDirectory = Debug.checkDefined(state.program).getCurrentDirectory();
         const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(state.compilerOptions)!, currentDirectory));
         const fileInfos: MapLike<BuilderState.FileInfo> = {};
@@ -751,6 +754,17 @@ namespace ts {
             result.semanticDiagnosticsPerFile = semanticDiagnosticsPerFile;
         }
 
+        if (state.affectedFilesPendingEmit) {
+            const affectedFilesPendingEmit: ProgramBuilderInfoFilePendingEmit[] = [];
+            const seenFiles = createMap<true>();
+            for (const path of state.affectedFilesPendingEmit.slice(state.affectedFilesPendingEmitIndex).sort(compareStringsCaseSensitive)) {
+                if (addToSeen(seenFiles, path)) {
+                    affectedFilesPendingEmit.push([relativeToBuildInfo(path), state.affectedFilesPendingEmitKind!.get(path)!]);
+                }
+            }
+            result.affectedFilesPendingEmit = affectedFilesPendingEmit;
+        }
+
         return result;
 
         function relativeToBuildInfoEnsuringAbsolutePath(path: string) {
@@ -916,13 +930,23 @@ namespace ts {
         else if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) {
             (builderProgram as EmitAndSemanticDiagnosticsBuilderProgram).getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile;
             (builderProgram as EmitAndSemanticDiagnosticsBuilderProgram).emitNextAffectedFile = emitNextAffectedFile;
+            builderProgram.emitBuildInfo = emitBuildInfo;
         }
         else {
             notImplemented();
         }
 
         return builderProgram;
 
+        function emitBuildInfo(writeFile?: WriteFileCallback, cancellationToken?: CancellationToken): EmitResult {
+            if (state.buildInfoEmitPending) {
+                const result = Debug.checkDefined(state.program).emitBuildInfo(writeFile || maybeBind(host, host.writeFile), cancellationToken);
+                state.buildInfoEmitPending = false;
+                return result;
+            }
+            return emitSkippedWithNoDiagnostics;
+        }
+
         /**
          * Emits the next affected file's emit result (EmitResult and sourceFiles emitted) or returns undefined if iteration is complete
          * The first of writeFile if provided, writeFile of BuilderProgramHost if provided, writeFile of compiler host
@@ -933,10 +957,10 @@ namespace ts {
             let emitKind = BuilderFileEmit.Full;
             let isPendingEmitFile = false;
             if (!affected) {
-                if (!state.compilerOptions.out && !state.compilerOptions.outFile) {
+                if (!outFile(state.compilerOptions)) {
                     const pendingAffectedFile = getNextAffectedFilePendingEmit(state);
                     if (!pendingAffectedFile) {
-                        if (state.emittedBuildInfo) {
+                        if (!state.buildInfoEmitPending) {
                             return undefined;
                         }
 
@@ -993,7 +1017,7 @@ namespace ts {
         function emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult {
             if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) {
                 assertSourceFileOkWithoutNextAffectedCall(state, targetSourceFile);
-                const result = handleNoEmitOptions(builderProgram, targetSourceFile, cancellationToken);
+                const result = handleNoEmitOptions(builderProgram, targetSourceFile, writeFile, cancellationToken);
                 if (result) return result;
                 if (!targetSourceFile) {
                     // Emit and report any errors we ran into.
@@ -1071,7 +1095,7 @@ namespace ts {
         function getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[] {
             assertSourceFileOkWithoutNextAffectedCall(state, sourceFile);
             const compilerOptions = Debug.checkDefined(state.program).getCompilerOptions();
-            if (compilerOptions.outFile || compilerOptions.out) {
+            if (outFile(compilerOptions)) {
                 Debug.assert(!state.semanticDiagnosticsPerFile);
                 // We dont need to cache the diagnostics just return them from program
                 return Debug.checkDefined(state.program).getSemanticDiagnostics(sourceFile, cancellationToken);
@@ -1142,7 +1166,10 @@ namespace ts {
             referencedMap: getMapOfReferencedSet(program.referencedMap, toPath),
             exportedModulesMap: getMapOfReferencedSet(program.exportedModulesMap, toPath),
             semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && arrayToMap(program.semanticDiagnosticsPerFile, value => toPath(isString(value) ? value : value[0]), value => isString(value) ? emptyArray : value[1]),
-            hasReusableDiagnostic: true
+            hasReusableDiagnostic: true,
+            affectedFilesPendingEmit: map(program.affectedFilesPendingEmit, value => toPath(value[0])),
+            affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && arrayToMap(program.affectedFilesPendingEmit, value => toPath(value[0]), value => value[1]),
+            affectedFilesPendingEmitIndex: program.affectedFilesPendingEmit && 0,
         };
         return {
             getState: () => state,
@@ -1165,6 +1192,7 @@ namespace ts {
             getCurrentDirectory: notImplemented,
             emitNextAffectedFile: notImplemented,
             getSemanticDiagnosticsOfNextAffectedFile: notImplemented,
+            emitBuildInfo: notImplemented,
             close: noop,
         };
 
@@ -1195,6 +1223,7 @@ namespace ts {
             getDeclarationDiagnostics: (sourceFile, cancellationToken) => getProgram().getDeclarationDiagnostics(sourceFile, cancellationToken),
             getSemanticDiagnostics: (sourceFile, cancellationToken) => getProgram().getSemanticDiagnostics(sourceFile, cancellationToken),
             emit: (sourceFile, writeFile, cancellationToken, emitOnlyDts, customTransformers) => getProgram().emit(sourceFile, writeFile, cancellationToken, emitOnlyDts, customTransformers),
+            emitBuildInfo: (writeFile, cancellationToken) => getProgram().emitBuildInfo(writeFile, cancellationToken),
             getAllDependencies: notImplemented,
             getCurrentDirectory: () => getProgram().getCurrentDirectory(),
             close: noop,

src/compiler/builderPublic.ts

@@ -99,6 +99,8 @@ namespace ts {
          * in that order would be used to write the files
          */
         emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult;
+        /*@internal*/
+        emitBuildInfo(writeFile?: WriteFileCallback, cancellationToken?: CancellationToken): EmitResult;
         /**
          * Get the current directory of the program
          */

src/compiler/builderState.ts

@@ -403,7 +403,7 @@ namespace ts {
         export function getAllDependencies(state: BuilderState, programOfThisState: Program, sourceFile: SourceFile): readonly string[] {
             const compilerOptions = programOfThisState.getCompilerOptions();
             // With --out or --outFile all outputs go into single file, all files depend on each other
-            if (compilerOptions.outFile || compilerOptions.out) {
+            if (outFile(compilerOptions)) {
                 return getAllFileNames(state, programOfThisState);
             }
 
@@ -519,7 +519,7 @@ namespace ts {
             const compilerOptions = programOfThisState.getCompilerOptions();
             // If `--out` or `--outFile` is specified, any new emit will result in re-emitting the entire project,
             // so returning the file itself is good enough.
-            if (compilerOptions && (compilerOptions.out || compilerOptions.outFile)) {
+            if (compilerOptions && outFile(compilerOptions)) {
                 return [sourceFileWithUpdatedShape];
             }
             return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
@@ -534,7 +534,7 @@ namespace ts {
             }
 
             const compilerOptions = programOfThisState.getCompilerOptions();
-            if (compilerOptions && (compilerOptions.isolatedModules || compilerOptions.out || compilerOptions.outFile)) {
+            if (compilerOptions && (compilerOptions.isolatedModules || outFile(compilerOptions))) {
                 return [sourceFileWithUpdatedShape];
             }