Custom binary encoding for symbols and types

Author: andrewbranch

_api/src/async/api.ts

@@ -8,10 +8,10 @@ import {
     Type as BaseType,
 } from "../base/api.ts";
 import type {
-    ProjectData,
-    SymbolData,
-    TypeData,
-} from "../types.ts";
+    ProjectResponse,
+    SymbolResponse,
+    TypeResponse,
+} from "../base/proto.ts";
 import { Client } from "./client.ts";
 import { startLSPServer } from "./lsp.ts";
 
@@ -50,7 +50,7 @@ export class API implements BaseAPI<true> {
 export class Project extends BaseProject<true> {
     private client: Client;
 
-    constructor(client: Client, data: ProjectData) {
+    constructor(client: Client, data: ProjectResponse) {
         super(data);
         this.client = client;
     }
@@ -69,7 +69,7 @@ export class Symbol extends BaseSymbol<true> {
     private client: Client;
     private project: Project;
 
-    constructor(client: Client, project: Project, data: SymbolData) {
+    constructor(client: Client, project: Project, data: SymbolResponse) {
         super(data);
         this.client = client;
         this.project = project;
@@ -84,7 +84,7 @@ export class Symbol extends BaseSymbol<true> {
 export class Type extends BaseType<true> {
     private client: Client;
 
-    constructor(client: Client, data: TypeData) {
+    constructor(client: Client, data: TypeResponse) {
         super(data);
         this.client = client;
     }

_api/src/base/api.ts

@@ -1,13 +1,11 @@
 import { SymbolFlags } from "#symbolFlags";
 import type { SourceFile as SourceFileNode } from "../ast/ast.ts";
 import { RemoteNode } from "../ast/node.ts";
+import type { MaybeAsync } from "../types.ts";
 import type {
-    MaybeAsync,
-    ParsedCommandLine,
-    ProjectData,
-    SymbolData,
-    TypeData,
-} from "../types.ts";
+    ConfigResponse,
+    ProjectResponse,
+} from "./proto.ts";
 
 export interface APIOptions {
     tsserverPath: string;
@@ -16,7 +14,7 @@ export interface APIOptions {
 }
 
 export interface API<Async extends boolean> {
-    parseConfigFile(fileName: string): MaybeAsync<Async, ParsedCommandLine>;
+    parseConfigFile(fileName: string): MaybeAsync<Async, ConfigResponse>;
     loadProject(configFileName: string): MaybeAsync<Async, Project<Async>>;
 }
 
@@ -26,20 +24,20 @@ export abstract class Project<Async extends boolean> {
     compilerOptions!: Record<string, unknown>;
     rootFiles!: readonly string[];
 
-    constructor(data: ProjectData) {
+    constructor(data: ProjectResponse) {
         this.id = data.id;
         this.loadData(data);
     }
 
-    loadData(data: ProjectData): void {
+    loadData(data: ProjectResponse): void {
         this.configFileName = data.configFileName;
         this.compilerOptions = data.compilerOptions;
         this.rootFiles = data.rootFiles;
     }
 
     abstract reload(): MaybeAsync<Async, void>;
     abstract getSourceFile(fileName: string): MaybeAsync<Async, SourceFileNode | undefined>;
-    abstract getSymbolAtPosition(fileName: string, position: number): MaybeAsync<Async, Symbol<Async> | undefined>;
+    abstract getSymbolAtPosition(fileName: string, position: number): MaybeAsync<Async, Symbol | undefined>;
 }
 
 export abstract class SourceFile extends RemoteNode {
@@ -51,28 +49,46 @@ export abstract class SourceFile extends RemoteNode {
 
 export { SymbolFlags };
 
-export abstract class Symbol<Async extends boolean> {
-    protected id: number;
-    name: string;
-    flags: SymbolFlags;
-    checkFlags: number;
+export abstract class Symbol {
+    private data: Uint8Array;
+    private view: DataView;
+    private decoder: TextDecoder;
 
-    constructor(data: SymbolData) {
-        this.id = data.id;
-        this.name = data.name;
-        this.flags = data.flags;
-        this.checkFlags = data.checkFlags;
+    constructor(data: Uint8Array, decoder: TextDecoder) {
+        this.data = data;
+        this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        this.decoder = decoder;
+    }
+
+    get id(): number {
+        return this.view.getUint32(0, true);
+    }
+
+    get flags(): number {
+        return this.view.getUint32(4, true);
+    }
+
+    get checkFlags(): number {
+        return this.view.getUint32(8, true);
     }
 
-    abstract getType(): MaybeAsync<Async, Type<Async> | undefined>;
+    get name(): string {
+        return this.decoder.decode(this.data.subarray(12));
+    }
 }
 
 export abstract class Type<Async extends boolean> {
-    protected id: number;
-    flags: number;
+    private view: DataView;
 
-    constructor(data: TypeData) {
-        this.id = data.id;
-        this.flags = data.flags;
+    constructor(data: Uint8Array) {
+        this.view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    }
+
+    get id(): number {
+        return this.view.getUint32(0, true);
+    }
+
+    get flags(): number {
+        return this.view.getUint32(4, true);
     }
 }

_api/src/base/binary.ts

@@ -0,0 +1,33 @@
+import type {
+    GetSymbolAtPositionRequest,
+    GetTypeOfSymbolRequest,
+    SymbolResponse,
+} from "./proto.ts";
+
+export function encodeGetSymbolAtPositionRequest(projectId: number, fileName: string, position: number, encoder: TextEncoder): Uint8Array {
+    // assume ASCII filename
+    const asciiLength = fileName.length;
+    const result = new Uint8Array(2 + 4 + asciiLength);
+    const view = new DataView(result.buffer);
+    view.setUint16(0, projectId, true);
+    view.setUint32(2, position, true);
+    const { read } = encoder.encodeInto(fileName, result.subarray(2 + 4));
+    // check if ASCII assumption was correct
+    if (read !== asciiLength) {
+        const encodedFileName = encoder.encode(fileName);
+        const newResult = new Uint8Array(2 + 4 + encodedFileName.length);
+        newResult.set(result.subarray(0, 2 + 4));
+        newResult.set(encodedFileName, 2 + 4);
+        return newResult;
+    }
+
+    return result;
+}
+
+export function encodeGetTypeOfSymbolRequest(projectId: number, symbolId: number): Uint8Array {
+    const result = new Uint8Array(6);
+    const view = new DataView(result.buffer);
+    view.setUint16(0, projectId, true);
+    view.setUint32(2, symbolId, true);
+    return result;
+}

_api/src/base/proto.ts

@@ -0,0 +1,33 @@
+export interface ConfigResponse {
+    options: Record<string, unknown>;
+    fileNames: string[];
+}
+
+export interface ProjectResponse {
+    id: number;
+    configFileName: string;
+    compilerOptions: Record<string, unknown>;
+    rootFiles: string[];
+}
+
+export interface GetSymbolAtPositionRequest {
+    project: number;
+    fileName: string;
+    position: number;
+}
+
+export interface SymbolResponse {
+    id: number;
+    name: string;
+    flags: number;
+    checkFlags: number;
+}
+
+export interface GetTypeOfSymbolRequest {
+    symbol: number;
+}
+
+export interface TypeResponse {
+    id: number;
+    flags: number;
+}

_api/src/bench.ts

@@ -35,7 +35,7 @@ import { API } from "./sync/api.ts";
             if (isIdentifier(node)) {
                 const symbol = project.getSymbolAtPosition("checker.ts", node.pos);
                 if (symbol?.flags! & SymbolFlags.Value) {
-                    symbol?.getType();
+                    project.getTypeOfSymbol(symbol!);
                 }
             }
             node.forEachChild(child => visitNode(child));

_api/src/sync/api.ts

@@ -8,12 +8,11 @@ import {
     Type as BaseType,
 } from "../base/api.ts";
 import type {
-    FileSystemEntries,
-    ParsedCommandLine,
-    ProjectData,
-    SymbolData,
-    TypeData,
-} from "../types.ts";
+    ConfigResponse,
+    ProjectResponse,
+    SymbolResponse,
+    TypeResponse,
+} from "../base/proto.ts";
 import { Client } from "./client.ts";
 
 export interface APIOptions extends BaseAPIOptions {
@@ -25,7 +24,7 @@ export class API implements BaseAPI<false> {
         this.client = new Client(options);
     }
 
-    parseConfigFile(fileName: string): ParsedCommandLine {
+    parseConfigFile(fileName: string): ConfigResponse {
         return this.client.request("parseConfigFile", { fileName });
     }
 
@@ -42,7 +41,7 @@ export class API implements BaseAPI<false> {
 export class Project extends BaseProject<false> {
     private client: Client;
 
-    constructor(client: Client, data: ProjectData) {
+    constructor(client: Client, data: ProjectResponse) {
         super(data);
         this.client = client;
     }
@@ -60,14 +59,19 @@ export class Project extends BaseProject<false> {
     getSymbolAtPosition(fileName: string, position: number): Symbol | undefined;
     getSymbolAtPosition(...params: [fileName: string, position: number] | [readonly { fileName: string; position: number; }[]]): Symbol | undefined | (Symbol | undefined)[] {
         if (params.length === 2) {
-            const data = this.client.request("getSymbolAtPosition", { project: this.id, fileName: params[0], position: params[1] });
-            return data ? new Symbol(this.client, this, data) : undefined;
+            const data = this.client.getSymbolAtPosition(this.id, params[0], params[1]);
+            return data.length ? new Symbol(this.client, data) : undefined;
         }
         else {
-            const data = this.client.request("getSymbolAtPosition", params[0].map(({ fileName, position }) => ({ project: this.id, fileName, position })));
-            return data.map((d: SymbolData | null) => d ? new Symbol(this.client, this, d) : undefined);
+            // const data = this.client.request("getSymbolAtPosition", params[0].map(({ fileName, position }) => ({ project: this.id, fileName, position })));
+            // return data.map((d: SymbolResponse | null) => d ? new Symbol(this.client, this, d) : undefined);
         }
     }
+
+    getTypeOfSymbol(symbol: Symbol): Type | undefined {
+        const data = this.client.getTypeOfSymbol(this.id, symbol.id);
+        return data ? new Type(this.client, data) : undefined;
+    }
 }
 
 export class SourceFile extends BaseSourceFile {
@@ -80,25 +84,18 @@ export class SourceFile extends BaseSourceFile {
     }
 }
 
-export class Symbol extends BaseSymbol<false> {
+export class Symbol extends BaseSymbol {
     private client: Client;
-    private project: Project;
 
-    constructor(client: Client, project: Project, data: SymbolData) {
-        super(data);
+    constructor(client: Client, data: Uint8Array) {
+        super(data, client.decoder);
         this.client = client;
-        this.project = project;
-    }
-
-    getType(): Type | undefined {
-        const data = this.client.request("getTypeOfSymbol", { project: this.project.id, symbol: this.id });
-        return data ? new Type(this.client, data) : undefined;
     }
 }
 
 export class Type extends BaseType<false> {
     private client: Client;
-    constructor(client: Client, data: TypeData) {
+    constructor(client: Client, data: Uint8Array) {
         super(data);
         this.client = client;
     }

_api/src/sync/client.ts

@@ -1,4 +1,8 @@
 import { SyncRpcChannel } from "libsyncrpc";
+import {
+    encodeGetSymbolAtPositionRequest,
+    encodeGetTypeOfSymbolRequest,
+} from "../base/binary.ts";
 import type { FileSystemEntries } from "../types.ts";
 
 export interface ClientOptions {
@@ -16,8 +20,8 @@ export interface ClientOptions {
 
 export class Client {
     private channel: SyncRpcChannel;
-    private decoder = new TextDecoder();
-    private encoder = new TextEncoder();
+    decoder: TextDecoder = new TextDecoder();
+    encoder: TextEncoder = new TextEncoder();
 
     constructor(options: ClientOptions) {
         this.channel = new SyncRpcChannel(options.tsserverPath, [
@@ -33,14 +37,20 @@ export class Client {
                 callbacks: Object.keys(options.fs ?? {}),
             }),
         );
+        for (const callback in options.fs) {
+            this.channel.registerCallback(callback, (_, arg) => {
+                const result = options.fs?.[callback as keyof typeof options.fs]?.(JSON.parse(this.decoder.decode(arg)));
+                return JSON.stringify(result) ?? "";
+            });
+        }
     }
 
-    registerCallback(method: string, callback: (payload: any) => any): void {
-        this.channel.registerCallback(method, (_, arg) => {
-            const result = callback(JSON.parse(this.decoder.decode(arg)));
-            return JSON.stringify(result) ?? "";
-        });
-        this.channel.requestSync("registerCallback", method);
+    getSymbolAtPosition(projectId: number, fileName: string, position: number): Uint8Array {
+        return this.channel.requestBinarySync("getSymbolAtPosition", encodeGetSymbolAtPositionRequest(projectId, fileName, position, this.encoder));
+    }
+
+    getTypeOfSymbol(projectId: number, symbolId: number): Uint8Array {
+        return this.channel.requestBinarySync("getTypeOfSymbol", encodeGetTypeOfSymbolRequest(projectId, symbolId));
     }
 
     request(method: string, payload: any): any {

_api/src/types.ts

@@ -4,27 +4,3 @@ export interface FileSystemEntries {
     files: string[];
     directories: string[];
 }
-
-export interface ParsedCommandLine {
-    options: Record<string, unknown>;
-    fileNames: string[];
-}
-
-export interface ProjectData {
-    id: number;
-    configFileName: string;
-    compilerOptions: Record<string, unknown>;
-    rootFiles: string[];
-}
-
-export interface SymbolData {
-    id: number;
-    name: string;
-    flags: number;
-    checkFlags: number;
-}
-
-export interface TypeData {
-    id: number;
-    flags: number;
-}