@tsonic/emitter 0.0.1

package/testcases/arrays/basic/config.yaml

@@ -0,0 +1 @@
+- ArrayLiteral.ts: should emit basic array literal with correct type

package/testcases/arrays/destructuring/ArrayDestructure.ts

@@ -0,0 +1,4 @@
+export function destructure(arr: number[]): number {
+  const [first, second] = arr;
+  return first + second;
+}

package/testcases/arrays/destructuring/config.yaml

@@ -0,0 +1 @@
+- ArrayDestructure.ts: should emit array destructuring with element access

package/testcases/arrays/methods/ArrayMethods.ts

@@ -0,0 +1,6 @@
+export function processArray(arr: number[]): number {
+  const doubled = arr.map((x) => x * 2);
+  const filtered = doubled.filter((x) => x > 5);
+  const sum = filtered.reduce((acc, x) => acc + x, 0);
+  return sum;
+}

package/testcases/arrays/methods/config.yaml

@@ -0,0 +1 @@
+- ArrayMethods.ts: should emit array method calls (map, filter, reduce)

package/testcases/arrays/multidimensional/MultiDimensional.ts

@@ -0,0 +1,10 @@
+export function getElement(matrix: number[][]): number {
+  return matrix[0][1];
+}
+
+export function createMatrix(): number[][] {
+  return [
+    [1, 2],
+    [3, 4],
+  ];
+}

package/testcases/arrays/multidimensional/config.yaml

@@ -0,0 +1 @@
+- MultiDimensional.ts: should emit multi-dimensional array access

package/testcases/arrays/spread/ArraySpread.ts

@@ -0,0 +1,3 @@
+export function spreadArray(arr1: number[], arr2: number[]): number[] {
+  return [...arr1, ...arr2];
+}

package/testcases/arrays/spread/config.yaml

@@ -0,0 +1 @@
+- ArraySpread.ts: should emit array spread operator

package/testcases/async/basic/AsyncFunction.ts

@@ -0,0 +1,5 @@
+export async function fetchData(): Promise<string> {
+  return await getData();
+}
+
+declare function getData(): Promise<string>;

package/testcases/async/basic/config.yaml

@@ -0,0 +1 @@
+- AsyncFunction.ts: should emit async function with Promise<string> return type

package/testcases/classes/abstract/AbstractClasses.ts

@@ -0,0 +1,53 @@
+// Abstract base class
+export abstract class Shape {
+  abstract getArea(): number;
+  abstract getPerimeter(): number;
+
+  // Concrete method in abstract class
+  describe(): string {
+    return `Area: ${this.getArea()}, Perimeter: ${this.getPerimeter()}`;
+  }
+}
+
+// Concrete implementation
+export class Rectangle extends Shape {
+  width: number;
+  height: number;
+
+  constructor(width: number, height: number) {
+    super();
+    this.width = width;
+    this.height = height;
+  }
+
+  getArea(): number {
+    return this.width * this.height;
+  }
+
+  getPerimeter(): number {
+    return 2 * (this.width + this.height);
+  }
+}
+
+// Another concrete implementation
+export class Circle extends Shape {
+  radius: number;
+
+  constructor(radius: number) {
+    super();
+    this.radius = radius;
+  }
+
+  getArea(): number {
+    return Math.PI * this.radius * this.radius;
+  }
+
+  getPerimeter(): number {
+    return 2 * Math.PI * this.radius;
+  }
+}
+
+// Function using abstract class
+export function calculateTotalArea(shapes: Shape[]): number {
+  return shapes.reduce((total, shape) => total + shape.getArea(), 0);
+}

package/testcases/classes/abstract/config.yaml

@@ -0,0 +1 @@
+- AbstractClasses.ts: should emit abstract classes with abstract methods

package/testcases/classes/basic/Person.ts

@@ -0,0 +1,12 @@
+export class Person {
+  name!: string;
+  age!: number;
+
+  greet(): string {
+    return `Hello, I'm ${this.name}`;
+  }
+
+  birthday(): void {
+    this.age++;
+  }
+}

package/testcases/classes/basic/config.yaml

@@ -0,0 +1 @@
+- Person.ts: should emit basic class with methods

package/testcases/classes/constructor/User.ts

@@ -0,0 +1,11 @@
+export class User {
+  constructor(
+    public name: string,
+    public email: string,
+    private password: string
+  ) {}
+
+  authenticate(input: string): boolean {
+    return input === this.password;
+  }
+}

