Changes before error encountered

Co-authored-by: alexr00 <38270282+alexr00@users.noreply.github.com>

Author: Copilot

.eslintrc.js

@@ -29,7 +29,8 @@ module.exports = {
 			files: ['**/*.ts', '**/*.tsx'],
 			rules: {
 				'rulesdir/no-any-except-union-method-signature': 'error',
-				'rulesdir/no-pr-in-user-strings': 'error'
+				'rulesdir/no-pr-in-user-strings': 'error',
+				'rulesdir/private-members-underscore': 'error'
 			}
 		}
 	]

build/eslint-rules/index.js

@@ -9,4 +9,5 @@ module.exports = {
 	'public-methods-well-defined-types': require('./public-methods-well-defined-types'),
 	'no-any-except-union-method-signature': require('./no-any-except-union-method-signature'),
 	'no-pr-in-user-strings': require('./no-pr-in-user-strings'),
+	'private-members-underscore': require('./private-members-underscore'),
 };

build/eslint-rules/private-members-underscore.js

@@ -0,0 +1,129 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+'use strict';
+
+/**
+ * ESLint rule to enforce that private class members start with underscore (_).
+ * This rule checks private properties, methods, getters, and setters in TypeScript classes.
+ */
+
+module.exports = {
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce that private class members start with underscore (_)',
+			category: 'TypeScript',
+			recommended: true,
+		},
+		schema: [],
+		messages: {
+			privateUnderscore: 'Private member "{{memberName}}" should start with underscore (_).',
+		},
+		fixable: 'code',
+	},
+
+	create(context) {
+		/**
+		 * Check if a member is private
+		 */
+		function isPrivateMember(node) {
+			// Check for explicit private modifier
+			if (node.accessibility === 'private') {
+				return true;
+			}
+
+			// Check for private modifier in the modifiers array (for different AST node types)
+			if (node.modifiers) {
+				return node.modifiers.some(modifier => modifier.kind === 'private');
+			}
+
+			return false;
+		}
+
+		/**
+		 * Check if a member name starts with underscore
+		 */
+		function startsWithUnderscore(name) {
+			return name && name.startsWith('_');
+		}
+
+		/**
+		 * Get the member name from various node types
+		 */
+		function getMemberName(node) {
+			if (node.key) {
+				// For method definitions, property definitions
+				if (node.key.type === 'Identifier') {
+					return node.key.name;
+				}
+			}
+			return null;
+		}
+
+		/**
+		 * Report and potentially fix a private member naming violation
+		 */
+		function reportViolation(node, memberName) {
+			context.report({
+				node,
+				messageId: 'privateUnderscore',
+				data: {
+					memberName,
+				},
+				fix(fixer) {
+					// Only provide auto-fix for simple identifier cases
+					if (node.key && node.key.type === 'Identifier') {
+						return fixer.replaceText(node.key, `_${memberName}`);
+					}
+					return null;
+				},
+			});
+		}
+
+		return {
+			// Handle class property definitions
+			PropertyDefinition(node) {
+				if (isPrivateMember(node)) {
+					const memberName = getMemberName(node);
+					if (memberName && !startsWithUnderscore(memberName)) {
+						reportViolation(node, memberName);
+					}
+				}
+			},
+
+			// Handle method definitions (including getters/setters)
+			MethodDefinition(node) {
+				if (isPrivateMember(node)) {
+					const memberName = getMemberName(node);
+					if (memberName && !startsWithUnderscore(memberName)) {
+						reportViolation(node, memberName);
+					}
+				}
+			},
+
+			// Handle constructor parameters with private modifier
+			TSParameterProperty(node) {
+				if (isPrivateMember(node)) {
+					if (node.parameter && node.parameter.type === 'Identifier') {
+						const memberName = node.parameter.name;
+						if (memberName && !startsWithUnderscore(memberName)) {
+							context.report({
+								node,
+								messageId: 'privateUnderscore',
+								data: {
+									memberName,
+								},
+								fix(fixer) {
+									return fixer.replaceText(node.parameter, `_${memberName}`);
+								},
+							});
+						}
+					}
+				}
+			},
+		};
+	},
+};

src/api/api1.ts

