Абстракт
Данная статья является продолжением предыдущей статьи о TypeScript Native (AOT) Compiler(далее tsc) https://habr.com/ru/post/581308/. В данной статье мне хотелось бы остановиться на обзоре возможностей компилятора, а также использование компилятора из command line(коммандной строки). При написании примеров я буду подразумевать что у читателя есть минимальное понимание как пользоваться компиляторами в командной строке и наличие некоторого опыта работы с LLVM
Использование tsc
Для получения краткой справки об опциях программы нужно выполнить следующую команду
QC:\dev>tsc.exe --help
Основана опция, которая нам потребуется это "--emit=<value>". Эта опция важна для генерировал файлов в разных форматах вывода, таких как "obj", LLVM IR и т.д.
Генерирование OBJ (объектный файл)
Предположим, у нас есть файл example1.ts который содержит простую программу
function main() { print("Hello World!"); }
и мы хотим получить obj. файл, то достаточно выполнить следующую команду
C:\dev>tsc.exe --emit=jit -nogc -dump-object-file -object-filename=out.o example.ts
Данная команда скомпилирует файл example.ts и сохранит OBJ в out.o. Далее сгенерированный файл можно использовать для получения исполняемого файла. Например, используя lld
Генерирование EXE (выполняемого файла)
Берем out.o из предыдущего примера и выполняем следующую команду
c:\LLVM\lld.exe -flavor link out.o /libpath:%LIBPATH% /libpath:%SDKPATH% /libpath:%UCRTPATH% msvcrt.lib ucrt.lib kernel32.lib user32.lib.lib
Альтернативный путь генерирования EXE(выполняемого файла)
C:\dev>tsc.exe --emit=llvm example1.ts 2>example1.ll C:\LLVM\llc.exe --filetype=obj -o=out.o example1.ll C:\LLVM\lld.exe -flavor link out.o
когда будете выполнять последний шаг то может понадобиться указать нужные библиотеки для C чтобы скомпилировать в .Exe файл (в конце статьи я приведу свои batch файлы для более детальной информации по компиляции)
Выполнение TypeScript кода без компиляции
Если нам нужно только посмотреть результат работы программы, то достаточно ввести следующую команду
C:\dev>tsc.exe --jit example1.ts
Шаги компилятора для генерирования исполняемого кода
После того как мы ознакомились с базовыми командами программы для командной строки, предлагаю посмотреть, как tsc компилирует программу example1.ts
C:\dev>tsc.exe --emit=mlir example1.ts
После чего мы получим вывод в MLIR (больше о MLIR тут https://mlir.llvm.org/)
module @"1.ts" { ts.Func @main () -> () { "ts.Entry"() : () -> () %0 = ts.UnresolvedSymbolRef {identifier = @print} : none %1 = ts.Constant {value = "Hello World!"} : !ts.string ts.Print(%1) : !ts.string "ts.Exit"() : () -> () } }
TypeScript файл будет преобразован в псевдоязык, который описывает логику программы. Этот промежуточный шаг позволяет компилятору проводить анализ кода и выполнять некоторую оптимизацию на данном этапе.
Что бы получить обработанной код нужно ввести следующую команду
C:\dev>tsc.exe --emit=mlir-affine example1.ts
Мы получим следующий листинг.
module @"example1.ts" { ts.Func @main () -> () { %0 = ts.Constant {value = "Hello World!"} : !ts.string ts.Print(%0) : !ts.string ts.ReturnInternal } }
Что нам говорит следующий псевдокод, что есть программа "example1.ts" которая имеет функцию "@main" которая в свою очередь загружает константу в параметр псевдокоманды "Print" и выходит из функции. Как не трудно догадаться, что при выполнении данной программы, мы увидим нашу строку вывода "Hello World!".
Дальнейшим шагом хотелось бы посмотреть выполняемый код близкий к машинному коду. Для этого мы выполним следующую команду
C:\dev>tsc.exe --emit=mlir-llvm example1.ts
И получаем результат выполнения
module @"1.ts" { llvm.func @puts(!llvm.ptr<i8>) -> i32 llvm.mlir.global internal constant @s_10092224619179044402("Hello World!\00") llvm.func @main() { %0 = llvm.mlir.addressof @s_10092224619179044402 : !llvm.ptr<array<13 x i8>> %1 = llvm.mlir.constant(0 : i64) : i64 %2 = llvm.getelementptr %0[%1, %1] : (!llvm.ptr<array<13 x i8>>, i64, i64) -> !llvm.ptr<i8> %3 = llvm.call @puts(%2) : (!llvm.ptr<i8>) -> i32 llvm.return } }
Но этого еще мало, чтобы получить файл, который мы может "скормить" llс для получения obj-файла нам нужно выполнить команду
C:\dev>tsc.exe --emit=llvm example1.ts
Получаем вывод
; ModuleID = 'LLVMDialectModule' source_filename = "LLVMDialectModule" target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target triple = "x86_64-pc-windows-msvc" @s_10092224619179044402 = internal constant [13 x i8] c"Hello World!\00" declare i32 @puts(i8*) define void @main() { %1 = call i32 @puts(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @s_10092224619179044402, i64 0, i64 0)), !d ret void }
Только что мы прошлись по основным этапам компиляции программы. Хотелось бы добавить, что шаги по оптимизации обычно выполняются на этапе, когда мы выполнили команду с параметром "--emit=mlir-affine"
Далее давайте посмотрим какой код может компилировать программа (я выбрал только более-менее интересные примеры)
Параметры функций по умолчанию
В следующем куске кода мы посмотрим, как можно использовать параметры по умолчанию
function defaultArgs(x: number, y = 3, z = 7) { return x + y + z; }
И вариант, когда значение по умолчанию указывать не нужно
function optargs(x: number, y?: number, z?: number) { if (y == undefined) y = 0; return x + y; }
В первом варианте параметры "y" и "z" указаны как параметры со значением, а во втором параметры "y" и "z" указаны как опциональные параметры. Заметьте, что в первом случае мы не указывает тип параметра т.к. тип параметра определяется из значения по умолчанию.
Вызов данных функций будет выглядеть следующим образом
defaultArgs(1); defaultArgs(1, 4); defaultArgs(1, 4, 8); optargs(1); optargs(1, 2); optargs(1, 2, 3);
Полный пример кода (обратите внимание что декларировать функции можно в любом порядке)
function defaultArgs(x: number, y = 3, z = 7) { return x + y + z; } function main() { defaultArgs(1); defaultArgs(1, 4); defaultArgs(1, 4, 8); optargs(1); optargs(1, 2); optargs(1, 2, 3); } function optargs(x: number, y?: number, z?: number) { if (y == undefined) y = 0; return x + y; }
И получаемый псевдокод, из которого будет сгенерирован выполняемый файл (для этого нужно выполнить команду tsc --emit=mlir example1.ts)
module @"C:\\temp\\1.ts" { ts.Func @defaultArgs (!ts.number, !ts.optional<i32>, !ts.optional<i32>) -> !ts.number {sym_visibility = "private"} { ^bb0(%arg0: !ts.number, %arg1: !ts.optional<i32>, %arg2: !ts.optional<i32>): // no predecessors %0 = "ts.Entry"() : () -> !ts.ref<!ts.number> %1 = "ts.Param"(%arg0) : (!ts.number) -> !ts.ref<!ts.number> %2 = "ts.ParamOpt"(%arg1) ( { %11 = ts.Constant {value = 3 : i32} : i32 ts.DefaultValue %11 : i32 }) : (!ts.optional<i32>) -> !ts.ref<i32> %3 = "ts.ParamOpt"(%arg2) ( { %11 = ts.Constant {value = 7 : i32} : i32 ts.DefaultValue %11 : i32 }) : (!ts.optional<i32>) -> !ts.ref<i32> %4 = ts.Load(%1) : !ts.ref<!ts.number> -> !ts.number %5 = ts.Load(%2) : !ts.ref<i32> -> i32 %6 = ts.Cast %5 : i32 to !ts.number %7 = ts.ArithmeticBinary %4(39) %6 : !ts.number, !ts.number -> !ts.number %8 = ts.Load(%3) : !ts.ref<i32> -> i32 %9 = ts.Cast %8 : i32 to !ts.number %10 = ts.ArithmeticBinary %7(39) %9 : !ts.number, !ts.number -> !ts.number "ts.ReturnVal"(%10, %0) : (!ts.number, !ts.ref<!ts.number>) -> () "ts.Exit"() : () -> () } ts.Func @main () -> () { "ts.Entry"() : () -> () %0 = ts.SymbolRef {identifier = @defaultArgs} : (!ts.number, !ts.optional<i32>, !ts.optional<i32>) -> !ts.number %1 = ts.Constant {value = 1 : i32} : i32 %2 = ts.Cast %1 : i32 to !ts.number %3 = ts.Undef : !ts.optional<i32> %4 = ts.Undef : !ts.optional<i32> %5 = ts.CallIndirect %0(%2, %3, %4) : (!ts.number, !ts.optional<i32>, !ts.optional<i32>) -> !ts.number %6 = ts.SymbolRef {identifier = @defaultArgs} : (!ts.number, !ts.optional<i32>, !ts.optional<i32>) -> !ts.number %7 = ts.Constant {value = 1 : i32} : i32 %8 = ts.Cast %7 : i32 to !ts.number %9 = ts.Constant {value = 4 : i32} : i32 %10 = ts.Cast %9 : i32 to !ts.optional<i32> %11 = ts.Undef : !ts.optional<i32> %12 = ts.CallIndirect %6(%8, %10, %11) : (!ts.number, !ts.optional<i32>, !ts.optional<i32>) -> !ts.number %13 = ts.SymbolRef {identifier = @defaultArgs} : (!ts.number, !ts.optional<i32>, !ts.optional<i32>) -> !ts.number %14 = ts.Constant {value = 1 : i32} : i32 %15 = ts.Cast %14 : i32 to !ts.number %16 = ts.Constant {value = 4 : i32} : i32 %17 = ts.Cast %16 : i32 to !ts.optional<i32> %18 = ts.Constant {value = 8 : i32} : i32 %19 = ts.Cast %18 : i32 to !ts.optional<i32> %20 = ts.CallIndirect %13(%15, %17, %19) : (!ts.number, !ts.optional<i32>, !ts.optional<i32>) -> !ts.number %21 = ts.SymbolRef {identifier = @optargs} : (!ts.number, !ts.optional<!ts.number>, !ts.optional<!ts.number>) -> !ts.number %22 = ts.Constant {value = 1 : i32} : i32 %23 = ts.Cast %22 : i32 to !ts.number %24 = ts.Undef : !ts.optional<!ts.number> %25 = ts.Undef : !ts.optional<!ts.number> %26 = ts.CallIndirect %21(%23, %24, %25) : (!ts.number, !ts.optional<!ts.number>, !ts.optional<!ts.number>) -> !ts.number %27 = ts.SymbolRef {identifier = @optargs} : (!ts.number, !ts.optional<!ts.number>, !ts.optional<!ts.number>) -> !ts.number %28 = ts.Constant {value = 1 : i32} : i32 %29 = ts.Cast %28 : i32 to !ts.number %30 = ts.Constant {value = 2 : i32} : i32 %31 = ts.Cast %30 : i32 to !ts.optional<!ts.number> %32 = ts.Undef : !ts.optional<!ts.number> %33 = ts.CallIndirect %27(%29, %31, %32) : (!ts.number, !ts.optional<!ts.number>, !ts.optional<!ts.number>) -> !ts.number %34 = ts.SymbolRef {identifier = @optargs} : (!ts.number, !ts.optional<!ts.number>, !ts.optional<!ts.number>) -> !ts.number %35 = ts.Constant {value = 1 : i32} : i32 %36 = ts.Cast %35 : i32 to !ts.number %37 = ts.Constant {value = 2 : i32} : i32 %38 = ts.Cast %37 : i32 to !ts.optional<!ts.number> %39 = ts.Constant {value = 3 : i32} : i32 %40 = ts.Cast %39 : i32 to !ts.optional<!ts.number> %41 = ts.CallIndirect %34(%36, %38, %40) : (!ts.number, !ts.optional<!ts.number>, !ts.optional<!ts.number>) -> !ts.number "ts.Exit"() : () -> () } ts.Func @optargs (!ts.number, !ts.optional<!ts.number>, !ts.optional<!ts.number>) -> !ts.number {sym_visibility = "private"} { ^bb0(%arg0: !ts.number, %arg1: !ts.optional<!ts.number>, %arg2: !ts.optional<!ts.number>): // no predecessors %0 = "ts.Entry"() : () -> !ts.ref<!ts.number> %1 = "ts.Param"(%arg0) : (!ts.number) -> !ts.ref<!ts.number> %2 = "ts.Param"(%arg1) : (!ts.optional<!ts.number>) -> !ts.ref<!ts.optional<!ts.number>> %3 = "ts.Param"(%arg2) : (!ts.optional<!ts.number>) -> !ts.ref<!ts.optional<!ts.number>> %4 = ts.Load(%2) : !ts.ref<!ts.optional<!ts.number>> -> !ts.optional<!ts.number> %5 = ts.Undef : !ts.optional<!ts.undef_ph> %6 = ts.LogicalBinary %4(34) %5 : !ts.optional<!ts.number>, !ts.optional<!ts.undef_ph> -> !ts.boolean "ts.If"(%6) ( { %11 = ts.Load(%2) : !ts.ref<!ts.optional<!ts.number>> -> !ts.optional<!ts.number> %12 = ts.Constant {value = 0 : i32} : i32 %13 = ts.Cast %12 : i32 to !ts.optional<!ts.number> ts.Store %13, %2 : !ts.optional<!ts.number> -> !ts.ref<!ts.optional<!ts.number>> "ts.Result"() : () -> () }, { }) : (!ts.boolean) -> () %7 = ts.Load(%1) : !ts.ref<!ts.number> -> !ts.number %8 = ts.Load(%2) : !ts.ref<!ts.optional<!ts.number>> -> !ts.optional<!ts.number> %9 = ts.Cast %8 : !ts.optional<!ts.number> to !ts.number %10 = ts.ArithmeticBinary %7(39) %9 : !ts.number, !ts.number -> !ts.number "ts.ReturnVal"(%10, %0) : (!ts.number, !ts.ref<!ts.number>) -> () "ts.Exit"() : () -> () } }
Данный код содержит части, которые могут быть упрощены на стадии оптимизации. Давайте посмотрим, что получиться на стадии оптимизации (для этого нам нужно выполнить команду tsc --emit=mlir-affine example1.ts)
module @"C:\\temp\\1.ts" { ts.Func @defaultArgs (!ts.number, !ts.optional<i32>, !ts.optional<i32>) -> !ts.number {sym_visibility = "private"} { ^bb0(%arg0: !ts.number, %arg1: !ts.optional<i32>, %arg2: !ts.optional<i32>): // no predecessors %c7_i32 = constant 7 : i32 %c3_i32 = constant 3 : i32 %0 = ts.Variable() {false} : -> !ts.ref<!ts.number> %1 = ts.Variable(%arg0) {false} : !ts.number -> !ts.ref<!ts.number> %2 = "ts.HasValue"(%arg1) : (!ts.optional<i32>) -> !ts.boolean %3 = ts.Cast %2 : !ts.boolean to i1 cond_br %3, ^bb1, ^bb2(%c3_i32 : i32) ^bb1: // pred: ^bb0 %4 = "ts.Value"(%arg1) : (!ts.optional<i32>) -> i32 br ^bb2(%4 : i32) ^bb2(%5: i32): // 2 preds: ^bb0, ^bb1 %6 = ts.Variable(%5) {false} : i32 -> !ts.ref<i32> %7 = "ts.HasValue"(%arg2) : (!ts.optional<i32>) -> !ts.boolean %8 = ts.Cast %7 : !ts.boolean to i1 cond_br %8, ^bb3, ^bb4(%c7_i32 : i32) ^bb3: // pred: ^bb2 %9 = "ts.Value"(%arg2) : (!ts.optional<i32>) -> i32 br ^bb4(%9 : i32) ^bb4(%10: i32): // 2 preds: ^bb2, ^bb3 %11 = ts.Variable(%10) {false} : i32 -> !ts.ref<i32> %12 = ts.Load(%1) : !ts.ref<!ts.number> -> !ts.number %13 = ts.Load(%6) : !ts.ref<i32> -> i32 %14 = ts.Cast %13 : i32 to !ts.number %15 = ts.ArithmeticBinary %12(39) %14 : !ts.number, !ts.number -> !ts.number %16 = ts.Load(%11) : !ts.ref<i32> -> i32 %17 = ts.Cast %16 : i32 to !ts.number %18 = ts.ArithmeticBinary %15(39) %17 : !ts.number, !ts.number -> !ts.number ts.Store %18, %0 : !ts.number -> !ts.ref<!ts.number> %19 = ts.Load(%0) : !ts.ref<!ts.number> -> !ts.number ts.ReturnInternal %19 : !ts.number } ts.Func @main () -> () { %c3_i32 = constant 3 : i32 %c2_i32 = constant 2 : i32 %c8_i32 = constant 8 : i32 %c4_i32 = constant 4 : i32 %c1_i32 = constant 1 : i32 %0 = ts.Cast %c1_i32 : i32 to !ts.number %1 = ts.Undef : !ts.optional<i32> %2 = ts.Undef : !ts.optional<i32> %3 = ts.CallInternal @defaultArgs(%0, %1, %2) : (!ts.number, !ts.optional<i32>, !ts.optional<i32>) -> !ts.number %4 = ts.Cast %c4_i32 : i32 to !ts.optional<i32> %5 = ts.Undef : !ts.optional<i32> %6 = ts.CallInternal @defaultArgs(%0, %4, %5) : (!ts.number, !ts.optional<i32>, !ts.optional<i32>) -> !ts.number %7 = ts.Cast %c8_i32 : i32 to !ts.optional<i32> %8 = ts.CallInternal @defaultArgs(%0, %4, %7) : (!ts.number, !ts.optional<i32>, !ts.optional<i32>) -> !ts.number %9 = ts.Undef : !ts.optional<!ts.number> %10 = ts.Undef : !ts.optional<!ts.number> %11 = ts.CallInternal @optargs(%0, %9, %10) : (!ts.number, !ts.optional<!ts.number>, !ts.optional<!ts.number>) -> !ts.number %12 = ts.Cast %c2_i32 : i32 to !ts.optional<!ts.number> %13 = ts.Undef : !ts.optional<!ts.number> %14 = ts.CallInternal @optargs(%0, %12, %13) : (!ts.number, !ts.optional<!ts.number>, !ts.optional<!ts.number>) -> !ts.number %15 = ts.Cast %c3_i32 : i32 to !ts.optional<!ts.number> %16 = ts.CallInternal @optargs(%0, %12, %15) : (!ts.number, !ts.optional<!ts.number>, !ts.optional<!ts.number>) -> !ts.number ts.ReturnInternal } ts.Func @optargs (!ts.number, !ts.optional<!ts.number>, !ts.optional<!ts.number>) -> !ts.number {sym_visibility = "private"} { ^bb0(%arg0: !ts.number, %arg1: !ts.optional<!ts.number>, %arg2: !ts.optional<!ts.number>): // no predecessors %c0_i32 = constant 0 : i32 %0 = ts.Variable() {false} : -> !ts.ref<!ts.number> %1 = ts.Variable(%arg0) {false} : !ts.number -> !ts.ref<!ts.number> %2 = ts.Variable(%arg1) {false} : !ts.optional<!ts.number> -> !ts.ref<!ts.optional<!ts.number>> %3 = ts.Variable(%arg2) {false} : !ts.optional<!ts.number> -> !ts.ref<!ts.optional<!ts.number>> %4 = ts.Load(%2) : !ts.ref<!ts.optional<!ts.number>> -> !ts.optional<!ts.number> %5 = ts.Undef : !ts.optional<!ts.undef_ph> %6 = ts.LogicalBinary %4(34) %5 : !ts.optional<!ts.number>, !ts.optional<!ts.undef_ph> -> !ts.boolean %7 = ts.Cast %6 : !ts.boolean to i1 cond_br %7, ^bb1, ^bb2 ^bb1: // pred: ^bb0 %8 = ts.Cast %c0_i32 : i32 to !ts.optional<!ts.number> ts.Store %8, %2 : !ts.optional<!ts.number> -> !ts.ref<!ts.optional<!ts.number>> br ^bb2 ^bb2: // 2 preds: ^bb0, ^bb1 %9 = ts.Load(%1) : !ts.ref<!ts.number> -> !ts.number %10 = ts.Load(%2) : !ts.ref<!ts.optional<!ts.number>> -> !ts.optional<!ts.number> %11 = ts.Cast %10 : !ts.optional<!ts.number> to !ts.number %12 = ts.ArithmeticBinary %9(39) %11 : !ts.number, !ts.number -> !ts.number ts.Store %12, %0 : !ts.number -> !ts.ref<!ts.number> %13 = ts.Load(%0) : !ts.ref<!ts.number> -> !ts.number ts.ReturnInternal %13 : !ts.number } }
И наконец, чтобы посмотреть, как работает данный код нужно запустить команду tsc --emit=jit -nogc example1.ts
В дальнейшем все листинги приводить буду по минимуму из-за большого их объёма.
Итерация массивов
В следующем коде посмотрим, как компилятор может генерировать код для обхода массивов
function main() { const trees = [[1], [2, 3], [4, 5, 6]]; for (const a of trees) { print("array"); for (const b of a) { print(b); } } print("done."); }
Результат работы (tsc --emit=jit -nogc example1.ts)
C:\>tsc.exe --emit=jit -nogc example1.ts array 1 array 2 3 array 4 5 6 done.
Давайте посмотрим на сгенерированный псевдокод (tsc --emit=mlir example1.ts)
module @"C:\\temp\\1.ts" { ts.Func @main () -> () { "ts.Entry"() : () -> () %0 = ts.Constant {value = 1 : i32} : i32 %1 = ts.Constant {value = [1 : i32]} : !ts.const_array<i32,1> %2 = ts.Constant {value = 2 : i32} : i32 %3 = ts.Constant {value = 3 : i32} : i32 %4 = ts.Constant {value = [2 : i32, 3 : i32]} : !ts.const_array<i32,2> %5 = ts.Constant {value = 4 : i32} : i32 %6 = ts.Constant {value = 5 : i32} : i32 %7 = ts.Constant {value = 6 : i32} : i32 %8 = ts.Constant {value = [4 : i32, 5 : i32, 6 : i32]} : !ts.const_array<i32,3> %9 = ts.Constant {value = [[1 : i32], [2 : i32, 3 : i32], [4 : i32, 5 : i32, 6 : i32]]} : !ts.const_array<!ts.array<i32>,3> %10 = ts.Constant {value = 0 : i32} : i32 %11 = ts.Variable(%10) {false} : i32 -> !ts.ref<i32> ts.For : -> ( { %14 = ts.Load(%11) : !ts.ref<i32> -> i32 %15 = ts.Constant {value = 3 : i32} : i32 %16 = ts.LogicalBinary %14(29) %15 : i32, i32 -> !ts.boolean ts.Condition(%16) : }, { %14 = ts.Load(%11) : !ts.ref<i32> -> i32 %15 = ts.PrefixUnary %14(45) : i32 -> i32 "ts.Result"() : () -> () }) { %14 = ts.Load(%11) : !ts.ref<i32> -> i32 %15 = ts.ElementRef %9[%14] : !ts.const_array<!ts.array<i32>,3>[i32] -> !ts.ref<!ts.array<i32>> %16 = ts.Load(%15) : !ts.ref<!ts.array<i32>> -> !ts.array<i32> %17 = ts.UnresolvedSymbolRef {identifier = @print} : none %18 = ts.Constant {value = "array"} : !ts.string ts.Print(%18) : !ts.string %19 = ts.Constant {value = 0 : i32} : i32 %20 = ts.Variable(%19) {false} : i32 -> !ts.ref<i32> ts.For : -> ( { %21 = ts.Load(%20) : !ts.ref<i32> -> i32 %22 = ts.Load(%15) : !ts.ref<!ts.array<i32>> -> !ts.array<i32> %23 = "ts.LengthOf"(%22) : (!ts.array<i32>) -> i32 %24 = ts.LogicalBinary %21(29) %23 : i32, i32 -> !ts.boolean ts.Condition(%24) : }, { %21 = ts.Load(%20) : !ts.ref<i32> -> i32 %22 = ts.PrefixUnary %21(45) : i32 -> i32 "ts.Result"() : () -> () }) { %21 = ts.Load(%20) : !ts.ref<i32> -> i32 %22 = ts.Load(%15) : !ts.ref<!ts.array<i32>> -> !ts.array<i32> %23 = ts.ElementRef %22[%21] : !ts.array<i32>[i32] -> !ts.ref<i32> %24 = ts.Load(%23) : !ts.ref<i32> -> i32 %25 = ts.UnresolvedSymbolRef {identifier = @print} : none ts.Print(%24) : i32 "ts.Result"() : () -> () } "ts.Result"() : () -> () } %12 = ts.UnresolvedSymbolRef {identifier = @print} : none %13 = ts.Constant {value = "done."} : !ts.string ts.Print(%13) : !ts.string "ts.Exit"() : () -> () } }
Захват переменных функциями
function func_in_object(a: number | undefined) { const s = { f() { assert(a == 11); print(a); }, }; s.f(); } function main() { func_in_object(11); print("done."); }
Результат работы:
C:\temp>C:\tsc.exe --emit=jit -nogc example1.ts 11 done.
В данном примере, передается параметр "a" с типом "number | undefined". Это значит, что, "а" может быть опциональный т.е. аналог "a?: number". Далее этот параметр будет захвачен в функции "f()" которая будет принадлежать абстрактному объекту "s"
И давайте посмотрим какой псевдокод будет сгенерирован в данном примере
module @"C:\\temp\\1.ts" { ts.Func @__uf14725333033948923702 (!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> () {arg_attrs = [{ts.nest}, {}], sym_visibility = "private", ts.nest} { ^bb0(%arg0: !ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, %arg1: !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>): // no predecessors "ts.Entry"() : () -> () %0 = "ts.Param"(%arg1) : (!ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> !ts.ref<!ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>> %1 = ts.PropertyRef %arg0<0> : !ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>> -> !ts.ref<!ts.ref<!ts.optional<!ts.number>>> %2 = ts.Load(%1) : !ts.ref<!ts.ref<!ts.optional<!ts.number>>> -> !ts.ref<!ts.optional<!ts.number>> %3 = ts.UnresolvedSymbolRef {identifier = @assert} : none %4 = ts.Load(%2) : !ts.ref<!ts.optional<!ts.number>> -> !ts.optional<!ts.number> %5 = ts.Constant {value = 11 : i32} : i32 %6 = ts.Cast %4 : !ts.optional<!ts.number> to i32 %7 = ts.LogicalBinary %6(34) %5 : i32, i32 -> !ts.boolean ts.Assert %7, "assert" %8 = ts.UnresolvedSymbolRef {identifier = @print} : none %9 = ts.Load(%2) : !ts.ref<!ts.optional<!ts.number>> -> !ts.optional<!ts.number> ts.Print(%9) : !ts.optional<!ts.number> "ts.Exit"() : () -> () } ts.Func @func_in_object (!ts.optional<!ts.number>) -> () {sym_visibility = "private"} { ^bb0(%arg0: !ts.optional<!ts.number>): // no predecessors "ts.Entry"() : () -> () %0 = "ts.Param"(%arg0) : (!ts.optional<!ts.number>) -> !ts.ref<!ts.optional<!ts.number>> %1 = ts.SymbolRef {identifier = @__uf14725333033948923702} : (!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> () %2 = ts.Load(%0) : !ts.ref<!ts.optional<!ts.number>> -> !ts.optional<!ts.number> %3 = "ts.Capture"(%0) : (!ts.ref<!ts.optional<!ts.number>>) -> !ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>> %4 = "ts.Trampoline"(%1, %3) {allocInHeap = false} : ((!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> (), !ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>) -> ((!ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()) %5 = ts.Constant {value = [unit]} : !ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()}> %6 = ts.Variable(%5) {false} : !ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()}> -> !ts.ref<!ts.tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()}>> %7 = ts.PropertyRef %6<0> : !ts.ref<!ts.tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()}>> -> !ts.bound_ref<(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()> %8 = ts.Load(%7) : !ts.bound_ref<(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()> -> !ts.this_func<(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>,!ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()> %9 = ts.Cast %4 : (!ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> () to (!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> () ts.Store %9, %7 : (!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> () -> !ts.bound_ref<(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()> %10 = ts.Load(%6) : !ts.ref<!ts.tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()}>> -> !ts.tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()}> %11 = ts.PropertyRef %6<0> : !ts.ref<!ts.tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()}>> -> !ts.bound_ref<(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()> %12 = ts.Load(%11) : !ts.bound_ref<(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()> -> !ts.this_func<(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>,!ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()> %13 = ts.GetThis %12 : !ts.this_func<(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>,!ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()> -> !ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>> %14 = ts.GetMethod %12 : !ts.this_func<(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>,!ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> ()> -> (!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> () %15 = ts.Undef : !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>> ts.CallIndirect %14(%13, %15) : (!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.object<!ts.const_tuple<{"f",(!ts.ref<!ts.tuple<{"a",!ts.ref<!ts.optional<!ts.number>>}>>, !ts.opaque) -> ()}>>) -> () "ts.Exit"() : () -> () } ts.Func @main () -> () { "ts.Entry"() : () -> () %0 = ts.SymbolRef {identifier = @func_in_object} : (!ts.optional<!ts.number>) -> () %1 = ts.Constant {value = 11 : i32} : i32 %2 = ts.Cast %1 : i32 to !ts.optional<!ts.number> ts.CallIndirect %0(%2) : (!ts.optional<!ts.number>) -> () %3 = ts.UnresolvedSymbolRef {identifier = @print} : none %4 = ts.Constant {value = "done."} : !ts.string ts.Print(%4) : !ts.string "ts.Exit"() : () -> () } }
Интересующие строки, где псевдокоманды, которые нас интересуют, имеют имена "ts.Capture" и "ts.Trampoline". Первая команда захватывает ссылку на объект или значение, а вторая команда создает виртуальную функцию, которая будет получать объект, содержащий ссылку на переменную "а"
Интерфейсы по требованию
В этом параграфе мы рассмотрим пример, который покажет, как можно создавать интерфейсы из классов, которые не задекларированы на уровне класса
class S { // нам не нужно указывать наличие интерфейса в декларации // class S implements IPrn print() { print("Hello World"); } } interface IPrn { print(); } function run(iface: IPrn) { iface.print(); } function main() { const s = new S(); let iface = <IPrn>s; iface.print(); run(s); print("done."); }
В этом коде мы создаем экземпляр интерфейса "IPrn" который не объявлен в классе "S" как это обычно требуется в С++
Использование yield в генераторах
Пример использования "yield".
function* foo() { let i = 1; while (i < 3) { yield ++i; } } function main() { for (const o of foo3()) { print(o); } }
Результат выполнения кода
C:\>tsc.exe --emit=jit -nogc example1.ts 2 3
Примеры с использованием async/await
В этом параграфе я покажу два примера с async/await и for await
async function f(a = 1) { return a; } function main() { const v = await f(2); print(v); print("done."); }
Давайте посмотрим на сгенерированный псевдокод
module @"C:\\temp\\1.ts" { ts.Func @f (!ts.optional<i32>) -> i32 {sym_visibility = "private"} { ^bb0(%arg0: !ts.optional<i32>): // no predecessors %0 = "ts.Entry"() : () -> !ts.ref<i32> %1 = "ts.ParamOpt"(%arg0) ( { %3 = ts.Constant {value = 1 : i32} : i32 ts.DefaultValue %3 : i32 }) : (!ts.optional<i32>) -> !ts.ref<i32> %2 = ts.Load(%1) : !ts.ref<i32> -> i32 "ts.ReturnVal"(%2, %0) : (i32, !ts.ref<i32>) -> () "ts.Exit"() : () -> () } ts.Func @main () -> () { "ts.Entry"() : () -> () %token, %results = async.execute -> !async.value<i32> { %4 = ts.SymbolRef {identifier = @f} : (!ts.optional<i32>) -> i32 %5 = ts.Constant {value = 2 : i32} : i32 %6 = ts.Cast %5 : i32 to !ts.optional<i32> %7 = ts.CallIndirect %4(%6) : (!ts.optional<i32>) -> i32 async.yield %7 : i32 } %0 = async.await %results : !async.value<i32> %1 = ts.UnresolvedSymbolRef {identifier = @print} : none ts.Print(%0) : i32 %2 = ts.UnresolvedSymbolRef {identifier = @print} : none %3 = ts.Constant {value = "done."} : !ts.string ts.Print(%3) : !ts.string "ts.Exit"() : () -> () } }
И второй пример с for/await
function main() { for await (const v of [1, 2, 3, 4, 5]) { print(v); } }
сгенерированный псевдокод
module @"C:\\temp\\1.ts" { ts.Func @main () -> () { "ts.Entry"() : () -> () %0 = ts.Constant {value = 1 : i32} : i32 %1 = ts.Constant {value = 2 : i32} : i32 %2 = ts.Constant {value = 3 : i32} : i32 %3 = ts.Constant {value = 4 : i32} : i32 %4 = ts.Constant {value = 5 : i32} : i32 %5 = ts.Constant {value = [1 : i32, 2 : i32, 3 : i32, 4 : i32, 5 : i32]} : !ts.const_array<i32,5> %6 = ts.Constant {value = 0 : i32} : i32 %7 = ts.Variable(%6) {false} : i32 -> !ts.ref<i32> %8 = async.create_group ts.For : -> ( { %9 = ts.Load(%7) : !ts.ref<i32> -> i32 %10 = ts.Constant {value = 5 : i32} : i32 %11 = ts.LogicalBinary %9(29) %10 : i32, i32 -> !ts.boolean ts.Condition(%11) : }, { %9 = ts.Load(%7) : !ts.ref<i32> -> i32 %10 = ts.PrefixUnary %9(45) : i32 -> i32 "ts.Result"() : () -> () }) { %9 = ts.Load(%7) : !ts.ref<i32> -> i32 %token = async.execute { %11 = ts.ElementRef %5[%9] : !ts.const_array<i32,5>[i32] -> !ts.ref<i32> %12 = ts.Load(%11) : !ts.ref<i32> -> i32 %13 = ts.UnresolvedSymbolRef {identifier = @print} : none ts.Print(%12) : i32 async.yield } %10 = async.add_to_group %token, %8 : !async.token "ts.Result"() : () -> () } async.await_all %8 "ts.Exit"() : () -> () } }
Интересующие нас команды в этом коде это "async.execute" которые берут всю ответственность за выполнение кода асинхронно на себя
Хочется добавить, что чтобы запустить данный код нам нужна поддержка "runtime".
C:\>tsc.exe --emit=jit --shared-libs=TypeScriptRuntime.dll example1.ts 1 2 3 4 5
Как мы видим из исполняемой строки что бы активировать "runtime" нужно указать параметр "--shared-libs=TypeScriptRuntime.dll". Для компиляции в LLVM IR данный параметр не нужен, но если мы хотим получить obj-файл с использованием --emit=jit тогда "runtime" нужно указывать. Также "runtime" нужно указывать при использовании "Garbage Collector" (сборщика мусора)
Примеры Batch-файлов для компиляции Exe-файлов
Компиляция, когда не нужна поддержка GC, async и захвата переменных.
set FILENAME=%1 set LLVMPATH=C:\dev\TypeScriptCompiler\3rdParty\llvm\release\bin set TSCPATH=C:\dev\TypeScriptCompiler\__build\tsc\bin set LIBPATH="C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.29.30133\lib\x64" set SDKPATH="C:\Program Files (x86)\Windows Kits\10\Lib\10.0.18362.0\um\x64" set UCRTPATH="C:\Program Files (x86)\Windows Kits\10\Lib\10.0.18362.0\ucrt\x64" set LLVMLIBPATH=C:\dev\TypeScriptCompiler\3rdParty\llvm\release\lib %TSCPATH%\tsc.exe --emit=llvm -nogc C:\temp\%FILENAME%.ts 2>%FILENAME%.ll %LLVMPATH%\llc.exe --filetype=obj -o=%FILENAME%.o %FILENAME%.ll %LLVMPATH%\lld.exe -flavor link %FILENAME%.o /libpath:%LIBPATH% /libpath:%SDKPATH% /libpath:%UCRTPATH% /defaultlib:libcmt.lib libvcruntime.lib del %FILENAME%.o echo "RUN:..." %FILENAME%.exe
Компиляция, когда нужна поддержка захвата переменных
set FILENAME=%1 set LLVMPATH=C:\dev\TypeScriptCompiler\3rdParty\llvm\release\bin set TSCPATH=C:\dev\TypeScriptCompiler\__build\tsc\bin set LIBPATH="C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.29.30133\lib\x64" set SDKPATH="C:\Program Files (x86)\Windows Kits\10\Lib\10.0.18362.0\um\x64" set UCRTPATH="C:\Program Files (x86)\Windows Kits\10\Lib\10.0.18362.0\ucrt\x64" set CLANGLIBPATH=C:\dev\TypeScriptCompiler\3rdParty\llvm\release\lib\clang\13.0.0\lib\windows %TSCPATH%\tsc.exe --emit=llvm -nogc C:\temp\%FILENAME%.ts 2>%FILENAME%.ll %LLVMPATH%\llc.exe --filetype=obj -o=%FILENAME%.o %FILENAME%.ll %LLVMPATH%\lld.exe -flavor link %FILENAME%.o /libpath:%LIBPATH% /libpath:%SDKPATH% /libpath:%UCRTPATH% /libpath:%CLANGLIBPATH% /defaultlib:libcmt.lib libvcruntime.lib clang_rt.builtins-x86_64.lib del %FILENAME%.o echo "RUN:..." %FILENAME%.exe
Компиляция если нужна поддержка GC
set FILENAME=%1 set LLVMPATH=C:\dev\TypeScriptCompiler\3rdParty\llvm\release\bin set TSCPATH=C:\dev\TypeScriptCompiler\__build\tsc\bin set LIBPATH="C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Tools\MSVC\14.29.30133\lib\x64" set SDKPATH="C:\Program Files (x86)\Windows Kits\10\Lib\10.0.18362.0\um\x64" set UCRTPATH="C:\Program Files (x86)\Windows Kits\10\Lib\10.0.18362.0\ucrt\x64" set LLVMLIBPATH=C:\dev\TypeScriptCompiler\3rdParty\llvm\release\lib set GCLIBPATH=C:\dev\TypeScriptCompiler\3rdParty\gc\Release %TSCPATH%\tsc.exe --emit=llvm C:\temp\%FILENAME%.ts 2>%FILENAME%.ll %LLVMPATH%\llc.exe --filetype=obj -o=%FILENAME%.o %FILENAME%.ll %LLVMPATH%\lld.exe -flavor link %FILENAME%.o /libpath:%LIBPATH% /libpath:%SDKPATH% /libpath:%UCRTPATH% /libpath:%GCLIBPATH% msvcrt.lib ucrt.lib kernel32.lib user32.lib gcmt-lib.lib del %FILENAME%.o echo "RUN:..." %FILENAME%.exe
Пример компиляции на Ubuntu
#/bin/sh ./tsc --emit=mlir-llvm -nogc /mnt/c/temp/1.ts -debug-only=llvm 2>1d.mlir ./tsc --emit=llvm -nogc /mnt/c/temp/1.ts 2>1.ll llc --filetype=obj --relocation-model=pic -o=1.o 1.ll
И если нужна поддержка try/catch/finally
#/bin/sh ./tsc --emit=llvm -nogc /mnt/c/temp/1.ts 2>1.ll llc --filetype=obj --relocation-model=pic -o=1.o 1.ll gcc -o 1.out 1.o -frtti -fexceptions -lstdc++
Пример компиляции для WASM
set FILENAME=%1 set LLVMPATH=C:\dev\TypeScriptCompiler\3rdParty\llvm\release\bin set TSCPATH=C:\dev\TypeScriptCompiler\__build\tsc\bin %TSCPATH%\tsc.exe --emit=llvm C:\temp\%FILENAME%.ts 2>%FILENAME%.ll %LLVMPATH%\llc.exe -mtriple=wasm32-unknown-unknown -O3 --filetype=obj -o=%FILENAME%.o %FILENAME%.ll %LLVMPATH%\wasm-ld.exe %FILENAME%.o -o %FILENAME%.wasm --no-entry --export-all --allow-undefined del *.o
Больше примеров batch-файлов можно посмотреть тут TypeScriptCompiler/docs/how at main · ASDAlexander77/TypeScriptCompiler (github.com)
Заключение
Я рекомендую заглянуть в репозиторий проекта в папку test что бы посмотреть примеры кодов, которые могут быть скомпилированы tsc.
TypeScriptCompiler/tsc/test/tester/tests at main · ASDAlexander77/TypeScriptCompiler (github.com)
Если Вам понравился данный проект, то дайте мне знать какую информацию Вы бы хотели еще узнать.