package/testcases/classes/constructor/config.yaml

@@ -0,0 +1 @@
+- User.ts: should emit class constructor with parameter properties

package/testcases/classes/field-inference/Counter.ts

@@ -0,0 +1,11 @@
+// Class fields without explicit type annotations
+// TypeScript infers types from initializers
+export class Counter {
+  count = 0;
+  name = "default";
+  active = true;
+
+  increment(): void {
+    this.count++;
+  }
+}

package/testcases/classes/field-inference/config.yaml

@@ -0,0 +1 @@
+- Counter.ts: should infer CLR types for class fields without type annotations

package/testcases/classes/inheritance/Inheritance.ts

@@ -0,0 +1,24 @@
+export class Animal {
+  name: string;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  makeSound(): string {
+    return "Some sound";
+  }
+}
+
+export class Dog extends Animal {
+  breed: string;
+
+  constructor(name: string, breed: string) {
+    super(name);
+    this.breed = breed;
+  }
+
+  makeSound(): string {
+    return "Woof!";
+  }
+}

package/testcases/classes/inheritance/config.yaml

@@ -0,0 +1 @@
+- Inheritance.ts: should emit class inheritance with extends keyword

package/testcases/classes/static-members/MathHelper.ts

@@ -0,0 +1,12 @@
+export class MathHelper {
+  static PI: number = 3.14159;
+  static E: number = 2.71828;
+
+  static square(x: number): number {
+    return x * x;
+  }
+
+  static cube(x: number): number {
+    return x * x * x;
+  }
+}

package/testcases/classes/static-members/config.yaml

@@ -0,0 +1 @@
+- MathHelper.ts: should emit static properties and methods

package/testcases/control-flow/error-handling/ErrorHandling.ts

@@ -0,0 +1,13 @@
+export function safeDivide(a: number, b: number): number {
+  try {
+    if (b === 0) {
+      throw new Error("Division by zero");
+    }
+    return a / b;
+  } catch (error) {
+    console.log(error);
+    return 0;
+  } finally {
+    console.log("Operation complete");
+  }
+}

package/testcases/control-flow/error-handling/config.yaml

@@ -0,0 +1 @@
+- ErrorHandling.ts: should emit try-catch-finally blocks

package/testcases/control-flow/loops/Loops.ts

@@ -0,0 +1,21 @@
+export function sumEven(numbers: number[]): number {
+  let sum = 0;
+  for (let i = 0; i < numbers.length; i++) {
+    if (numbers[i] % 2 !== 0) {
+      continue;
+    }
+    sum += numbers[i];
+  }
+  return sum;
+}
+
+export function findFirst(numbers: number[], target: number): number {
+  let i = 0;
+  while (i < numbers.length) {
+    if (numbers[i] === target) {
+      break;
+    }
+    i++;
+  }
+  return i;
+}

package/testcases/control-flow/loops/config.yaml

@@ -0,0 +1 @@
+- Loops.ts: should emit for, while loops with break and continue

package/testcases/control-flow/switch/SwitchStatement.ts

@@ -0,0 +1,15 @@
+export function getDayType(day: number): string {
+  switch (day) {
+    case 0:
+    case 6:
+      return "weekend";
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return "weekday";
+    default:
+      return "invalid";
+  }
+}

package/testcases/control-flow/switch/config.yaml

@@ -0,0 +1 @@
+- SwitchStatement.ts: should emit switch statement with cases and default

package/testcases/edge-cases/complex-expressions/ComplexExpressions.ts

@@ -0,0 +1,10 @@
+export function complexExpression(a: number, b: number, c: number): number {
+  return (a + b) * c - a / b + (c % a) * ((b - a) / (c + 1));
+}
+
+export function chainedCalls(arr: number[]): number {
+  return arr
+    .map((x) => x * 2)
+    .filter((x) => x > 10)
+    .reduce((acc, x) => acc + x, 0);
+}

package/testcases/edge-cases/complex-expressions/config.yaml

@@ -0,0 +1 @@
+- ComplexExpressions.ts: should handle deeply nested and complex expressions

package/testcases/edge-cases/nested-scopes/NestedScopes.ts

@@ -0,0 +1,10 @@
+export function nestedScopes(x: number): number {
+  const a = 10;
+  {
+    const b = 20;
+    {
+      const c = 30;
+      return a + b + c + x;
+    }
+  }
+}

package/testcases/edge-cases/nested-scopes/config.yaml