@@ -80,7 +80,7 @@ export class GitApiImpl extends Disposable implements API, IGit {
 	private _providers = new Map<number, IGit>();
 
 	public constructor(
-		private readonly repositoriesManager: RepositoriesManager) {
+		private readonly _repositoriesManager) {
 		super();
 	}
 
@@ -228,7 +228,7 @@ export class GitApiImpl extends Disposable implements API, IGit {
 	}
 
 	async getRepositoryDescription(uri: vscode.Uri) {
-		const folderManagerForRepo = this.repositoriesManager.getManagerForFile(uri);
+		const folderManagerForRepo = this._repositoriesManager.getManagerForFile(uri);
 
 		if (folderManagerForRepo && folderManagerForRepo.gitHubRepositories.length > 0) {
 			const repositoryMetadata = await folderManagerForRepo.gitHubRepositories[0].getMetadata();

src/common/logger.ts

@@ -32,7 +32,7 @@ class Log extends Disposable {
 		this._activePerfMarkers.delete(marker);
 	}
 
-	private logString(message: string | Error | Stringish | Object, component?: string): string {
+	private _logString(message: string | Error | Stringish | Object, component?: string): string {
 		let logMessage: string;
 		if (typeof message !== 'string') {
 			const asString = message as Partial<Stringish>;
@@ -50,23 +50,23 @@ class Log extends Disposable {
 	}
 
 	public trace(message: string | Error | Stringish | Object, component: string) {
-		this._outputChannel.trace(this.logString(message, component));
+		this._outputChannel.trace(this._logString(message, component));
 	}
 
 	public debug(message: string | Error | Stringish | Object, component: string) {
-		this._outputChannel.debug(this.logString(message, component));
+		this._outputChannel.debug(this._logString(message, component));
 	}
 
 	public appendLine(message: string | Error | Stringish | Object, component: string) {
-		this._outputChannel.info(this.logString(message, component));
+		this._outputChannel.info(this._logString(message, component));
 	}
 
 	public warn(message: string | Error | Stringish | Object, component?: string) {
-		this._outputChannel.warn(this.logString(message, component));
+		this._outputChannel.warn(this._logString(message, component));
 	}
 
 	public error(message: string | Error | Stringish | Object, component: string) {
-		this._outputChannel.error(this.logString(message, component));
+		this._outputChannel.error(this._logString(message, component));
 	}
 }
 

src/common/protocol.ts

@@ -17,7 +17,7 @@ export enum ProtocolType {
 }
 
 export class Protocol {
-	private static readonly ID = 'Protocol';
+	private static readonly _ID = 'Protocol';
 	public type: ProtocolType = ProtocolType.OTHER;
 	public host: string = '';
 
@@ -31,14 +31,14 @@ export class Protocol {
 
 	public readonly url: vscode.Uri;
 	constructor(uriString: string) {
-		if (this.parseSshProtocol(uriString)) {
+		if (this._parseSshProtocol(uriString)) {
 			this.url = vscode.Uri.from({ scheme: 'ssh', authority: this.host, path: `/${this.nameWithOwner}` });
 			return;
 		}
 
 		try {
 			this.url = vscode.Uri.parse(uriString);
-			this.type = this.getType(this.url.scheme);
+			this.type = this._getType(this.url.scheme);
 
 			this.host = this.getHostName(this.url.authority);
 			if (this.host) {
@@ -53,7 +53,7 @@ export class Protocol {
 		}
 	}
 
-	private getType(scheme: string): ProtocolType {
+	private _getType(scheme: string): ProtocolType {
 		switch (scheme) {
 			case 'file':
 				return ProtocolType.Local;
@@ -69,7 +69,7 @@ export class Protocol {
 		}
 	}
 
-	private parseSshProtocol(uriString: string): boolean {
+	private _parseSshProtocol(uriString: string): boolean {
 		const sshConfig = resolve(uriString);
 		if (!sshConfig) {
 			return false;

src/common/temporaryState.ts

@@ -10,37 +10,37 @@ let tempState: TemporaryState | undefined;
 
 export class TemporaryState extends vscode.Disposable {
 	static readonly ID = 'TemporaryState';
-	private readonly SUBPATH = 'temp';
-	private readonly disposables: vscode.Disposable[] = [];
-	private readonly persistInSessionDisposables: vscode.Disposable[] = [];
+	private readonly _SUBPATH = 'temp';
+	private readonly _disposables: vscode.Disposable[] = [];
+	private readonly _persistInSessionDisposables: vscode.Disposable[] = [];
 
-	constructor(private readonly _storageUri: vscode.Uri) {
-		super(() => disposeAll(this.disposables));
+	constructor(private readonly _storageUri: vscode.Uri) {
+		super(() => disposeAll(this._disposables));
 	}
 
-	private get path(): vscode.Uri {
-		return vscode.Uri.joinPath(this._storageUri, this.SUBPATH);
+	private get _path(): vscode.Uri {
+		return vscode.Uri.joinPath(this._storageUri, this._SUBPATH);
 	}
 
-	override dispose() {
-		disposeAll(this.disposables);
-		disposeAll(this.persistInSessionDisposables);
+	override dispose() {
+		disposeAll(this._disposables);
+		disposeAll(this._persistInSessionDisposables);
 	}
 
-	private addDisposable(disposable: vscode.Disposable, persistInSession: boolean) {
-		if (persistInSession) {
-			this.persistInSessionDisposables.push(disposable);
-		} else {
-			if (this.disposables.length > 30) {
-				const oldDisposable = this.disposables.shift();
-				oldDisposable?.dispose();
-			}
-			this.disposables.push(disposable);
-		}
+	private _addDisposable(disposable: vscode.Disposable, persistInSession: boolean) {
+		if (persistInSession) {
+			this._persistInSessionDisposables.push(disposable);
+		} else {
+			if (this._disposables.length > 30) {
+				const oldDisposable = this._disposables.shift();
+				oldDisposable?.dispose();
+			}
+			this._disposables.push(disposable);
+		}
 	}
 
-	private async writeState(subpath: string, filename: string, contents: Uint8Array, persistInSession: boolean): Promise<vscode.Uri> {
-		let filePath: vscode.Uri = this.path;
+	private async _writeState(subpath: string, filename: string, contents: Uint8Array, persistInSession: boolean): Promise<vscode.Uri> {
+		let filePath: vscode.Uri = this._path;
 		const workspace = (vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 0)
 			? vscode.workspace.workspaceFolders[0].name : undefined;
 
@@ -64,12 +64,12 @@ export class TemporaryState extends vscode.Disposable {
 				}
 			}
 		};
-		this.addDisposable(dispose, persistInSession);
+		this._addDisposable(dispose, persistInSession);
 		return file;
 	}
 
-	private async readState(subpath: string, filename: string): Promise<Uint8Array> {
-		let filePath: vscode.Uri = this.path;
+	private async _readState(subpath: string, filename: string): Promise<Uint8Array> {
+		let filePath: vscode.Uri = this._path;
 		const workspace = (vscode.workspace.workspaceFolders && vscode.workspace.workspaceFolders.length > 0)
 			? vscode.workspace.workspaceFolders[0].name : undefined;
 
@@ -84,13 +84,13 @@ export class TemporaryState extends vscode.Disposable {
 	static async init(context: vscode.ExtensionContext): Promise<vscode.Disposable | undefined> {
 		if (context.globalStorageUri && !tempState) {
 			tempState = new TemporaryState(context.globalStorageUri);
-			try {
-				await vscode.workspace.fs.delete(tempState.path, { recursive: true });
-			} catch (e) {
-				Logger.appendLine(`Error in initialization: ${e.message}`, TemporaryState.ID);
-			}
-			try {
-				await vscode.workspace.fs.createDirectory(tempState.path);
+			try {
+				await vscode.workspace.fs.delete(tempState._path, { recursive: true });
+			} catch (e) {
+				Logger.appendLine(`Error in initialization: ${e.message}`, TemporaryState.ID);
+			}
+			try {
+				await vscode.workspace.fs.createDirectory(tempState._path);
 			} catch (e) {
 				Logger.appendLine(`Error in initialization: ${e.message}`, TemporaryState.ID);
 			}
@@ -104,14 +104,14 @@ export class TemporaryState extends vscode.Disposable {
 			return;
 		}
 
-		return tempState.writeState(subpath, filename, contents, persistInSession);
+		return tempState._writeState(subpath, filename, contents, persistInSession);
 	}
 
 	static async read(subpath: string, filename: string): Promise<Uint8Array | undefined> {
 		if (!tempState) {
 			return;
 		}
 
-		return tempState.readState(subpath, filename);
+		return tempState._readState(subpath, filename);
 	}
 }