├── .gitignore
├── .prettierrc.js
├── .vscode
    └── settings.json
├── LICENSE
├── README.md
├── package.json
├── src
    ├── ast.ts
    ├── eval.ts
    ├── index.ts
    ├── parser.ts
    ├── test
    │   └── test.ts
    └── utils.ts
├── tsconfig.json
└── yarn.lock


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules


--------------------------------------------------------------------------------
/.prettierrc.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   semi: true,
3 |   trailingComma: 'all',
4 |   singleQuote: true,
5 |   bracketSpacing: false,
6 |   arrowParens: 'always',
7 | };
8 | 


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 |   "editor.formatOnSave": true,
3 |   "typescript.tsdk": "node_modules\\typescript\\lib",
4 | }
5 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2022 judehunter
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # ts-asm
2 | 
3 | Read the story: https://judehunter.dev/blog/assembly-interpreter-in-typescripts-type-system
4 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 |   "devDependencies": {
3 |     "prettier": "^2.7.1",
4 |     "typescript": "^4.8.4"
5 |   }
6 | }
7 | 


--------------------------------------------------------------------------------
/src/ast.ts:
--------------------------------------------------------------------------------
  1 | export type Register =
  2 |   | 'r0'
  3 |   | 'r1'
  4 |   | 'r2'
  5 |   | 'r3'
  6 |   | 'r4'
  7 |   | 'r5'
  8 |   | 'r6'
  9 |   | 'r7'
 10 |   | 'sp'
 11 |   | 'lr'
 12 |   | 'pc';
 13 | 
 14 | export type Immediate = string;
 15 | 
 16 | export type AddIInstr<
 17 |   Rd extends Register,
 18 |   Rn extends Register,
 19 |   imm extends Immediate,
 20 | > = {
 21 |   type: 'AddI';
 22 |   Rd: Rd;
 23 |   Rn: Rn;
 24 |   imm: imm;
 25 | };
 26 | 
 27 | export type AddRInstr<
 28 |   Rd extends Register,
 29 |   Rn extends Register,
 30 |   Rm extends Register,
 31 | > = {
 32 |   type: 'AddR';
 33 |   Rd: Rd;
 34 |   Rn: Rn;
 35 |   Rm: Rm;
 36 | };
 37 | 
 38 | export type SubIInstr<
 39 |   Rd extends Register,
 40 |   Rn extends Register,
 41 |   imm extends Immediate,
 42 | > = {
 43 |   type: 'SubI';
 44 |   Rd: Rd;
 45 |   Rn: Rn;
 46 |   imm: imm;
 47 | };
 48 | 
 49 | export type SubRInstr<
 50 |   Rd extends Register,
 51 |   Rn extends Register,
 52 |   Rm extends Register,
 53 | > = {
 54 |   type: 'SubR';
 55 |   Rd: Rd;
 56 |   Rn: Rn;
 57 |   Rm: Rm;
 58 | };
 59 | 
 60 | export type MovIInstr<Rd extends Register, imm extends Immediate> = {
 61 |   type: 'MovI';
 62 |   Rd: Rd;
 63 |   imm: imm;
 64 | };
 65 | 
 66 | export type MovRInstr<Rd extends Register, Rm extends Register> = {
 67 |   type: 'MovR';
 68 |   Rd: Rd;
 69 |   Rm: Rm;
 70 | };
 71 | 
 72 | export type LabelInstr<name extends string> = {
 73 |   type: 'Label';
 74 |   name: name;
 75 | };
 76 | 
 77 | export type _BranchInstr<label extends string> = {
 78 |   type: 'Branch';
 79 |   label: label;
 80 | };
 81 | 
 82 | export type _BranchIfZeroInstr<Rn extends Register, label extends string> = {
 83 |   type: 'BranchIfZero';
 84 |   Rn: Rn;
 85 |   label: label;
 86 | };
 87 | 
 88 | export type _BranchIfNotZeroInstr<Rn extends Register, label extends string> = {
 89 |   type: 'BranchIfNotZero';
 90 |   Rn: Rn;
 91 |   label: label;
 92 | };
 93 | 
 94 | export type _BranchIf<
 95 |   type extends 'BranchIfZero' | 'BranchIfNotZero',
 96 |   Rn extends Register,
 97 |   label extends string,
 98 | > = {
 99 |   type: type;
100 |   Rn: Rn;
101 |   label: label;
102 | };
103 | 
104 | export type BranchIf<
105 |   type extends 'BranchIfZero' | 'BranchIfNotZero',
106 |   Rn extends Register,
107 |   address extends string,
108 | > = {
109 |   type: type;
110 |   Rn: Rn;
111 |   address: address;
112 | };
113 | 
114 | export type _BranchLinkInstr<label extends string> = {
115 |   type: '_BranchLink';
116 |   label: label;
117 | };
118 | 
119 | export type BranchLinkInstr<address extends string> = {
120 |   type: 'BranchLink';
121 |   address: address;
122 | };
123 | 
124 | export type PushInstr<Rm extends Register> = {
125 |   type: 'Push';
126 |   Rm: Rm;
127 | };
128 | 
129 | export type PopInstr<Rm extends Register> = {
130 |   type: 'Pop';
131 |   Rm: Rm;
132 | };
133 | 
134 | export type StrIInstr<
135 |   Rt extends Register,
136 |   Rn extends Register,
137 |   imm extends Immediate,
138 | > = {
139 |   type: 'StrI';
140 |   Rt: Rt;
141 |   Rn: Rn;
142 |   imm: imm;
143 | };
144 | 
145 | export type StrRInstr<
146 |   Rt extends Register,
147 |   Rn extends Register,
148 |   Rm extends Register,
149 | > = {
150 |   type: 'StrR';
151 |   Rt: Rt;
152 |   Rn: Rn;
153 |   Rm: Rm;
154 | };
155 | 
156 | export type LdrIInstr<
157 |   Rt extends Register,
158 |   Rn extends Register,
159 |   imm extends Immediate,
160 | > = {
161 |   type: 'LdrI';
162 |   Rt: Rt;
163 |   Rn: Rn;
164 |   imm: imm;
165 | };
166 | 
167 | export type LdrRInstr<
168 |   Rt extends Register,
169 |   Rn extends Register,
170 |   Rm extends Register,
171 | > = {
172 |   type: 'LdrR';
173 |   Rt: Rt;
174 |   Rn: Rn;
175 |   Rm: Rm;
176 | };
177 | 
178 | export type LSLIInstr<
179 |   Rd extends Register,
180 |   Rm extends Register,
181 |   imm extends Immediate,
182 | > = {
183 |   type: 'LslI';
184 |   Rd: Rd;
185 |   Rm: Rm;
186 |   imm: imm;
187 | };
188 | 
189 | export type LSLRInstr<
190 |   Rd extends Register,
191 |   Rm extends Register,
192 |   Rs extends Register,
193 | > = {
194 |   type: 'LslR';
195 |   Rd: Rd;
196 |   Rm: Rm;
197 |   Rs: Rs;
198 | };
199 | export type LSRIInstr<
200 |   Rd extends Register,
201 |   Rm extends Register,
202 |   imm extends Immediate,
203 | > = {
204 |   type: 'LsrI';
205 |   Rd: Rd;
206 |   Rm: Rm;
207 |   imm: imm;
208 | };
209 | 
210 | export type LSRRInstr<
211 |   Rd extends Register,
212 |   Rm extends Register,
213 |   Rs extends Register,
214 | > = {
215 |   type: 'LsrR';
216 |   Rd: Rd;
217 |   Rm: Rm;
218 |   Rs: Rs;
219 | };
220 | 
221 | export type Indexed<T, idx extends string> = T & {idx: idx};
222 | 
223 | // export type Resolved<T, address extends string> = T &
224 | 