@@ -0,0 +1 @@
+- NestedScopes.ts: should handle nested block scopes correctly

package/testcases/edge-cases/shadowing/Shadowing.ts

@@ -0,0 +1,16 @@
+export function shadowedVariable(): number {
+  const x = 10;
+  {
+    const x = 20;
+    return x;
+  }
+}
+
+export function shadowInFunction(): number {
+  const value = 5;
+  const inner = (): number => {
+    const value = 10;
+    return value;
+  };
+  return value + inner();
+}

package/testcases/edge-cases/shadowing/config.yaml

@@ -0,0 +1 @@
+- Shadowing.ts: should handle variable shadowing correctly

package/testcases/functions/arrow/ArrowFunction.ts

@@ -0,0 +1,5 @@
+export const add = (a: number, b: number): number => a + b;
+
+export const greet = (name: string): string => {
+  return `Hello ${name}`;
+};

package/testcases/functions/arrow/config.yaml

@@ -0,0 +1 @@
+- ArrowFunction.ts: should emit arrow function as lambda expression

package/testcases/functions/basic/Greet.ts

@@ -0,0 +1,3 @@
+export function greet(name: string): string {
+  return `Hello ${name}`;
+}

package/testcases/functions/basic/config.yaml

@@ -0,0 +1 @@
+- Greet.ts: should emit simple function with string parameter

package/testcases/functions/closures/Closures.ts

@@ -0,0 +1,11 @@
+export function makeCounter(): () => number {
+  let count = 0;
+  return () => {
+    count++;
+    return count;
+  };
+}
+
+export function makeAdder(x: number): (y: number) => number {
+  return (y) => x + y;
+}

package/testcases/functions/closures/config.yaml

@@ -0,0 +1 @@
+- Closures.ts: should emit closure capturing outer scope variables

package/testcases/functions/default-params/DefaultParams.ts

@@ -0,0 +1,7 @@
+export function greet(name: string, greeting: string = "Hello"): string {
+  return `${greeting} ${name}`;
+}
+
+export function multiply(a: number, b: number = 2): number {
+  return a * b;
+}

package/testcases/functions/default-params/config.yaml

@@ -0,0 +1 @@
+- DefaultParams.ts: should emit function with default parameter values

package/testcases/functions/rest-params/RestParams.ts

@@ -0,0 +1,7 @@
+export function sum(...numbers: number[]): number {
+  return numbers.reduce((acc, n) => acc + n, 0);
+}
+
+export function concat(separator: string, ...strings: string[]): string {
+  return strings.join(separator);
+}

package/testcases/functions/rest-params/config.yaml

@@ -0,0 +1 @@
+- RestParams.ts: should emit function with rest parameters as params array

package/testcases/functions/type-guards/TypeGuards.ts

@@ -0,0 +1,52 @@
+export interface Dog {
+  type: "dog";
+  bark(): void;
+}
+
+export interface Cat {
+  type: "cat";
+  meow(): void;
+}
+
+export type Animal = Dog | Cat;
+
+// Type guard function with 'is' predicate
+export function isDog(animal: Animal): animal is Dog {
+  return animal.type === "dog";
+}
+
+export function isCat(animal: Animal): animal is Cat {
+  return animal.type === "cat";
+}
+
+// Using type guards
+export function makeSound(animal: Animal): void {
+  if (isDog(animal)) {
+    animal.bark();
+  } else if (isCat(animal)) {
+    animal.meow();
+  }
+}
+
+// typeof type guard
+export function processValue(value: string | number): string {
+  if (typeof value === "string") {
+    return value.toUpperCase();
+  }
+  return value.toString();
+}
+
+// instanceof type guard
+export class Circle {
+  radius: number;
+  constructor(radius: number) {
+    this.radius = radius;
+  }
+}
+
+export function getArea(shape: Circle | number): number {
+  if (shape instanceof Circle) {
+    return Math.PI * shape.radius * shape.radius;
+  }
+  return shape;
+}

package/testcases/functions/type-guards/config.yaml

@@ -0,0 +1 @@
+- TypeGuards.ts: should emit type guard functions with is predicates

package/testcases/operators/logical/LogicalOperators.ts

@@ -0,0 +1,11 @@
+export function isValid(name: string, age: number): boolean {
+  return name.length > 0 && age >= 18;
+}
+
+export function getDisplayName(name: string | null): string {
+  return name || "Anonymous";
+}
+
+export function classify(age: number): string {
+  return age >= 18 ? "adult" : "minor";
+}

