Mohsen Azimi mohsen1

tsz perf: how do we close a 200x+ gap to tsgo on `large-ts-repo`?

Background

tsz is a Rust port of the TypeScript compiler, aiming for parity with tsc behavior plus better speed than tsgo (the Go port). On most fixtures we're competitive or ahead, but on multi-package monorepo workloads we are catastrophically behind:

Fixture	Files	tsgo	tsz	Factor
`utility-types`	small	117ms	100ms	tsz 1.17× faster
`type-fest` (heavy `.d.ts` mapped types)	16.5K LOC	103ms	219ms	tsgo 2.11× faster

ask.js

CLI tool that uses DeepSeek AI to debug Rust projects by analyzing test failures.

This is highly personalized to my own use case. But you can customize it for yourself.

This will collect all of test failues, filter out passing test, serialize the repo and git changes into one request to ask deepseek for help

Setup

`serialize-repo.ts`

You probably want to put this in your repo and run it via npx and tsx as such:

First make sure you have the dependencies with npm/yarn/pnpm. You need ignore, lodash and yargs

npx tsx src/scripts/serialize-repo.ts

	/**
	* Create an input element
	*/
	function createInput(type: 'text', value: string): HTMLInputElement;
	function createInput(type: 'checkbox', value: boolean): HTMLInputElement;
	function createInput(type, value) {
	// code
	}

	/**
	* Create an input element
	* @param {string} type
	* @param {string\|boolean} value
	* @return {HTMLInputElement}
	*/
	function createInput(type, value) {
	const el = document.createElement('input');
	el.type = type;
	if (type === 'checkbox') {

	import * as React from 'react';
	import { computed } from 'mobx';
	import { inject, observer, Provider } from 'mobx-react';
	import { fromPromise } from 'mobx-utils';
	import {StaticRouter} from 'react-router-dom';
	import { Request, Response } from 'express';
	import * as ReactDOM from 'react-dom/server';

	interface Item {
	weight: number;

	import * as React from 'react';
	import { RouteComponentProps } from 'react-router-dom';

	interface LoadableProps<T> {
	loader: (props: RouteComponentProps<T>) => (() => Promise<React.ComponentType<T>> \| React.ComponentType<T>);
	loading: React.ComponentType<T>;
	}
	export function Loadable<T>(loadableProps: LoadableProps<T>) {

	return class LoadableComponent extends React.Component<RouteComponentProps<T>, { ResultComponent: React.ComponentType<T> }> {

	function foo(a) {
	console.log(a.b)
	}
	foo({})

	function power2(a) {
	return a * a;
	}
	power2('string')