Merge pull request #438 from sugarlabs/gsoc-dmp-2025/week-1/safwan

GSoC/DMP 2025 Week 1: feat(program): Add Abstract classes

Author: meganindya

modules/program/package.json

@@ -8,6 +8,7 @@
     "test": "vitest --passWithNoTests",
     "coverage": "vitest run --coverage --passWithNoTests",
     "check": "tsc",
+    "dev": "ts-node src/sample/program-test.ts",
     "lint": "eslint src"
   }
 }

modules/program/src/@types/index.d.ts

@@ -0,0 +1,38 @@
+export type TNodeType =
+    | 'Program'
+    | 'ThreadFunctionDeclaration'
+    | 'CustomFunctionDeclaration'
+    | 'Block'
+    | 'VariableDeclarationStatement'
+    | 'VariableAssignmentStatement'
+    | 'FunctionCallStatement'
+    | 'JumpStatement'
+    | 'ModifyingContextStatement'
+    | 'DeclarativeContextStatement'
+    | 'BranchStatement'
+    | 'MatchStatement'
+    | 'IterationLoopStatement'
+    | 'ConditionLoopStatement'
+    | 'SequenceAlterStatement'
+    | 'NumericLiteralExpression'
+    | 'StringLiteralExpression'
+    | 'BooleanLiteralExpression'
+    | 'UnaryOperatorExpression'
+    | 'BinaryOperatorExpression'
+    | 'FunctionCallExpression'
+    | 'MemberExpression'
+    | 'ArrayExpression'
+    | 'DictExpression'
+    | 'IdentifierExpression';
+
+export type TUnaryOperator = 'sqrt' | 'abs' | 'not';
+export type TBinaryOperator =
+    | 'add'
+    | 'subtract'
+    | 'multiply'
+    | 'divide'
+    | 'lessThan'
+    | 'greaterThan'
+    | 'equal'
+    | 'and'
+    | 'or';

modules/program/src/abstracts.ts

@@ -0,0 +1,163 @@
+import { TNodeType, TUnaryOperator, TBinaryOperator } from './@types/index';
+
+// Base AST node
+export abstract class ASTNodeBase {
+    constructor(protected readonly _type: TNodeType) {}
+    public get type(): TNodeType {
+        return this._type;
+    }
+}
+
+// Program
+export abstract class Program extends ASTNodeBase {
+    constructor(public body: ASTNodeBase[]) {
+        super('Program');
+    }
+}
+
+// Function Declarations
+export abstract class FunctionDeclaration extends ASTNodeBase {
+    constructor(
+        nodeType: TNodeType,
+        public body: ASTNodeBase,
+    ) {
+        super(nodeType);
+    }
+}
+
+// Thread Function Declaration
+export abstract class ThreadFunctionDeclaration extends FunctionDeclaration {
+    constructor(public body: ASTNodeBase) {
+        super('ThreadFunctionDeclaration', body);
+    }
+}
+
+// Custom Function Declaration
+export abstract class CustomFunctionDeclaration extends FunctionDeclaration {
+    constructor(
+        public id: IdentifierExpression,
+        public params: IdentifierExpression[],
+        body: ASTNodeBase,
+    ) {
+        super('CustomFunctionDeclaration', body);
+    }
+}
+
+// Block
+export abstract class Block extends ASTNodeBase {
+    constructor(public statements: ASTNodeBase[]) {
+        super('Block');
+    }
+}
+
+// Statements
+export abstract class Statement extends ASTNodeBase {}
+
+export abstract class SimpleStatement extends Statement {}
+
+export abstract class CompoundStatement extends Statement {
+    constructor(
+        nodeType: TNodeType,
+        public body: ASTNodeBase,
+    ) {
+        super(nodeType);
+    }
+}
+
+// Expressions
+export abstract class Expression extends ASTNodeBase {}
+
+export abstract class LiteralExpression extends Expression {
+    constructor(
+        nodeType: TNodeType,
+        public value: number | string | boolean,
+    ) {
+        super(nodeType);
+    }
+}
+
+export class NumericLiteralExpression extends LiteralExpression {
+    constructor(public value: number) {
+        super('NumericLiteralExpression', value);
+    }
+}
+
+export class StringLiteralExpression extends LiteralExpression {
+    constructor(public value: string) {
+        super('StringLiteralExpression', value);
+    }
+}
+
+export class BooleanLiteralExpression extends LiteralExpression {
+    constructor(public value: boolean) {
+        super('BooleanLiteralExpression', value);
+    }
+}
+
+export abstract class OperatorExpression extends Expression {
+    constructor(nodeType: TNodeType) {
+        super(nodeType);
+    }
+}
+
+export abstract class UnaryOperatorExpression extends OperatorExpression {
+    constructor(
+        nodeType: TNodeType,
+        public operator: TUnaryOperator,
+        public operand: Expression,
+    ) {
+        super(nodeType);
+    }
+}
+
+export abstract class BinaryOperatorExpression extends OperatorExpression {
+    constructor(
+        nodeType: TNodeType,
+        public operator: TBinaryOperator,
+        public left: Expression,
+        public right: Expression,
+    ) {
+        super(nodeType);
+    }
+}
+
+// Function Call
+export abstract class FunctionCallExpression extends Expression {
+    constructor(
+        public callee: Expression,
+        public args: { param: Expression; value: Expression }[],
+    ) {
+        super('FunctionCallExpression');
+    }
+}
+
+// Member Expression
+export abstract class MemberExpression extends Expression {
+    constructor(
+        public object: Expression,
+        public property: Expression,
+    ) {
+        super('MemberExpression');
+    }
+}
+
+// Array Expression
+export abstract class ArrayExpression extends Expression {
+    constructor(public elements: Expression[]) {
+        super('ArrayExpression');
+    }
+}
+
+// Dict Expression
+export abstract class DictExpression extends Expression {
+    constructor(public entries: { key: Expression; value: Expression }[]) {
+        super('DictExpression');
+    }
+}
+
+// Identifier Expression
+export abstract class IdentifierExpression extends Expression {
+    constructor(public name: string) {
+        super('IdentifierExpression');
+    }
+}