--------------------------------------------------------------------------------
/src/eval.ts:
--------------------------------------------------------------------------------
  1 | // type X<T extends string> = T['length'];
  2 | 
  3 | import {Signature} from './utils';
  4 | import {
  5 |   AddIInstr,
  6 |   AddRInstr,
  7 |   BranchIf,
  8 |   BranchLinkInstr,
  9 |   Immediate,
 10 |   LabelInstr,
 11 |   LdrIInstr,
 12 |   LdrRInstr,
 13 |   LSLIInstr,
 14 |   LSLRInstr,
 15 |   LSRIInstr,
 16 |   LSRRInstr,
 17 |   MovIInstr,
 18 |   MovRInstr,
 19 |   PopInstr,
 20 |   PushInstr,
 21 |   Register,
 22 |   StrIInstr,
 23 |   StrRInstr,
 24 |   SubIInstr,
 25 |   SubRInstr,
 26 | } from './ast';
 27 | import {ParseProgram, ResolveLabels} from './parser';
 28 | 
 29 | type Adder<A, B, C> = [A, B, C] extends ['0', '0', '0']
 30 |   ? {result: '0'; carry: '0'}
 31 |   : [A, B, C] extends ['1', '0', '0'] | ['0', '1', '0'] | ['0', '0', '1']
 32 |   ? {result: '1'; carry: '0'}
 33 |   : [A, B, C] extends ['1', '1', '0'] | ['1', '0', '1'] | ['0', '1', '1']
 34 |   ? {result: '0'; carry: '1'}
 35 |   : {result: '1'; carry: '1'};
 36 | 
 37 | type Head<T> = T extends `${infer R extends '0' | '1'}${string}` ? R : never;
 38 | 
 39 | type Tail<T> = T extends `${'0' | '1'}${infer R extends string}`
 40 |   ? R extends ''
 41 |     ? never
 42 |     : R
 43 |   : never;
 44 | 
 45 | export type EvalAdd<A, B> = [Tail<A>, Tail<B>] extends [infer AU, infer BU]
 46 |   ? [AU, BU] extends [never, never]
 47 |     ? Adder<A, B, '0'>
 48 |     : EvalAdd<AU, BU> extends infer Rest extends {carry: any; result: any}
 49 |     ? Adder<Head<A>, Head<B>, Rest['carry']> extends infer Current extends {
 50 |         carry: any;
 51 |         result: any;
 52 |       }
 53 |       ? {
 54 |           result: `${Current['result']}${Rest['result']}`;
 55 |           carry: Current['carry'];
 56 |         }
 57 |       : never
 58 |     : never
 59 |   : never;
 60 | 
 61 | type OnesComplement<T> = T extends ''
 62 |   ? ''
 63 |   : T extends `0${infer Rest}`
 64 |   ? `1${OnesComplement<Rest>}`
 65 |   : T extends `1${infer Rest}`
 66 |   ? `0${OnesComplement<Rest>}`
 67 |   : never;
 68 | 
 69 | type TwosComplement<T> = EvalAdd<OnesComplement<T>, '00000001'>['result'];
 70 | 
 71 | type EvalSub<A, B> = EvalAdd<A, TwosComplement<B>>;
 72 | 
 73 | // type Test = EvalSub<'00000010', '00001000'>;
 74 | 
 75 | type Overwrite<A, B> = Omit<A, keyof B> & B;
 76 | 
 77 | type EvalAddRInstr<T, Ctx extends Context> = T extends AddRInstr<
 78 |   infer Rd,
 79 |   infer Rn,
 80 |   infer Rm
 81 | >
 82 |   ? {
 83 |       memory: Ctx['memory'];
 84 |       registers: Overwrite<
 85 |         Overwrite<
 86 |           Ctx['registers'],
 87 |           Record<
 88 |             Rd,
 89 |             EvalAdd<Ctx['registers'][Rn], Ctx['registers'][Rm]>['result']
 90 |           >
 91 |         >,
 92 |         {pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result']}
 93 |       >;
 94 |     }
 95 |   : never;
 96 | 
 97 | type EvalAddIInstr<T, Ctx extends Context> = T extends AddIInstr<
 98 |   infer Rd,
 99 |   infer Rn,
100 |   infer imm
101 | >
102 |   ? {
103 |       memory: Ctx['memory'];
104 |       registers: Overwrite<
105 |         Overwrite<
106 |           Ctx['registers'],
107 |           Record<Rd, EvalAdd<Ctx['registers'][Rn], imm>['result']>
108 |         >,
109 |         {pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result']}
110 |       >;
111 |     }
112 |   : never;
113 | 
114 | type EvalSubIInstr<T, Ctx extends Context> = T extends SubIInstr<
115 |   infer Rd,
116 |   infer Rn,
117 |   infer imm
118 | >
119 |   ? {
120 |       memory: Ctx['memory'];
121 |       registers: Overwrite<
122 |         Overwrite<
123 |           Ctx['registers'],
124 |           Record<Rd, EvalSub<Ctx['registers'][Rn], imm>['result']>
125 |         >,
126 |         {pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result']}
127 |       >;
128 |     }
129 |   : never;
130 | 
131 | type EvalSubRInstr<T, Ctx extends Context> = T extends SubRInstr<
132 |   infer Rd,
133 |   infer Rn,
134 |   infer Rm
135 | >
136 |   ? {
137 |       memory: Ctx['memory'];
138 |       registers: Overwrite<
139 |         Overwrite<
140 |           Ctx['registers'],
141 |           Record<
142 |             Rd,
143 |             EvalSub<Ctx['registers'][Rn], Ctx['registers'][Rm]>['result']
144 |           >
145 |         >,
146 |         {pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result']}
147 |       >;
148 |     }
149 |   : never;
150 | 
151 | type EvalMovIInstr<T, Ctx extends Context> = T extends MovIInstr<
152 |   infer Rd,
153 |   infer imm
154 | >
155 |   ? {
156 |       memory: Ctx['memory'];
157 |       registers: Overwrite<
158 |         Overwrite<
159 |           Ctx['registers'],
160 |           {pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result']}
161 |         >,
162 |         Record<Rd, imm>
163 |       >;
164 |     }
165 |   : never;
166 | 
167 | type EvalMovRInstr<T, Ctx extends Context> = T extends MovRInstr<
168 |   infer Rd,
169 |   infer Rm
170 | >
171 |   ? {
172 |       memory: Ctx['memory'];
173 |       registers: Overwrite<
174 |         Overwrite<
175 |           Ctx['registers'],
176 |           {pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result']}
177 |         >,
178 |         Record<Rd, Ctx['registers'][Rm]>
179 |       >;
180 |     }
181 |   : never;
182 | 
183 | type EvalBranchIfInstr<T, Ctx extends Context> = T extends BranchIf<
184 |   infer type,
185 |   infer Rn,
186 |   infer address
187 | >
188 |   ? {
189 |       memory: Ctx['memory'];
190 |       registers: Overwrite<
191 |         Ctx['registers'],
192 |         {
193 |           pc: Ctx['registers'][Rn] extends '00000000'
194 |             ? type extends 'BranchIfZero'
195 |               ? address
196 |               : EvalAdd<Ctx['registers']['pc'], '00000001'>['result']
197 |             : type extends 'BranchIfZero'
198 |             ? EvalAdd<Ctx['registers']['pc'], '00000001'>['result']
199 |             : address;
200 |         }
201 |       >;
202 |     }
203 |   : never;
204 | 
205 | type EvalBranchLinkInstr<T, Ctx extends Context> = T extends BranchLinkInstr<
206 |   infer address
207 | >
208 |   ? {
209 |       memory: Ctx['memory'];
210 |       registers: Overwrite<
211 |         Ctx['registers'],
212 |         {
213 |           pc: address;
214 |           lr: EvalAdd<Ctx['registers']['pc'], '00000001'>['result'];
215 |         }
216 |       >;
217 |     }
218 |   : never;
219 | 
220 | type EvalLabelInstr<T, Ctx extends Context> = T extends LabelInstr<string>
221 |   ? {
222 |       memory: Ctx['memory'];
223 |       registers: Overwrite<
224 |         Ctx['registers'],
225 |         {pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result']}
226 |       >;
227 |     }
228 |   : never;
229 | 
230 | type EvalPushInstr<T, Ctx extends Context> = T extends PushInstr<infer Rm>
231 |   ? {
232 |       memory: Overwrite<
233 |         Ctx['memory'],
234 |         Record<Ctx['registers']['sp'], Ctx['registers'][Rm]>
235 |       >;
236 |       registers: Overwrite<
237 |         Ctx['registers'],
238 |         {
239 |           pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result'];
240 |           sp: EvalSub<Ctx['registers']['sp'], '00000001'>['result'];
241 |         }
242 |       >;
243 |     }
244 |   : never;
245 | 
246 | type EvalPopInstr<T, Ctx extends Context> = T extends PopInstr<infer Rm>
247 |   ? {
248 |       memory: Ctx['memory'];
249 |       registers: Overwrite<
250 |         Overwrite<
251 |           Ctx['registers'],
252 |           {
253 |             pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result'];
254 |             sp: EvalAdd<Ctx['registers']['sp'], '00000001'>['result'];
255 |           }
256 |         >,
257 |         Record<
258 |           Rm,
259 |           Ctx['memory'][EvalAdd<Ctx['registers']['sp'], '00000001'>['result']]
260 |         >
261 |       >;
262 |     }
263 |   : never;
264 | 
265 | type EvalStrIInstr<T, Ctx extends Context> = T extends StrIInstr<
266 |   infer Rt,
267 |   infer Rn,
268 |   infer imm
269 | >
270 |   ? {
271 |       memory: Overwrite<
272 |         Ctx['memory'],
273 |         Record<
274 |           EvalAdd<Ctx['registers'][Rn], imm>['result'],
275 |           Ctx['registers'][Rt]
276 |         >
277 |       >;
278 |       registers: Overwrite<
279 |         Ctx['registers'],
280 |         {
281 |           pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result'];
282 |         }
283 |       >;
284 |     }
285 |   : never;
286 | 
287 | type EvalStrRInstr<T, Ctx extends Context> = T extends StrRInstr<
288 |   infer Rt,
289 |   infer Rn,
290 |   infer Rm
291 | >
292 |   ? {
293 |       memory: Overwrite<
294 |         Ctx['memory'],
295 |         Record<
296 |           EvalAdd<Ctx['registers'][Rn], Ctx['registers'][Rm]>['result'],
297 |           Ctx['registers'][Rt]
298 |         >
299 |       >;
300 |       registers: Overwrite<
301 |         Ctx['registers'],
302 |         {
303 |           pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result'];
304 |         }
305 |       >;
306 |     }
307 |   : never;
308 | 
309 | type EvalLdrIInstr<T, Ctx extends Context> = T extends LdrIInstr<
310 |   infer Rt,
311 |   infer Rn,
312 |   infer imm
313 | >
314 |   ? {
315 |       memory: Ctx['memory'];
316 |       registers: Overwrite<
317 |         Overwrite<
318 |           Ctx['registers'],
319 |           {
320 |             pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result'];
321 |           }
322 |         >,
323 |         Record<Rt, Ctx['memory'][EvalAdd<Ctx['registers'][Rn], imm>['result']]>
324 |       >;
325 |     }
326 |   : never;
327 | 
328 | type EvalLdrRInstr<T, Ctx extends Context> = T extends LdrRInstr<
329 |   infer Rt,
330 |   infer Rn,
331 |   infer Rm
332 | >
333 |   ? {
334 |       memory: Ctx['memory'];
335 |       registers: Overwrite<
336 |         Overwrite<
337 |           Ctx['registers'],
338 |           {
339 |             pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result'];
340 |           }
341 |         >,
342 |         Record<
343 |           Rt,
344 |           Ctx['memory'][EvalAdd<
345 |             Ctx['registers'][Rn],
346 |             Ctx['registers'][Rm]
347 |           >['result']]
348 |         >
349 |       >;
350 |     }
351 |   : never;
352 | 
353 | type SingleLSL<T> = T extends `${infer First}${infer Rest}`
354 |   ? `${Rest}0`
355 |   : never;
356 | type SingleLSRLoop<T> = T extends `${infer First}${infer Rest}`
357 |   ? Rest extends ''
358 |     ? ''
359 |     : `${First}${SingleLSRLoop<Rest>}`
360 |   : never;
361 | type SingleLSR<T> = `0${SingleLSRLoop<T>}`;
362 | type EvalLSL<T, amount extends string> = amount extends '00000000'
363 |   ? T
364 |   : EvalLSL<SingleLSL<T>, EvalSub<amount, '00000001'>['result']>;
365 | type EvalLSR<T, amount extends string> = amount extends '00000000'
366 |   ? T
367 |   : EvalLSR<SingleLSR<T>, EvalSub<amount, '00000001'>['result']>;
368 | 
369 | type EvalLSLIInstr<T, Ctx extends Context> = T extends LSLIInstr<
370 |   infer Rd,
371 |   infer Rm,
372 |   infer imm
373 | >
374 |   ? {
375 |       memory: Ctx['memory'];
376 |       registers: Overwrite<
377 |         Overwrite<
378 |           Ctx['registers'],
379 |           Record<Rd, EvalLSL<Ctx['registers'][Rm], imm>>
380 |         >,
381 |         {pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result']}
382 |       >;
383 |     }
384 |   : never;
385 | 
386 | type EvalLSLRInstr<T, Ctx extends Context> = T extends LSLRInstr<
387 |   infer Rd,
388 |   infer Rm,
389 |   infer Rs
390 | >
391 |   ? {
392 |       memory: Ctx['memory'];
393 |       registers: Overwrite<
394 |         Overwrite<
395 |           Ctx['registers'],
396 |           Record<Rd, EvalLSL<Ctx['registers'][Rm], Ctx['registers'][Rs]>>
397 |         >,
398 |         {pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result']}
399 |       >;
400 |     }
401 |   : never;
402 | 
403 | type EvalLSRIInstr<T, Ctx extends Context> = T extends LSRIInstr<
404 |   infer Rd,
405 |   infer Rm,
406 |   infer imm
407 | >
408 |   ? {
409 |       memory: Ctx['memory'];
410 |       registers: Overwrite<
411 |         Overwrite<
412 |           Ctx['registers'],
413 |           Record<Rd, EvalLSR<Ctx['registers'][Rm], imm>>
414 |         >,
415 |         {pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result']}
416 |       >;
417 |     }
418 |   : never;
419 | 
420 | type EvalLSRRInstr<T, Ctx extends Context> = T extends LSRRInstr<
421 |   infer Rd,
422 |   infer Rm,
423 |   infer Rs
424 | >
425 |   ? {
426 |       memory: Ctx['memory'];
427 |       registers: Overwrite<
428 |         Overwrite<
429 |           Ctx['registers'],
430 |           Record<Rd, EvalLSR<Ctx['registers'][Rm], Ctx['registers'][Rs]>>
431 |         >,
432 |         {pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result']}
433 |       >;
434 |     }
435 |   : never;
436 | 
437 | type And<A, B> = [A, B] extends ['1', '1'] ? '1' : '0';
438 | 
439 | type EvalAnd<A, B> = [A, B] extends [
440 |   `${infer AFirst}${infer ARest}`,
441 |   `${infer BFirst}${infer BRest}`,
442 | ]
443 |   ? [ARest, BRest] extends ['', '']
444 |     ? And<AFirst, BFirst>
445 |     : `${And<AFirst, BFirst>}${EvalAnd<ARest, BRest>}`
446 |   : '';
447 | 
448 | type Or<A, B> = [A, B] extends ['0', '0'] ? '0' : '1';
449 | 
450 | type EvalOr<A, B> = [A, B] extends [
451 |   `${infer AFirst}${infer ARest}`,
452 |   `${infer BFirst}${infer BRest}`,
453 | ]
454 |   ? [ARest, BRest] extends ['', '']
455 |     ? Or<AFirst, BFirst>
456 |     : `${Or<AFirst, BFirst>}${EvalOr<ARest, BRest>}`
457 |   : '';
458 | 
459 | type XOr<A, B> = [A, B] extends ['0', '1'] | ['1', '0'] ? '1' : '0';
460 | 
461 | type EvalXOr<A, B> = [A, B] extends [
462 |   `${infer AFirst}${infer ARest}`,
463 |   `${infer BFirst}${infer BRest}`,
464 | ]
465 |   ? [ARest, BRest] extends ['', '']
466 |     ? XOr<AFirst, BFirst>
467 |     : `${XOr<AFirst, BFirst>}${EvalXOr<ARest, BRest>}`
468 |   : '';
469 | 
470 | type EvalNot<A> = EvalXOr<A, '11111111'>;
471 | 
472 | type EvalInstr<T, Ctx extends Context> =
473 |   | EvalAddIInstr<T, Ctx>
474 |   | EvalAddRInstr<T, Ctx>
475 |   | EvalMovIInstr<T, Ctx>
476 |   | EvalMovRInstr<T, Ctx>
477 |   | EvalLabelInstr<T, Ctx>
478 |   | EvalBranchIfInstr<T, Ctx>
479 |   | EvalSubIInstr<T, Ctx>
480 |   | EvalSubRInstr<T, Ctx>
481 |   | EvalBranchLinkInstr<T, Ctx>
482 |   | EvalPushInstr<T, Ctx>
483 |   | EvalPopInstr<T, Ctx>
484 |   | EvalStrIInstr<T, Ctx>
485 |   | EvalStrRInstr<T, Ctx>
486 |   | EvalLdrIInstr<T, Ctx>
487 |   | EvalLdrRInstr<T, Ctx>
488 |   | EvalLSLIInstr<T, Ctx>
489 |   | EvalLSLRInstr<T, Ctx>
490 |   | EvalLSRIInstr<T, Ctx>
491 |   | EvalLSRRInstr<T, Ctx>;
492 | 
493 | export type Context = {
494 |   registers: {
495 |     r0: string;
496 |     r1: string;
497 |     r2: string;
498 |     r3: string;
499 |     r4: string;
500 |     r5: string;
501 |     r6: string;
502 |     r7: string;
503 |     sp: string;
504 |     lr: string;
505 |     pc: string;
506 |   };
507 |   memory: Record<string, string>;
508 | };
509 | 
510 | // type PickPC<T, PC> = T extends PC ? T : never;
511 | 
512 | type Find<Instrs, PC> = {
513 |   [K in keyof Instrs]: Instrs[K] extends {idx: PC} ? Instrs[K] : never;
514 | };
515 | 
516 | type Clean<Arr> = {
517 |   [K in keyof Arr as K extends number ? K : never]: Arr[K];
518 | }[any];
519 | 
520 | type CleanFind<Instrs, PC> = Clean<Find<Instrs, PC>>;
521 | 
522 | // type t = Clean<Find<[{idx: '0'}, {idx: '1'}], '1'>>;
523 | 
524 | export type EvalProgram<Instrs, Ctx extends Context> = CleanFind<
525 |   Instrs,
526 |   Ctx['registers']['pc']
527 | > extends never
528 |   ? Ctx
529 |   : EvalProgram<
530 |       Instrs,
531 |       EvalInstr<CleanFind<Instrs, Ctx['registers']['pc']>, Ctx>
532 |     >;
533 | 
534 | // type Program = Eval<
535 | //   ResolveLabels<
536 | //     ParseProgram<`
537 | //       MOV r0, #00000110
538 | //       MOV r1, #11000110
539 | //       mul:
540 | //         CBZ r1, exit
541 | //         ADD r2, r2, r0
542 | //         SUB r1, r1, #00000001
543 | //         B mul
544 | //       exit:
545 | //     `>
546 | //   >
547 | // >;
548 | 
549 | // type Program = Eval<
550 | //   ResolveLabels<
551 | //     ParseProgram<`
552 | //       ADD r0, r0, #00000011
553 | //       ADD r1, r0, r0
554 | //       SUB r1, r1, #00000010
555 | //       SUB r1, r1, r0
556 | //       MOV r2, #00000010
557 | //       MOV r2, r1
558 | //     `>
559 | //   >
560 | // >;
561 | 
562 | // type Program = Eval<
563 | //   ResolveLabels<
564 | //     ParseProgram<`
565 | //       MOV r0, #00000010
566 | //       MOV r1, #00000001
567 | //       BL add
568 | //       B exit
569 | //       add:
570 | //         ADD r0, r0, r1
571 | //         BR lr
572 | //       exit:
573 | //     `>
574 | //   >
575 | // >;
576 | 
577 | // type Program = Eval<
578 | //   ResolveLabels<
579 | //     ParseProgram<`
580 | //       MOV r0, #00000110
581 | //       MOV r1, #11000110
582 | //       mul:
583 | //         CBZ r1, exit
584 | //         ADD r2, r2, r0
585 | //         SUB r1, r1, #00000001
586 | //         B mul
587 | //       exit:
588 | //     `>
589 | //   >
590 | // >;
591 | 
592 | // type Program = EvalProgram<
593 | //   ResolveLabels<
594 | //     ParseProgram<`
595 | //     MOV r0, #00000011
596 | //     MOV r1, #00000100
597 | //     loop:
598 | //       CBZ r1, exit
599 | //       ADD r0, r0, r0
600 | //       SUB r1, r1, #00000001
601 | //       B loop
602 | //     exit:
603 | //     `>
604 | //   >
605 | // >;
606 | 
607 | // type r0 = Program['registers']['r0'];
608 | // //   ^?
609 | // type r1 = Program['registers']['r1'];
610 | // //   ^?
611 | // type r2 = Program['registers']['r2'];
612 | // //   ^?
613 | // type mem = Signature<Program['memory']>;
614 | // //   ^?
615 | 
616 | // type Test = Signature<Eval<
617 | //   [
618 | //     {
619 | //       type: 'MovI';
620 | //       Rd: 'r1';
621 | //       imm: '00000001';
622 | //       idx: '00000000';
623 | //     },
624 | //     {
625 | //       type: 'MovI';
626 | //       Rd: 'r1';
627 | //       imm: '00000001';
628 | //       idx: '00000001';
629 | //     },
630 | //   ]
631 | // >>;
632 | 
633 | // > = Instrs[number] extends infer R
634 | //   ? R extends infer B extends {idx: PC}
635 | //     ? Eval<Instrs, EvalAdd<PC, '00000001'>['result']>
636 | //     : PC
637 | //   : never;
638 | 
639 | // type Eval<
640 | //   Instrs extends any[],
641 | //   Ctx extends Context = {
642 | //     registers: {
643 | //       r0: '00000000';
644 | //       r1: '00000000';
645 | //       r2: '00000000';
646 | //       r3: '00000000';
647 | //       r4: '00000000';
648 | //       r5: '00000000';
649 | //       r6: '00000000';
650 | //       r7: '00000000';
651 | //       sp: '00000000';
652 | //       lr: '00000000';
653 | //       pc: '00000001';
654 | //     };
655 | //     memory: [];
656 | //   }
657 | // > = {
658 | //   [K in keyof Instrs as Instrs[K] extends {idx: Ctx['registers']['pc']}
659 | //     ? K
660 | //     : never]: Instrs[K];
661 | // } extends infer R
662 | //   ? R[keyof R] extends infer Cur
663 | //     ? Cur extends never
664 | //       ? never
665 | //       : Eval<
666 | //           [],
667 | //           {
668 | //             registers: {
669 | //               r0: '00000000';
670 | //               r1: '00000000';
671 | //               r2: '00000000';
672 | //               r3: '00000000';
673 | //               r4: '00000000';
674 | //               r5: '00000000';
675 | //               r6: '00000000';
676 | //               r7: '00000000';
677 | //               sp: '00000000';
678 | //               lr: '00000000';
679 | //               pc: EvalAdd<Ctx['registers']['pc'], '00000001'>['result'];
680 | //             };
681 | //             memory: [];
682 | //           }
683 | //         >
684 | //     : 'never'
685 | //   : never;
686 | 
687 | // type XYZ = Eval<
688 | //   [
689 | //     {
690 | //       type: 'MovI';
691 | //       Rd: 'r1';
692 | //       imm: '00000001';
693 | //       idx: '00000000';
694 | //     },
695 | //   ]
696 | // >;
697 | 
698 | // Instrs[number] & {idx: Ctx['registers']['pc']} extends infer Cur
699 | // ? Cur extends never
700 | //   ? Ctx
701 | //   : Eval<Instrs, EvalInstr<Cur, Ctx>>
702 | // : Ctx;
703 | 
704 | // type XXX = EvalAdd<'00000000', '00000010'>;
705 | // type EvalTest = Eval<
706 | //   [
707 | //     {
708 | //       type: 'ADD';
709 | //       Rd: 'r0';
710 | //       Rn: 'r1';
711 | //       imm: '00000010';
712 | //     },
713 | //   ]
714 | // >;
715 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
 1 | import {Context, EvalProgram} from './eval';
 2 | import {ParseProgram, ResolveLabels} from './parser';
 3 | 
 4 | export type InterpretProgram<
 5 |   T,
 6 |   StartingContext extends Context = {
 7 |     registers: {
 8 |       r0: '00000000';
 9 |       r1: '00000000';
10 |       r2: '00000000';
11 |       r3: '00000000';
12 |       r4: '00000000';
13 |       r5: '00000000';
14 |       r6: '00000000';
15 |       r7: '00000000';
16 |       sp: '11111111';
17 |       lr: '00000000';
18 |       pc: '00000000';
19 |     };
20 |     memory: {};
21 |   },
22 | > = EvalProgram<ResolveLabels<ParseProgram<T>>, StartingContext>;
23 | 


--------------------------------------------------------------------------------
/src/parser.ts:
--------------------------------------------------------------------------------
  1 | import {
  2 |   AddIInstr,
  3 |   Immediate,
  4 |   Register,
  5 |   AddRInstr,
  6 |   SubIInstr,
  7 |   SubRInstr,
  8 |   MovIInstr,
  9 |   MovRInstr,
 10 |   LabelInstr,
 11 |   _BranchInstr,
 12 |   _BranchIfZeroInstr,
 13 |   _BranchIfNotZeroInstr,
 14 |   _BranchLinkInstr,
 15 |   Indexed,
 16 |   _BranchIf,
 17 |   BranchLinkInstr,
 18 |   BranchIf,
 19 |   PushInstr,
 20 |   PopInstr,
 21 |   StrIInstr,
 22 |   StrRInstr,
 23 |   LdrIInstr,
 24 |   LdrRInstr,
 25 |   LSLIInstr,
 26 |   LSLRInstr,
 27 |   LSRRInstr,
 28 |   LSRIInstr,
 29 | } from './ast';
 30 | import {EvalAdd} from './eval';
 31 | import {Signature} from './utils';
 32 | 
 33 | type TrimLeftSpace<T> = T extends ` ${infer R}` ? TrimLeftSpace<R> : T;
 34 | type TrimRightSpace<T> = T extends `${infer R} ` ? TrimRightSpace<R> : T;
 35 | type TrimSpace<T> = TrimRightSpace<TrimLeftSpace<T>>;
 36 | 
 37 | type TrimLeft<T> = T extends `${' ' | '\n'}${infer R}` ? TrimLeft<R> : T;
 38 | type TrimRight<T> = T extends `${infer R}${' ' | '\n'}` ? TrimRight<R> : T;
 39 | type Trim<T> = TrimRight<TrimLeft<T>>;
 40 | 
 41 | type Split<T, SEP extends string> = T extends `${infer LINE}${SEP}${infer REST}`
 42 |   ? [LINE, ...Split<REST, SEP>]
 43 |   : [T];
 44 | 
 45 | type SplitLines<T> = Split<T, '\n'>;
 46 | 
 47 | type ParseAddIInstr<T> =
 48 |   T extends `ADD ${infer Rd extends Register}, ${infer Rn extends Register}, #${infer imm extends Immediate}`
 49 |     ? AddIInstr<Rd, Rn, imm>
 50 |     : never;
 51 | 
 52 | type ParseAddRInstr<T> =
 53 |   T extends `ADD ${infer Rd extends Register}, ${infer Rn extends Register}, ${infer Rm extends Register}`
 54 |     ? AddRInstr<Rd, Rn, Rm>
 55 |     : never;
 56 | 
 57 | type ParseSubIInstr<T> =
 58 |   T extends `SUB ${infer Rd extends Register}, ${infer Rn extends Register}, #${infer imm extends Immediate}`
 59 |     ? SubIInstr<Rd, Rn, imm>
 60 |     : never;
 61 | 
 62 | type ParseSubRInstr<T> =
 63 |   T extends `SUB ${infer Rd extends Register}, ${infer Rn extends Register}, ${infer Rm extends Register}`
 64 |     ? SubRInstr<Rd, Rn, Rm>
 65 |     : never;
 66 | 
 67 | type ParseMovIInstr<T> =
 68 |   T extends `MOV ${infer Rd extends Register}, #${infer imm extends Immediate}`
 69 |     ? MovIInstr<Rd, imm>
 70 |     : never;
 71 | 
 72 | type ParseMovRInstr<T> =
 73 |   T extends `MOV ${infer Rd extends Register}, ${infer Rm extends Register}`
 74 |     ? MovRInstr<Rd, Rm>
 75 |     : never;
 76 | 
 77 | type ParseLabel<T> = T extends `${infer name extends string}:`
 78 |   ? LabelInstr<name>
 79 |   : never;
 80 | 
 81 | type ParseBranch<T> = T extends `B ${infer label extends string}`
 82 |   ? _BranchInstr<label>
 83 |   : never;
 84 | 
 85 | type ParseBranchIfZero<T> =
 86 |   T extends `CBZ ${infer Rn extends Register}, ${infer label extends string}`
 87 |     ? _BranchIfZeroInstr<Rn, label>
 88 |     : never;
 89 | 
 90 | type ParseBranchIfNotZero<T> =
 91 |   T extends `CBNZ ${infer Rn extends Register}, ${infer label extends string}`
 92 |     ? _BranchIfNotZeroInstr<Rn, label>
 93 |     : never;
 94 | 
 95 | type ParseBranchLink<T> = T extends `BL ${infer label extends string}`
 96 |   ? _BranchLinkInstr<label>
 97 |   : never;
 98 | 
 99 | type ParseBranchR<T> = T extends `BR ${infer Rm extends Register}`
100 |   ? MovRInstr<'pc', Rm>
101 |   : never;
102 | 
103 | type ParsePush<T> = T extends `PUSH {${infer Rm extends Register}}`
104 |   ? PushInstr<Rm>
105 |   : never;
106 | 
107 | type ParsePop<T> = T extends `POP {${infer Rm extends Register}}`
108 |   ? PopInstr<Rm>
109 |   : never;
110 | 
111 | type ParseStrInstr<T> =
112 |   T extends `STR ${infer Rt extends Register}, [${infer address extends string}]`
113 |     ? address extends `${infer Rn extends Register}`
114 |       ? StrIInstr<Rt, Rn, '00000000'>
115 |       : address extends `${infer Rn extends Register}, #${infer imm extends Immediate}`
116 |       ? StrIInstr<Rt, Rn, imm>
117 |       : address extends `${infer Rn extends Register}, ${infer Rm extends Register}`
118 |       ? StrRInstr<Rt, Rn, Rm>
119 |       : never
120 |     : never;
121 | 
122 | type ParseLdrInstr<T> =
123 |   T extends `LDR ${infer Rt extends Register}, [${infer address extends string}]`
124 |     ? address extends `${infer Rn extends Register}`
125 |       ? LdrIInstr<Rt, Rn, '00000000'>
126 |       : address extends `${infer Rn extends Register}, #${infer imm extends Immediate}`
127 |       ? LdrIInstr<Rt, Rn, imm>
128 |       : address extends `${infer Rn extends Register}, ${infer Rm extends Register}`
129 |       ? LdrRInstr<Rt, Rn, Rm>
130 |       : never
131 |     : never;
132 | 
133 | type ParseLSLIInstr<T> =
134 |   T extends `LSL ${infer Rd extends Register}, ${infer Rm extends Register}, #${infer imm extends Immediate}`
135 |     ? LSLIInstr<Rd, Rm, imm>
136 |     : never;
137 | 
138 | type ParseLSLRInstr<T> =
139 |   T extends `LSL ${infer Rd extends Register}, ${infer Rm extends Register}, ${infer Rs extends Register}`
140 |     ? LSLRInstr<Rd, Rm, Rs>
141 |     : never;
142 | 
143 | type ParseLSRIInstr<T> =
144 |   T extends `LSR ${infer Rd extends Register}, ${infer Rm extends Register}, #${infer imm extends Immediate}`
145 |     ? LSRIInstr<Rd, Rm, imm>
146 |     : never;
147 | 
148 | type ParseLSRRInstr<T> =
149 |   T extends `LSR ${infer Rd extends Register}, ${infer Rm extends Register}, ${infer Rs extends Register}`
150 |     ? LSRRInstr<Rd, Rm, Rs>
151 |     : never;
152 | 
153 | type ParseInstr<T> =
154 |   | ParseAddIInstr<T>
155 |   | ParseAddRInstr<T>
156 |   | ParseSubIInstr<T>
157 |   | ParseSubRInstr<T>
158 |   | ParseMovIInstr<T>
159 |   | ParseMovRInstr<T>
160 |   | ParseLabel<T>
161 |   | ParseBranch<T>
162 |   | ParseBranchIfZero<T>
163 |   | ParseBranchLink<T>
164 |   | ParseBranchR<T>
165 |   | ParseBranchIfNotZero<T>
166 |   | ParsePush<T>
167 |   | ParsePop<T>
168 |   | ParseStrInstr<T>
169 |   | ParseLdrInstr<T>
170 |   | ParseLSLIInstr<T>
171 |   | ParseLSLRInstr<T>
172 |   | ParseLSRIInstr<T>
173 |   | ParseLSRRInstr<T>;
174 | 
175 | type ParseLine<T> = ParseInstr<TrimSpace<T>>;
176 | 
177 | type ParseLoop<T extends any[], idx extends string = '00000000'> = T extends [
178 |   infer Cur,
179 |   ...infer Rest,
180 | ]
181 |   ? [
182 |       Indexed<ParseLine<Cur>, idx>,
183 |       ...ParseLoop<Rest, EvalAdd<idx, '00000001'>['result']>,
184 |     ]
185 |   : [];
186 | 
187 | export type ParseProgram<T> = SplitLines<Trim<T>> extends infer R extends any[]
188 |   ? ParseLoop<R>
189 |   : never;
190 | 
191 | type Find<Instrs, Name> = {
192 |   [K in keyof Instrs]: Instrs[K] extends {
193 |     type: 'Label';
194 |     name: Name;
195 |     idx: string;
196 |   }
197 |     ? Instrs[K]
198 |     : never;
199 | };
200 | 
201 | type Clean<Arr> = {
202 |   [K in keyof Arr as K extends number ? K : never]: Arr[K];
203 | }[any];
204 | 
205 | type FindLabel<Instrs, PC> = Clean<Find<Instrs, PC>>;
206 | 
207 | export type ResolveLabels<Instrs> = {
208 |   [K in keyof Instrs]: Instrs[K] extends Indexed<
209 |     _BranchInstr<infer label>,
210 |     infer idx
211 |   >
212 |     ? Indexed<MovIInstr<'pc', FindLabel<Instrs, label>['idx']>, idx>
213 |     : // else if
214 |     Instrs[K] extends Indexed<_BranchLinkInstr<infer label>, infer idx>
215 |     ? Indexed<BranchLinkInstr<FindLabel<Instrs, label>['idx']>, idx>
216 |     : // else if
217 |     Instrs[K] extends Indexed<
218 |         _BranchIf<
219 |           infer type extends 'BranchIfZero' | 'BranchIfNotZero',
220 |           infer Rn,
221 |           infer label
222 |         >,
223 |         infer idx
224 |       >
225 |     ? Indexed<BranchIf<type, Rn, FindLabel<Instrs, label>['idx']>, idx>
226 |     : // else
227 |       Instrs[K];
228 | };
229 | 
230 | type Test = Signature<
231 |   ParseProgram<`
232 |     LSR r0, r1, r2
233 |   `>
234 | >;
235 | 


--------------------------------------------------------------------------------
/src/test/test.ts:
--------------------------------------------------------------------------------
 1 | import {InterpretProgram} from '..';
 2 | import {Signature} from '../utils';
 3 | 
 4 | // type Test = InterpretProgram<`
 5 | `
 6 |   B main
 7 |   sum_fibonacci:
 8 |     PUSH {lr}
 9 |     MOV r1, #00000000
10 |   sum_fibonacci_loop:
11 |     CBZ r0, sum_fibonacci_exit
12 | 
13 |     SUB r0, r0, #00000001
14 |     BL fibonacci
15 |   sum_fibonacci_exit:
16 |     POP {pc}
17 |   fibonacci:
18 |     PUSH {lr}
19 |     SUB r1, r0, #00000001
20 |     CBZ r1, fibonacci_base_case
21 |     SUB r1, r0, #00000010
22 |     CBZ r1, fibonacci_base_case
23 | 
24 |     POP {pc}
25 |   fibonacci_base_case:
26 |     MOV r0, #00000001
27 | 
28 |   main:
29 |     MOV r0, #00000100
30 |     BL sum_fibonacci
31 | `;
32 | // `>;
33 | 
34 | type Program = InterpretProgram<`
35 |   B main
36 |   fibonacci:
37 |     PUSH {lr}
38 |     MOV r4, r0
39 |     SUB r1, r0, #00000001
40 |     CBZ r1, fibonacci_base_case
41 |     SUB r1, r0, #00000010
42 |     CBZ r1, fibonacci_base_case
43 |     SUB r0, r4, #00000001
44 |     PUSH {r4}
45 |     BL fibonacci
46 |     POP {r4}
47 |     MOV r2, r0
48 |     SUB r0, r4, #00000010
49 |     PUSH {r4}
50 |     PUSH {r2}
51 |     BL fibonacci
52 |     POP {r2}
53 |     POP {r4}
54 |     MOV r3, r0
55 |     ADD r0, r2, r3
56 |     POP {pc}
57 |   fibonacci_base_case:
58 |     MOV r0, #00000001
59 |     POP {pc}
60 |   main:
61 |     MOV r0, #00001000
62 |     BL fibonacci
63 | `>;
64 | 
65 | type r0 = Program['registers']['r0'];
66 | //   ^?
67 | 
68 | 
69 | 
70 | 
71 | 
72 | 
73 | // type r1 = Test['registers']['r1'];
74 | // //   ^?
75 | // type r2 = Test['registers']['r2'];
76 | // //   ^?
77 | // type r3 = Test['registers']['r3'];
78 | // //   ^?
79 | // // type r4 = Test['registers']['r4'];
80 | // // //   ^?
81 | // type r4 = Test['registers']['r4'];
82 | // //   ^?
83 | // type mem = Signature<Test['memory']>;
84 | //   ^?
85 | 


--------------------------------------------------------------------------------
/src/utils.ts:
--------------------------------------------------------------------------------
 1 | export type Signature<T> = T extends Record<any, any>
 2 |   ? {[K in keyof T]: Signature<T[K]>}
 3 |   : T;
 4 | 
 5 | type Tail<T extends any[]> = T extends [any, ...infer U] ? U : never;
 6 | // type TailN<T extends any[], N extends number> = N extends 0
 7 | //   ? T
 8 | //   : TailN<Tail<T>, Subtract<N, 1>>;
 9 | 
10 | export type Overwrite<
11 |   A extends Record<string, any>,
12 |   B extends Record<string, any>,
13 | > = Omit<A, keyof B> & B;


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "es5",
 4 |     "module": "commonjs",
 5 |     "outDir": "dist",
 6 |     "strict": true,
 7 |     "noImplicitAny": false,
 8 |     "esModuleInterop": true,
 9 |     "allowJs": true,
10 |     "skipLibCheck": true,
11 |     "downlevelIteration": true,
12 |     "moduleDetection": "force"
13 |   },
14 |   "include": ["src"]
15 | }


--------------------------------------------------------------------------------
/yarn.lock:
--------------------------------------------------------------------------------
 1 | # THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
 2 | # yarn lockfile v1
 3 | 
 4 | 
 5 | prettier@^2.7.1:
 6 |   version "2.7.1"
 7 |   resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.7.1.tgz#e235806850d057f97bb08368a4f7d899f7760c64"
 8 |   integrity sha512-ujppO+MkdPqoVINuDFDRLClm7D78qbDt0/NR+wp5FqEZOoTNAjPHWj17QRhu7geIHJfcNhRk1XVQmF8Bp3ye+g==
 9 | 
10 | typescript@^4.8.4:
11 |   version "4.8.4"
12 |   resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.8.4.tgz#c464abca159669597be5f96b8943500b238e60e6"
13 |   integrity sha512-QCh+85mCy+h0IGff8r5XWzOVSbBO+KfeYrMQh7NJ58QujwcE22u+NUSmUxqF+un70P9GXKxa2HCNiTTMJknyjQ==
14 | 


--------------------------------------------------------------------------------