Enable --strictPropertyInitialization (microsoft#27558)

* Enable --strictPropertyInitialization

* Code review

Author: Andy

src/harness/client.ts

@@ -37,7 +37,7 @@ namespace ts.server {
         private sequence = 0;
         private lineMaps: Map<number[]> = createMap<number[]>();
         private messages: string[] = [];
-        private lastRenameEntry: RenameEntry;
+        private lastRenameEntry: RenameEntry | undefined;
 
         constructor(private host: SessionClientHost) {
         }
@@ -431,7 +431,7 @@ namespace ts.server {
                 this.getRenameInfo(fileName, position, findInStrings, findInComments);
             }
 
-            return this.lastRenameEntry.locations;
+            return this.lastRenameEntry!.locations;
         }
 
         private decodeNavigationBarItems(items: protocol.NavigationBarItem[] | undefined, fileName: string, lineMap: number[]): NavigationBarItem[] {

src/harness/fakes.ts

@@ -215,7 +215,7 @@ namespace fakes {
 
         private _setParentNodes: boolean;
         private _sourceFiles: collections.SortedMap<string, ts.SourceFile>;
-        private _parseConfigHost: ParseConfigHost;
+        private _parseConfigHost: ParseConfigHost | undefined;
         private _newLine: string;
 
         constructor(sys: System | vfs.FileSystem, options = ts.getDefaultCompilerOptions(), setParentNodes = false) {

src/harness/fourslash.ts

@@ -158,7 +158,7 @@ namespace FourSlash {
         public lastKnownMarker = "";
 
         // The file that's currently 'opened'
-        public activeFile: FourSlashFile;
+        public activeFile!: FourSlashFile;
 
         // Whether or not we should format on keystrokes
         public enableFormatting = true;
@@ -855,9 +855,9 @@ namespace FourSlash {
         }
 
         /** Use `getProgram` instead of accessing this directly. */
-        private _program: ts.Program;
+        private _program: ts.Program | undefined;
         /** Use `getChecker` instead of accessing this directly. */
-        private _checker: ts.TypeChecker;
+        private _checker: ts.TypeChecker | undefined;
 
         private getProgram(): ts.Program {
             return this._program || (this._program = this.languageService.getProgram()!); // TODO: GH#18217
@@ -3734,7 +3734,7 @@ namespace FourSlashInterface {
     }
 
     export class VerifyNegatable {
-        public not: VerifyNegatable;
+        public not: VerifyNegatable | undefined;
 
         constructor(protected state: FourSlash.TestState, private negative = false) {
             if (!negative) {

src/harness/harnessLanguageService.ts

@@ -289,8 +289,8 @@ namespace Harness.LanguageService {
     class ShimLanguageServiceHost extends LanguageServiceAdapterHost implements ts.LanguageServiceShimHost, ts.CoreServicesShimHost {
         private nativeHost: NativeLanguageServiceHost;
 
-        public getModuleResolutionsForFile: (fileName: string) => string;
-        public getTypeReferenceDirectiveResolutionsForFile: (fileName: string) => string;
+        public getModuleResolutionsForFile: ((fileName: string) => string) | undefined;
+        public getTypeReferenceDirectiveResolutionsForFile: ((fileName: string) => string) | undefined;
 
         constructor(preprocessToResolve: boolean, cancellationToken?: ts.HostCancellationToken, options?: ts.CompilerOptions) {
             super(cancellationToken, options);
@@ -639,7 +639,7 @@ namespace Harness.LanguageService {
 
     // Server adapter
     class SessionClientHost extends NativeLanguageServiceHost implements ts.server.SessionClientHost {
-        private client: ts.server.SessionClient;
+        private client!: ts.server.SessionClient;
 
         constructor(cancellationToken: ts.HostCancellationToken | undefined, settings: ts.CompilerOptions | undefined) {
             super(cancellationToken, settings);

src/harness/typeWriter.ts

@@ -21,7 +21,7 @@ interface TypeWriterResult {
 }
 
 class TypeWriterWalker {
-    currentSourceFile: ts.SourceFile;
+    currentSourceFile!: ts.SourceFile;
 
     private checker: ts.TypeChecker;
 

src/harness/virtualFileSystemWithWatch.ts

@@ -341,7 +341,7 @@ interface Array<T> {}`
         private readonly currentDirectory: string;
         private readonly dynamicPriorityWatchFile: HostWatchFile | undefined;
         private readonly customRecursiveWatchDirectory: HostWatchDirectory | undefined;
-        public require: (initialPath: string, moduleName: string) => server.RequireResult;
+        public require: ((initialPath: string, moduleName: string) => server.RequireResult) | undefined;
 
         constructor(public withSafeList: boolean, public useCaseSensitiveFileNames: boolean, executingFilePath: string, currentDirectory: string, fileOrFolderorSymLinkList: ReadonlyArray<FileOrFolderOrSymLink>, public readonly newLine = "\n", public readonly useWindowsStylePath?: boolean, private readonly environmentVariables?: Map<string>) {
             this.getCanonicalFileName = createGetCanonicalFileName(useCaseSensitiveFileNames);

src/server/editorServices.ts

@@ -479,7 +479,7 @@ namespace ts.server {
          */
         private readonly openFilesWithNonRootedDiskPath = createMap<ScriptInfo>();
 
-        private compilerOptionsForInferredProjects: CompilerOptions;
+        private compilerOptionsForInferredProjects: CompilerOptions | undefined;
         private compilerOptionsForInferredProjectsPerProjectRoot = createMap<CompilerOptions>();
         /**
          * Project size for configured or external projects
@@ -501,7 +501,7 @@ namespace ts.server {
 
         private pendingProjectUpdates = createMap<Project>();
         /* @internal */
-        pendingEnsureProjectForOpenFiles: boolean;
+        pendingEnsureProjectForOpenFiles = false;
 
         readonly currentDirectory: NormalizedPath;
         readonly toCanonicalFileName: (f: string) => string;
@@ -1936,7 +1936,7 @@ namespace ts.server {
         }
 
         private createInferredProject(currentDirectory: string | undefined, isSingleInferredProject?: boolean, projectRootPath?: NormalizedPath): InferredProject {
-            const compilerOptions = projectRootPath && this.compilerOptionsForInferredProjectsPerProjectRoot.get(projectRootPath) || this.compilerOptionsForInferredProjects;
+            const compilerOptions = projectRootPath && this.compilerOptionsForInferredProjectsPerProjectRoot.get(projectRootPath) || this.compilerOptionsForInferredProjects!; // TODO: GH#18217
             const project = new InferredProject(this, this.documentRegistry, compilerOptions, projectRootPath, currentDirectory, this.currentPluginConfigOverrides);
             if (isSingleInferredProject) {
                 this.inferredProjects.unshift(project);

src/server/project.ts

@@ -112,9 +112,9 @@ namespace ts.server {
     export abstract class Project implements LanguageServiceHost, ModuleResolutionHost {
         private rootFiles: ScriptInfo[] = [];
         private rootFilesMap: Map<ProjectRoot> = createMap<ProjectRoot>();
-        private program: Program;
-        private externalFiles: SortedReadonlyArray<string>;
-        private missingFilesMap: Map<FileWatcher>;
+        private program: Program | undefined;
+        private externalFiles: SortedReadonlyArray<string> | undefined;
+        private missingFilesMap: Map<FileWatcher> | undefined;
         private plugins: PluginModuleWithName[] = [];
 
         /*@internal*/
@@ -141,7 +141,7 @@ namespace ts.server {
         readonly realpath?: (path: string) => string;
 
         /*@internal*/
-        hasInvalidatedResolution: HasInvalidatedResolution;
+        hasInvalidatedResolution: HasInvalidatedResolution | undefined;
 
         /*@internal*/
         resolutionCache: ResolutionCache;
@@ -154,7 +154,7 @@ namespace ts.server {
         /**
          * Set of files that was returned from the last call to getChangesSinceVersion.
          */
-        private lastReportedFileNames: Map<true>;
+        private lastReportedFileNames: Map<true> | undefined;
         /**
          * Last version that was reported.
          */
@@ -512,8 +512,8 @@ namespace ts.server {
                 return [];
             }
             updateProjectIfDirty(this);
-            this.builderState = BuilderState.create(this.program, this.projectService.toCanonicalFileName, this.builderState);
-            return mapDefined(BuilderState.getFilesAffectedBy(this.builderState, this.program, scriptInfo.path, this.cancellationToken, data => this.projectService.host.createHash!(data)), // TODO: GH#18217
+            this.builderState = BuilderState.create(this.program!, this.projectService.toCanonicalFileName, this.builderState);
+            return mapDefined(BuilderState.getFilesAffectedBy(this.builderState, this.program!, scriptInfo.path, this.cancellationToken, data => this.projectService.host.createHash!(data)), // TODO: GH#18217
                 sourceFile => this.shouldEmitFile(this.projectService.getScriptInfoForPath(sourceFile.path)!) ? sourceFile.fileName : undefined);
         }
 
@@ -594,7 +594,7 @@ namespace ts.server {
 
         /* @internal */
         getSourceFileOrConfigFile(path: Path): SourceFile | undefined {
-            const options = this.program.getCompilerOptions();
+            const options = this.program!.getCompilerOptions();
             return path === options.configFilePath ? options.configFile : this.getSourceFile(path);
         }
 
@@ -681,7 +681,7 @@ namespace ts.server {
                 // if language service is not enabled - return just root files
                 return this.rootFiles;
             }
-            return map(this.program.getSourceFiles(), sourceFile => {
+            return map(this.program!.getSourceFiles(), sourceFile => {
                 const scriptInfo = this.projectService.getScriptInfoForPath(sourceFile.resolvedPath);
                 Debug.assert(!!scriptInfo, "getScriptInfo", () => `scriptInfo for a file '${sourceFile.fileName}' Path: '${sourceFile.path}' / '${sourceFile.resolvedPath}' is missing.`);
                 return scriptInfo!;
@@ -749,7 +749,7 @@ namespace ts.server {
         }
 
         containsScriptInfo(info: ScriptInfo): boolean {
-            return this.isRoot(info) || (this.program && this.program.getSourceFileByPath(info.path) !== undefined);
+            return this.isRoot(info) || (!!this.program && this.program.getSourceFileByPath(info.path) !== undefined);
         }
 
         containsFile(filename: NormalizedPath, requireOpen?: boolean): boolean {
@@ -845,7 +845,7 @@ namespace ts.server {
                 // (can reuse cached imports for files that were not changed)
                 // 4. compilation settings were changed in the way that might affect module resolution - drop all caches and collect all data from the scratch
                 if (hasNewProgram || changedFiles.length) {
-                    this.lastCachedUnresolvedImportsList = getUnresolvedImports(this.program, this.cachedUnresolvedImportsPerFile);
+                    this.lastCachedUnresolvedImportsList = getUnresolvedImports(this.program!, this.cachedUnresolvedImportsPerFile);
                 }
 
                 this.projectService.typingsCache.enqueueInstallTypingsForProject(this, this.lastCachedUnresolvedImportsList, hasAddedorRemovedFiles);
@@ -872,7 +872,7 @@ namespace ts.server {
         }
 
         /* @internal */
-        getCurrentProgram() {
+        getCurrentProgram(): Program | undefined {
             return this.program;
         }
 
@@ -911,7 +911,7 @@ namespace ts.server {
                     }
 
                     oldProgram.forEachResolvedProjectReference((resolvedProjectReference, resolvedProjectReferencePath) => {
-                        if (resolvedProjectReference && !this.program.getResolvedProjectReferenceByPath(resolvedProjectReferencePath)) {
+                        if (resolvedProjectReference && !this.program!.getResolvedProjectReferenceByPath(resolvedProjectReferencePath)) {
                             this.detachScriptInfoFromProject(resolvedProjectReference.sourceFile.fileName);
                         }
                     });
@@ -967,8 +967,8 @@ namespace ts.server {
                         this.getCachedDirectoryStructureHost().addOrDeleteFile(fileName, missingFilePath, eventKind);
                     }
 
-                    if (eventKind === FileWatcherEventKind.Created && this.missingFilesMap.has(missingFilePath)) {
-                        this.missingFilesMap.delete(missingFilePath);
+                    if (eventKind === FileWatcherEventKind.Created && this.missingFilesMap!.has(missingFilePath)) {
+                        this.missingFilesMap!.delete(missingFilePath);
                         fileWatcher.close();
 
                         // When a missing file is created, we should update the graph.
@@ -983,7 +983,7 @@ namespace ts.server {
         }
 
         private isWatchedMissingFile(path: Path) {
-            return this.missingFilesMap && this.missingFilesMap.has(path);
+            return !!this.missingFilesMap && this.missingFilesMap.has(path);
         }
 
         getScriptInfoForNormalizedPath(fileName: NormalizedPath): ScriptInfo | undefined {
@@ -1344,22 +1344,22 @@ namespace ts.server {
      * Otherwise it will create an InferredProject.
      */
     export class ConfiguredProject extends Project {
-        private typeAcquisition: TypeAcquisition;
+        private typeAcquisition!: TypeAcquisition; // TODO: GH#18217
         /* @internal */
         configFileWatcher: FileWatcher | undefined;
         private directoriesWatchedForWildcards: Map<WildcardDirectoryWatcher> | undefined;
         readonly canonicalConfigFilePath: NormalizedPath;
 
         /* @internal */
-        pendingReload: ConfigFileProgramReloadLevel;
+        pendingReload: ConfigFileProgramReloadLevel | undefined;
         /* @internal */
         pendingReloadReason: string | undefined;
 
         /*@internal*/
         configFileSpecs: ConfigFileSpecs | undefined;
 
         /*@internal*/
-        canConfigFileJsonReportNoInputFiles: boolean;
+        canConfigFileJsonReportNoInputFiles = false;
 
         /** Ref count to the project when opened from external project */
         private externalProjectRefCount = 0;
@@ -1590,7 +1590,7 @@ namespace ts.server {
      */
     export class ExternalProject extends Project {
         excludedFiles: ReadonlyArray<NormalizedPath> = [];
-        private typeAcquisition: TypeAcquisition;
+        private typeAcquisition!: TypeAcquisition; // TODO: GH#18217
         /*@internal*/
         constructor(public externalProjectName: string,
             projectService: ProjectService,

src/server/scriptInfo.ts

@@ -36,15 +36,15 @@ namespace ts.server {
         /**
          * True if the text is for the file thats open in the editor
          */
-        public isOpen: boolean;
+        public isOpen = false;
         /**
          * True if the text present is the text from the file on the disk
          */
-        private ownFileText: boolean;
+        private ownFileText = false;
         /**
          * True when reloading contents of file from the disk is pending
          */
-        private pendingReloadFromDisk: boolean;
+        private pendingReloadFromDisk = false;
 
         constructor(private readonly host: ServerHost, private readonly fileName: NormalizedPath, initialVersion: ScriptInfoVersion | undefined, private readonly info: ScriptInfo) {
             this.version = initialVersion || { svc: 0, text: 0 };
@@ -279,7 +279,7 @@ namespace ts.server {
         private realpath: Path | undefined;
 
         /*@internal*/
-        cacheSourceFile: DocumentRegistrySourceFileCache;
+        cacheSourceFile: DocumentRegistrySourceFileCache | undefined;
 
         /*@internal*/
         mTime?: number;

src/server/scriptVersionCache.ts

@@ -41,11 +41,11 @@ namespace ts.server {
         // path to start of range
         private readonly startPath: LineCollection[];
         private readonly endBranch: LineCollection[] = [];
-        private branchNode: LineNode;
+        private branchNode: LineNode | undefined;
         // path to current node
         private readonly stack: LineNode[];
         private state = CharRangeSection.Entire;
-        private lineCollectionAtBranch: LineCollection;
+        private lineCollectionAtBranch: LineCollection | undefined;
         private initialText = "";
         private trailingText = "";
 
@@ -383,7 +383,7 @@ namespace ts.server {
     }
 
     export class LineIndex {
-        root: LineNode;
+        root!: LineNode;
         // set this to true to check each edit for accuracy
         checkEdits = false;
 

src/server/session.ts

@@ -516,7 +516,7 @@ namespace ts.server {
         protected projectService: ProjectService;
         private changeSeq = 0;
 
-        private currentRequestId: number;
+        private currentRequestId!: number;
         private errorCheck: MultistepOperation;
 
         protected host: ServerHost;

src/services/formatting/formattingContext.ts

@@ -10,11 +10,11 @@ namespace ts.formatting {
     }
 
     export class FormattingContext {
-        public currentTokenSpan: TextRangeWithKind;
-        public nextTokenSpan: TextRangeWithKind;
-        public contextNode: Node;
-        public currentTokenParent: Node;
-        public nextTokenParent: Node;
+        public currentTokenSpan!: TextRangeWithKind;
+        public nextTokenSpan!: TextRangeWithKind;
+        public contextNode!: Node;
+        public currentTokenParent!: Node;
+        public nextTokenParent!: Node;
 
         private contextNodeAllOnSameLine: boolean | undefined;
         private nextNodeAllOnSameLine: boolean | undefined;
@@ -26,17 +26,11 @@ namespace ts.formatting {
         }
 
         public updateContext(currentRange: TextRangeWithKind, currentTokenParent: Node, nextRange: TextRangeWithKind, nextTokenParent: Node, commonParent: Node) {
-            Debug.assert(currentRange !== undefined, "currentTokenSpan is null");
-            Debug.assert(currentTokenParent !== undefined, "currentTokenParent is null");
-            Debug.assert(nextRange !== undefined, "nextTokenSpan is null");
-            Debug.assert(nextTokenParent !== undefined, "nextTokenParent is null");
-            Debug.assert(commonParent !== undefined, "commonParent is null");
-
-            this.currentTokenSpan = currentRange;
-            this.currentTokenParent = currentTokenParent;
-            this.nextTokenSpan = nextRange;
-            this.nextTokenParent = nextTokenParent;
-            this.contextNode = commonParent;
+            this.currentTokenSpan = Debug.assertDefined(currentRange);
+            this.currentTokenParent = Debug.assertDefined(currentTokenParent);
+            this.nextTokenSpan = Debug.assertDefined(nextRange);
+            this.nextTokenParent = Debug.assertDefined(nextTokenParent);
+            this.contextNode = Debug.assertDefined(commonParent);
 
             // drop cached results
             this.contextNodeAllOnSameLine = undefined;