package/testcases/operators/logical/config.yaml

@@ -0,0 +1 @@
+- LogicalOperators.ts: should emit logical operators (&&, ||, ternary)

package/testcases/operators/nullish-coalescing/NullishCoalescing.ts

@@ -0,0 +1,7 @@
+export function getDefault(value: string | null | undefined): string {
+  return value ?? "default";
+}
+
+export function getNumber(value: number | null): number {
+  return value ?? 0;
+}

package/testcases/operators/nullish-coalescing/config.yaml

@@ -0,0 +1 @@
+- NullishCoalescing.ts: should emit nullish coalescing operator (??)

package/testcases/operators/optional-chaining/OptionalChaining.ts

@@ -0,0 +1,15 @@
+export interface User {
+  name?: string;
+  address?: {
+    street?: string;
+    city?: string;
+  };
+}
+
+export function getCity(user: User | null): string | undefined {
+  return user?.address?.city;
+}
+
+export function getNameLength(user: User | null): number {
+  return user?.name?.length ?? 0;
+}

package/testcases/operators/optional-chaining/config.yaml

@@ -0,0 +1 @@
+- OptionalChaining.ts: should emit optional chaining operator (?.)

package/testcases/real-world/advanced-generics/advanced-generics.ts

@@ -0,0 +1,116 @@
+// Generic pair
+export class Pair<T, U> {
+  constructor(
+    public first: T,
+    public second: U
+  ) {}
+
+  swap(): Pair<U, T> {
+    return new Pair(this.second, this.first);
+  }
+
+  map<V, W>(
+    firstMapper: (value: T) => V,
+    secondMapper: (value: U) => W
+  ): Pair<V, W> {
+    return new Pair(firstMapper(this.first), secondMapper(this.second));
+  }
+}
+
+// Generic result type
+export type Result<T, E> = { ok: true; value: T } | { ok: false; error: E };
+
+export function ok<T, E>(value: T): Result<T, E> {
+  return { ok: true, value };
+}
+
+export function err<T, E>(error: E): Result<T, E> {
+  return { ok: false, error };
+}
+
+export function isOk<T, E>(
+  result: Result<T, E>
+): result is { ok: true; value: T } {
+  return result.ok === true;
+}
+
+export function isErr<T, E>(
+  result: Result<T, E>
+): result is { ok: false; error: E } {
+  return result.ok === false;
+}
+
+// Generic tree structure
+export class TreeNode<T> {
+  children: TreeNode<T>[] = [];
+
+  constructor(public value: T) {}
+
+  addChild(value: T): TreeNode<T> {
+    const child = new TreeNode(value);
+    this.children.push(child);
+    return child;
+  }
+
+  forEach(callback: (value: T) => void): void {
+    callback(this.value);
+    for (const child of this.children) {
+      child.forEach(callback);
+    }
+  }
+
+  map<U>(mapper: (value: T) => U): TreeNode<U> {
+    const mapped = new TreeNode(mapper(this.value));
+    for (const child of this.children) {
+      mapped.children.push(child.map(mapper));
+    }
+    return mapped;
+  }
+}
+
+// Constrained generics
+export interface Comparable<T> {
+  compareTo(other: T): number;
+}
+
+export function min<T extends Comparable<T>>(items: T[]): T | undefined {
+  if (items.length === 0) {
+    return undefined;
+  }
+
+  let result = items[0];
+  for (let i = 1; i < items.length; i++) {
+    if (items[i].compareTo(result) < 0) {
+      result = items[i];
+    }
+  }
+  return result;
+}
+
+export function max<T extends Comparable<T>>(items: T[]): T | undefined {
+  if (items.length === 0) {
+    return undefined;
+  }
+
+  let result = items[0];
+  for (let i = 1; i < items.length; i++) {
+    if (items[i].compareTo(result) > 0) {
+      result = items[i];
+    }
+  }
+  return result;
+}
+
+// Generic builder pattern
+export class Builder<T> {
+  private props: Partial<T> = {};
+
+  set<K extends keyof T>(key: K, value: T[K]): Builder<T> {
+    this.props[key] = value;
+    return this;
+  }
+
+  build(): T {
+    return this.props as T;
+  }
+}

package/testcases/real-world/advanced-generics/config.yaml

@@ -0,0 +1 @@
+- advanced-generics.ts: should emit real-world advanced-generics program