Remove implied public modifier.

Author: whitequark

src/cxxrtl/client.ts

@@ -40,7 +40,7 @@ export class Connection {
         });
     }
 
-    public dispose(): void {
+    dispose(): void {
         this.link.dispose();
     }
 
@@ -126,53 +126,53 @@ export class Connection {
         });
     }
 
-    public async onConnected(): Promise<void> {}
+    async onConnected(): Promise<void> {}
 
-    public async onDisconnected(): Promise<void> {}
+    async onDisconnected(): Promise<void> {}
 
-    public async onEvent(_event: proto.AnyEvent): Promise<void> {}
+    async onEvent(_event: proto.AnyEvent): Promise<void> {}
 
-    public get state(): ConnectionState {
+    get state(): ConnectionState {
         return this._state;
     }
 
-    public get commands(): string[] {
+    get commands(): string[] {
         return this._commands.slice();
     }
 
-    public get events(): string[] {
+    get events(): string[] {
         return this._events.slice();
     }
 
-    public get itemValuesEncodings(): string[] {
+    get itemValuesEncodings(): string[] {
         return this._itemValuesEncodings.slice();
     }
 
-    public async listScopes(command: proto.CommandListScopes): Promise<proto.ResponseListScopes> {
+    async listScopes(command: proto.CommandListScopes): Promise<proto.ResponseListScopes> {
         return await this.perform(command) as proto.ResponseListScopes;
     }
 
-    public async listItems(command: proto.CommandListItems): Promise<proto.ResponseListItems> {
+    async listItems(command: proto.CommandListItems): Promise<proto.ResponseListItems> {
         return await this.perform(command) as proto.ResponseListItems;
     }
 
-    public async referenceItems(command: proto.CommandReferenceItems): Promise<proto.ResponseReferenceItems> {
+    async referenceItems(command: proto.CommandReferenceItems): Promise<proto.ResponseReferenceItems> {
         return await this.perform(command) as proto.ResponseReferenceItems;
     }
 
-    public async queryInterval(command: proto.CommandQueryInterval): Promise<proto.ResponseQueryInterval> {
+    async queryInterval(command: proto.CommandQueryInterval): Promise<proto.ResponseQueryInterval> {
         return await this.perform(command) as proto.ResponseQueryInterval;
     }
 
-    public async getSimulationStatus(command: proto.CommandGetSimulationStatus): Promise<proto.ResponseGetSimulationStatus> {
+    async getSimulationStatus(command: proto.CommandGetSimulationStatus): Promise<proto.ResponseGetSimulationStatus> {
         return await this.perform(command) as proto.ResponseGetSimulationStatus;
     }
 
-    public async runSimulation(command: proto.CommandRunSimulation): Promise<proto.ResponseRunSimulation> {
+    async runSimulation(command: proto.CommandRunSimulation): Promise<proto.ResponseRunSimulation> {
         return await this.perform(command) as proto.ResponseRunSimulation;
     }
 
-    public async pauseSimulation(command: proto.CommandPauseSimulation): Promise<proto.ResponsePauseSimulation> {
+    async pauseSimulation(command: proto.CommandPauseSimulation): Promise<proto.ResponsePauseSimulation> {
         return await this.perform(command) as proto.ResponsePauseSimulation;
     }
 }

src/cxxrtl/link.ts

@@ -16,17 +16,17 @@ export class MockLink implements ILink {
         private conversation: [proto.ClientPacket, proto.ServerPacket | proto.ServerPacket[]][]
     ) {}
 
-    public dispose(): void {
+    dispose(): void {
         if (this.conversation.length !== 0) {
             throw new Error('disposed of before end of conversation');
         }
     }
 
-    public async onRecv(_serverPacket: proto.ServerPacket): Promise<void> {}
+    async onRecv(_serverPacket: proto.ServerPacket): Promise<void> {}
 
-    public async onDone(): Promise<void> {}
+    async onDone(): Promise<void> {}
 
-    public async send(clientPacket: proto.ClientPacket): Promise<void> {
+    async send(clientPacket: proto.ClientPacket): Promise<void> {
         if (this.conversation.length === 0) {
             throw new Error('premature end of conversation');
         }
@@ -109,15 +109,15 @@ export class NodeStreamLink implements ILink {
         }
     }
 
-    public dispose(): void {
+    dispose(): void {
         this.stream.destroy();
     }
 
-    public async onRecv(_serverPacket: proto.ServerPacket): Promise<void> {}
+    async onRecv(_serverPacket: proto.ServerPacket): Promise<void> {}
 
-    public async onDone(): Promise<void> {}
+    async onDone(): Promise<void> {}
 
-    public async send(clientPacket: proto.ClientPacket): Promise<void> {
+    async send(clientPacket: proto.ClientPacket): Promise<void> {
         this.stream.write(JSON.stringify(clientPacket) + '\0');
     }
 }

src/debugger.ts

@@ -19,15 +19,15 @@ export enum CXXRTLSessionStatus {
 export class CXXRTLDebugger {
     private statusBarItem: StatusBarItem;
     private terminal: vscode.Terminal | null = null;
-    public session: Session | null = null;
+    session: Session | null = null;
 
     // Session properties.
 
     private _onDidChangeSession: vscode.EventEmitter<Session | null> = new vscode.EventEmitter<Session | null>();
     readonly onDidChangeSession: vscode.Event<Session | null> = this._onDidChangeSession.event;
 
     private _sessionStatus: CXXRTLSessionStatus = CXXRTLSessionStatus.Absent;
-    public get sessionStatus() {
+    get sessionStatus() {
         return this._sessionStatus;
     }
     private _onDidChangeSessionStatus: vscode.EventEmitter<CXXRTLSessionStatus> = new vscode.EventEmitter<CXXRTLSessionStatus>();
@@ -36,7 +36,7 @@ export class CXXRTLDebugger {
     // Simulation properties.
 
     private _simulationStatus: CXXRTLSimulationStatus = CXXRTLSimulationStatus.Finished;
-    public get simulationStatus() {
+    get simulationStatus() {
         return this._simulationStatus;
     }
     private _onDidChangeSimulationStatus: vscode.EventEmitter<CXXRTLSimulationStatus> = new vscode.EventEmitter<CXXRTLSimulationStatus>();
@@ -46,12 +46,12 @@ export class CXXRTLDebugger {
         this.statusBarItem = new StatusBarItem(this);
     }
 
-    public dispose() {
+    dispose() {
         this.statusBarItem.dispose();
         this._onDidChangeSimulationStatus.dispose();
     }
 
-    public async startSession(): Promise<void> {
+    async startSession(): Promise<void> {
         if (this.terminal !== null) {
             vscode.window.showErrorMessage('A debug session is already in the process of being started.');
             return;
@@ -116,7 +116,7 @@ export class CXXRTLDebugger {
         }
     }
 
-    public stopSession() {
+    stopSession() {
         this._onDidChangeSession.fire(null);
 
         this.terminal?.dispose();

src/model/time.ts

@@ -10,35 +10,35 @@ export class TimePoint {
         this.#raw = secs * TimePoint.RESOLUTION + femtos;
     }
 
-    public get secs(): bigint {
+    get secs(): bigint {
         return this.#raw / TimePoint.RESOLUTION;
     }
 
-    public get femtos(): bigint {
+    get femtos(): bigint {
         return this.#raw % TimePoint.RESOLUTION;
     }
 
-    public equals(other: TimePoint): boolean {
+    equals(other: TimePoint): boolean {
         return this.#raw === other.#raw;
     }
 
-    public greaterThan(other: TimePoint): boolean {
+    greaterThan(other: TimePoint): boolean {
         return this.#raw > other.#raw;
     }
 
-    public lessThan(other: TimePoint): boolean {
+    lessThan(other: TimePoint): boolean {
         return this.#raw < other.#raw;
     }
 
-    public offsetByFemtos(femtos: bigint): TimePoint {
+    offsetByFemtos(femtos: bigint): TimePoint {
         return new TimePoint(this.secs, this.femtos + femtos);
     }
 
-    public differenceInFemtos(other: TimePoint): bigint {
+    differenceInFemtos(other: TimePoint): bigint {
         return this.#raw - other.#raw;
     }
 
-    public toString(): string {
+    toString(): string {
         function groupDecimals(num: bigint) {
             const groups: string[] = [];
             if (num === 0n) {
@@ -70,7 +70,7 @@ export class TimePoint {
         }
     }
 
-    public static fromString(value: string): TimePoint {
+    static fromString(value: string): TimePoint {
         const matches = value.match(/^(\d+)\s*(s|ms|us|ns|ps|fs)$/);
         if (matches === null) {
             throw new SyntaxError(`${JSON.stringify(value)} is not a valid time point`);
@@ -94,27 +94,27 @@ export class TimePoint {
         }
     }
 
-    public static fromCXXRTL(value: string): TimePoint {
+    static fromCXXRTL(value: string): TimePoint {
         const matches = value.match(/^(\d+)\.(\d+)$/);
         if (matches === null) {
             throw new SyntaxError(`${JSON.stringify(value)} is not a valid time point`);
         }
         return new TimePoint(BigInt(matches[1]), BigInt(matches[2]));
     }
 
-    public toCXXRTL(): string {
+    toCXXRTL(): string {
         return `${this.secs.toString()}.${this.femtos.toString().padStart(15, '0')}`;
     }
 }
 
 export class TimeInterval {
     constructor(public begin: TimePoint, public end: TimePoint) {}
 
-    public static fromCXXRTL([begin, end]: [string, string]): TimeInterval {
+    static fromCXXRTL([begin, end]: [string, string]): TimeInterval {
         return new TimeInterval(TimePoint.fromCXXRTL(begin), TimePoint.fromCXXRTL(end));
     }
 
-    public toCXXRTL(): [string, string] {
+    toCXXRTL(): [string, string] {
         return [this.begin.toCXXRTL(), this.end.toCXXRTL()];
     }
 }