modules/program/src/ast/Block.ts

@@ -0,0 +1,7 @@
+import { ASTNodeBase, Block as BlockAbstract } from '../abstracts';
+
+export class Block extends BlockAbstract {
+    constructor(statements: ASTNodeBase[] = []) {
+        super(statements);
+    }
+}

modules/program/src/ast/ProgramDeclaration.ts

@@ -0,0 +1,7 @@
+import { ASTNodeBase, Program } from '../abstracts';
+
+export class ProgramDeclaration extends Program {
+    constructor(body: ASTNodeBase[]) {
+        super(body);
+    }
+}

modules/program/src/ast/expression/ArrayExpression.ts

@@ -0,0 +1,7 @@
+import { ArrayExpression as ArrayExpressionAbstract, Expression } from '../../abstracts';
+
+export class ArrayExpression extends ArrayExpressionAbstract {
+    constructor(elements: Expression[]) {
+        super(elements);
+    }
+}

modules/program/src/ast/expression/BinaryOperatorExpression.ts

@@ -0,0 +1,11 @@
+import {
+    BinaryOperatorExpression as BinaryOperatorExpressionAbstract,
+    Expression,
+} from '../../abstracts';
+import { TBinaryOperator } from '../../@types/index';
+
+export class BinaryOperatorExpression extends BinaryOperatorExpressionAbstract {
+    constructor(operator: TBinaryOperator, left: Expression, right: Expression) {
+        super('BinaryOperatorExpression', operator, left, right);
+    }
+}

modules/program/src/ast/expression/BooleanLiteralExpression.ts

@@ -0,0 +1,7 @@
+import { LiteralExpression } from '../../abstracts';
+
+export class BooleanLiteralExpression extends LiteralExpression {
+    constructor(value: boolean) {
+        super('BooleanLiteralExpression', value);
+    }
+}

modules/program/src/ast/expression/DictExpression.ts

@@ -0,0 +1,7 @@
+import { DictExpression as DictExpressionAbstract, Expression } from '../../abstracts';
+
+export class DictExpression extends DictExpressionAbstract {
+    constructor(entries: { key: Expression; value: Expression }[]) {
+        super(entries);
+    }
+}

modules/program/src/ast/expression/FunctionCallExpression.ts

@@ -0,0 +1,10 @@
+import {
+    FunctionCallExpression as FunctionCallExpressionAbstract,
+    Expression,
+} from '../../abstracts';
+
+export class FunctionCallExpression extends FunctionCallExpressionAbstract {
+    constructor(callee: Expression, args: { param: Expression; value: Expression }[]) {
+        super(callee, args);
+    }
+}