@ugo-studio/jspp 0.1.2 → 0.1.4

package/README.md

@@ -33,6 +33,8 @@ JSPP reserves certain keywords to avoid conflicts with the generated C++ code an
 
 - `std`: Reserved to prevent conflicts with the C++ standard library namespace.
 - `jspp`: Reserved for internal use by the JSPP transpiler.
+- `co_yield`: Reserved to prevent conflicts with the c++ generator functions.
+- `co_return`: Reserved to prevent conflicts with the c++ generator functions.
 
 Using these keywords as variable names will result in a `SyntaxError`.
 
@@ -45,7 +47,7 @@ The transpilation process is a classic three-stage pipeline:
 2.  **Analysis:** The `TypeAnalyzer` traverses the AST. While it doesn't perform traditional static type checking, it plays a crucial role in understanding the code's structure. It identifies scopes (global, function, block) and detects when variables are "captured" by closures.
 
 3.  **Code Generation:** The `CodeGenerator` performs a final traversal of the AST. It translates each node into its C++ equivalent.
-    - All variables are declared as `std::shared_ptr<AnyValue>` (where `AnyValue` uses a [Tagged Union](https://en.wikipedia.org/wiki/Tagged_union) system for managing dynamic types like JavaScript). This approach elegantly mimics JavaScript's dynamic types and reference-based memory model.
+    - All variables are declared as `std::shared_ptr<AnyValue>` (where `AnyValue` uses a [Tagged Union](https://en.wikipedia.org/wiki/Tagged_union) method for managing dynamic types like JavaScript). This approach elegantly mimics JavaScript's dynamic types and reference-based memory model.
     - Closures are implemented as C++ lambdas that capture `shared_ptr`s by value, ensuring variable lifetimes are correctly extended beyond their original scope.
     - The entire script is wrapped into a single `main` function, with hoisting logic carefully replicated to ensure correct execution order.
 
@@ -130,15 +132,15 @@ This phase will broaden the range of supported JavaScript syntax and features.
 - [x] **Objects:** Literals, property access (dot and bracket notation), methods.
 - [x] **Arrays:** Literals, indexing, and core methods (`.push`, `.pop`, `.length`, etc.).
 - [x] **Operators:** Full suite of arithmetic, logical, and comparison operators.
-- [ ] **Control Flow:** tenary operators, `for` loops, `while` loops, `switch`.
+- [x] **Control Flow:** tenary operators, `for` loops, `while` loops, `switch`.
 
 ### **Phase 3: Interoperability & Standard Library**
 
 This phase will focus on building out the standard library and enabling modular code.
 
 - [ ] **JS Standard Library:** Implementation of common built-in objects and functions (`Math`, `Date`, `String.prototype.*`, `Array.prototype.*`).
+- [x] **Asynchronous Operations:** A C++ implementation of the JavaScript event loop, `Promise`, and `async/await`.
 - [ ] **Module System:** Support for `import` and `export` to transpile multi-file projects.
-- [ ] **Asynchronous Operations:** A C++ implementation of the JavaScript event loop, `Promise`, and `async/await`.
 
 ### **Phase 4: Optimization & Advanced Features**
 

package/dist/analysis/scope.js

@@ -1,10 +1,35 @@
-const RESERVED_KEYWORDS = ["std", "jspp"];
+import * as ts from "typescript";
+export const RESERVED_KEYWORDS = new Set([
+    "jspp",
+    "std",
+    "co_yield",
+    "co_return",
+    "co_await",
+]);
+export const BUILTIN_OBJECTS = new Set([
+    { name: "undefined", isConst: true },
+    { name: "null", isConst: true },
+    { name: "Symbol", isConst: false },
+    { name: "console", isConst: false },
+    { name: "performance", isConst: false },
+    { name: "global", isConst: false },
+    { name: "globalThis", isConst: false },
+    { name: "Error", isConst: false },
+    { name: "Promise", isConst: false },
+    { name: "setTimeout", isConst: false },
+    { name: "clearTimeout", isConst: false },
+    { name: "setInterval", isConst: false },
+    { name: "clearInterval", isConst: false },
+]);
 // Represents a single scope (e.g., a function body or a block statement)
 export class Scope {
     parent;
+    ownerFunction;
     symbols = new Map();
-    constructor(parent) {
+    children = [];
+    constructor(parent, ownerFunction) {
         this.parent = parent;
+        this.ownerFunction = ownerFunction;
     }
     // Defines a variable in this scope.
     define(name, type) {
@@ -28,23 +53,21 @@ export class ScopeManager {
     allScopes = []; // Array to store all created scopes
     reservedKeywords = new Set(RESERVED_KEYWORDS);
     constructor() {
-        const rootScope = new Scope(null); // The global scope
+        const rootScope = new Scope(null, null); // The global scope
         this.currentScope = rootScope;
         this.allScopes.push(rootScope); // Add the root scope to our list
-        this.define("undefined", {
-            type: "undefined",
-            isConst: true,
-            isBuiltin: true,
-        });
-        this.define("null", {
-            type: "null",
-            isConst: true,
-            isBuiltin: true,
-        });
+        for (const { name, isConst } of BUILTIN_OBJECTS) {
+            this.define(name, {
+                type: name,
+                isConst: isConst,
+                isBuiltin: true,
+            });
+        }
     }
     // Enters a new, nested scope.
-    enterScope() {
-        const newScope = new Scope(this.currentScope);
+    enterScope(ownerFunction) {
+        const newScope = new Scope(this.currentScope, ownerFunction);
+        this.currentScope.children.push(newScope);
         this.currentScope = newScope;
         this.allScopes.push(newScope); // Add every new scope to the list
     }

package/dist/analysis/typeAnalyzer.js

@@ -1,4 +1,5 @@
 import * as ts from "typescript";
+import { isBuiltinObject } from "../core/codegen/helpers";
 import { Traverser } from "../core/traverser";
 import { Scope, ScopeManager } from "./scope";
 export class TypeAnalyzer {
@@ -7,13 +8,34 @@ export class TypeAnalyzer {
     functionTypeInfo = new Map();
     functionStack = [];
     nodeToScope = new Map();
+    labelStack = [];
+    loopDepth = 0;
+    switchDepth = 0;
     analyze(ast) {
         this.nodeToScope.set(ast, this.scopeManager.currentScope);
+        const crossScopeModificationVisitor = (node) => {
+            if (ts.isIdentifier(node)) {
+                const name = node.getText();
+                const definingScope = this.scopeManager.currentScope
+                    .findScopeFor(name);
+                if (definingScope) {
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    const definingFunc = definingScope.ownerFunction;
+                    if (definingFunc !== currentFuncNode) {
+                        const typeInfo = this.scopeManager.lookup(name);
+                        if (typeInfo) {
+                            typeInfo.needsHeapAllocation = true;
+                        }
+                    }
+                }
+            }
+        };
         const visitor = {
             // Enter new scope for any block-like structure
             Block: {
                 enter: (node, parent) => {
-                    this.scopeManager.enterScope();
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    this.scopeManager.enterScope(currentFuncNode);
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                     if (parent && ts.isCatchClause(parent) &&
                         parent.variableDeclaration) {
@@ -34,28 +56,41 @@ export class TypeAnalyzer {
             },
             ForStatement: {
                 enter: (node) => {
-                    this.scopeManager.enterScope();
+                    this.loopDepth++;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    this.scopeManager.enterScope(currentFuncNode);
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                 },
-                exit: () => this.scopeManager.exitScope(),
+                exit: () => {
+                    this.loopDepth--;
+                    this.scopeManager.exitScope();
+                },
             },
             ForOfStatement: {
                 enter: (node) => {
-                    this.scopeManager.enterScope();
+                    this.loopDepth++;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    this.scopeManager.enterScope(currentFuncNode);
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                 },
-                exit: () => this.scopeManager.exitScope(),
+                exit: () => {
+                    this.loopDepth--;
+                    this.scopeManager.exitScope();
+                },
             },
             ForInStatement: {
                 enter: (node) => {
-                    this.scopeManager.enterScope();
+                    this.loopDepth++;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    this.scopeManager.enterScope(currentFuncNode);
                     this.nodeToScope.set(node, this.scopeManager.currentScope);
                     const forIn = node;
                     if (ts.isVariableDeclarationList(forIn.initializer)) {
                         const varDecl = forIn.initializer.declarations[0];
                         if (varDecl) {
                             const name = varDecl.name.getText();
-                            const isConst = (varDecl.parent.flags & ts.NodeFlags.Const) !== 0;
+                            const isConst = (varDecl.parent.flags & ts.NodeFlags.Const) !==
+                                0;
                             const typeInfo = {
                                 type: "string", // Keys are always strings
                                 declaration: varDecl,
@@ -69,7 +104,87 @@ export class TypeAnalyzer {
                         // The generator will handle assigning to it.
                     }
                 },
-                exit: () => this.scopeManager.exitScope(),
+                exit: () => {
+                    this.loopDepth--;
+                    this.scopeManager.exitScope();
+                },
+            },
+            WhileStatement: {
+                enter: (node) => {
+                    this.loopDepth++;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    this.scopeManager.enterScope(currentFuncNode);
+                    this.nodeToScope.set(node, this.scopeManager.currentScope);
+                },
+                exit: () => {
+                    this.loopDepth--;
+                    this.scopeManager.exitScope();
+                },
+            },
+            DoStatement: {
+                enter: (node) => {
+                    this.loopDepth++;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    this.scopeManager.enterScope(currentFuncNode);
+                    this.nodeToScope.set(node, this.scopeManager.currentScope);
+                },
+                exit: () => {
+                    this.loopDepth--;
+                    this.scopeManager.exitScope();
+                },
+            },
+            SwitchStatement: {
+                enter: (node) => {
+                    this.switchDepth++;
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    this.scopeManager.enterScope(currentFuncNode);
+                    this.nodeToScope.set(node, this.scopeManager.currentScope);
+                },
+                exit: () => {
+                    this.switchDepth--;
+                    this.scopeManager.exitScope();
+                },
+            },
+            LabeledStatement: {
+                enter: (node) => {
+                    this.nodeToScope.set(node, this.scopeManager.currentScope);
+                    this.labelStack.push(node.label.text);
+                },
+                exit: () => {
+                    this.labelStack.pop();
+                },
+            },
+            BreakStatement: {
+                enter: (node) => {
+                    const breakNode = node;
+                    if (breakNode.label) {
+                        if (!this.labelStack.includes(breakNode.label.text)) {
+                            throw new Error(`SyntaxError: Undefined label '${breakNode.label.text}'`);
+                        }
+                    }
+                    else {
+                        if (this.loopDepth === 0 && this.switchDepth === 0) {
+                            throw new Error("SyntaxError: Unlabeled break must be inside an iteration or switch statement");
+                        }
+                    }
+                },
+            },
+            ContinueStatement: {
+                enter: (node) => {
+                    const continueNode = node;
+                    if (continueNode.label) {
+                        if (!this.labelStack.includes(continueNode.label.text)) {
+                            throw new Error(`SyntaxError: Undefined label '${continueNode.label.text}'`);
+                        }
+                        // Also need to check if the label belongs to a loop, but that's harder here.
+                        // The TS checker should handle this. We'll assume for now it does.
+                    }
+                    else {
+                        if (this.loopDepth === 0) {
+                            throw new Error("SyntaxError: Unlabeled continue must be inside an iteration statement");
+                        }
+                    }
+                },
             },
             ArrowFunction: {
                 enter: (node) => {
@@ -80,7 +195,7 @@ export class TypeAnalyzer {
                             captures: new Map(),
                         };
                         this.functionTypeInfo.set(node, funcType);
-                        this.scopeManager.enterScope();
+                        this.scopeManager.enterScope(node);
                         this.nodeToScope.set(node, this.scopeManager.currentScope);
                         // Define parameters in the new scope
                         node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
@@ -106,9 +221,10 @@ export class TypeAnalyzer {
                             isClosure: false,
                             captures: new Map(),
                             declaration: node,
+                            needsHeapAllocation: true, // Added: Functions are always heap-allocated
                         };
                         this.functionTypeInfo.set(node, funcType);
-                        this.scopeManager.enterScope();
+                        this.scopeManager.enterScope(node);
                         this.nodeToScope.set(node, this.scopeManager.currentScope);
                         // If the function expression is named, define the name within its own scope for recursion.
                         if (node.name) {
@@ -141,11 +257,12 @@ export class TypeAnalyzer {
                                 isClosure: false,
                                 captures: new Map(),
                                 declaration: node,
+                                needsHeapAllocation: true,
                             };
                             this.scopeManager.define(funcName, funcType);
                             this.functionTypeInfo.set(node, funcType);
                         }
-                        this.scopeManager.enterScope();
+                        this.scopeManager.enterScope(node);
                         this.nodeToScope.set(node, this.scopeManager.currentScope);
                         // Define parameters in the new scope
                         node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
@@ -163,21 +280,106 @@ export class TypeAnalyzer {
                     this.scopeManager.exitScope();
                 },
             },
+            ClassDeclaration: {
+                enter: (node) => {
+                    const classNode = node;
+                    if (classNode.name) {
+                        const name = classNode.name.getText();
+                        const typeInfo = {
+                            type: "function", // Classes are functions
+                            declaration: classNode,
+                            needsHeapAllocation: true,
+                        };
+                        this.scopeManager.define(name, typeInfo);
+                    }
+                    const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
+                    this.scopeManager.enterScope(currentFuncNode);
+                    this.nodeToScope.set(node, this.scopeManager.currentScope);
+                },
+                exit: () => {
+                    this.scopeManager.exitScope();
+                },
+            },
+            MethodDeclaration: {
+                enter: (node) => {
+                    if (ts.isMethodDeclaration(node)) {
+                        const funcType = {
+                            type: "function",
+                            isClosure: false,
+                            captures: new Map(),
+                            declaration: node,
+                            needsHeapAllocation: true,
+                        };
+                        // Methods don't need to be defined in scope by name generally,
+                        // but we need to track them for captures.
+                        this.functionTypeInfo.set(node, funcType);
+                        this.scopeManager.enterScope(node);
+                        this.nodeToScope.set(node, this.scopeManager.currentScope);
+                        node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
+                            type: "auto",
+                            isParameter: true,
+                            declaration: p,
+                        }));
+                        this.functionStack.push(node);
+                    }
+                },
+                exit: (node) => {
+                    if (ts.isMethodDeclaration(node)) {
+                        this.functionStack.pop();
+                    }
+                    this.scopeManager.exitScope();
+                },
+            },
+            Constructor: {
+                enter: (node) => {
+                    if (ts.isConstructorDeclaration(node)) {
+                        const funcType = {
+                            type: "function",
+                            isClosure: false,
+                            captures: new Map(),
+                            declaration: node,
+                            needsHeapAllocation: true,
+                        };
+                        this.functionTypeInfo.set(node, funcType);
+                        this.scopeManager.enterScope(node);
+                        this.nodeToScope.set(node, this.scopeManager.currentScope);
+                        node.parameters.forEach((p) => this.scopeManager.define(p.name.getText(), {
+                            type: "auto",
+                            isParameter: true,
+                            declaration: p,
+                        }));
+                        this.functionStack.push(node); // Constructor acts like a function
+                    }
+                },
+                exit: (node) => {
+                    if (ts.isConstructorDeclaration(node)) {
+                        this.functionStack.pop();
+                    }
+                    this.scopeManager.exitScope();
+                },
+            },
             VariableDeclaration: {
                 enter: (node) => {
                     if (ts.isVariableDeclaration(node)) {
                         const name = node.name.getText();
                         const isConst = (node.parent.flags & ts.NodeFlags.Const) !== 0;
                         let type = "auto";
+                        let needsHeap = false;
                         if (node.initializer) {
                             if (ts.isArrayLiteralExpression(node.initializer)) {
                                 type = "array";
                             }
+                            else if (ts.isArrowFunction(node.initializer) ||
+                                ts.isFunctionExpression(node.initializer)) {
+                                type = "function";
+                                needsHeap = true;
+                            }
                         }
                         const typeInfo = {
                             type,
                             declaration: node,
                             isConst,
+                            needsHeapAllocation: needsHeap,
                         };
                         this.scopeManager.define(name, typeInfo);
                     }
@@ -186,10 +388,9 @@ export class TypeAnalyzer {
             Identifier: {
                 enter: (node, parent) => {
                     if (ts.isIdentifier(node)) {
-                        if (node.text === "console") {
+                        if (isBuiltinObject.call(this, node))
                             return;
-                        }
-                        const currentFuncNode = this.functionStack[this.functionStack.length - 1];
+                        const currentFuncNode = this.functionStack[this.functionStack.length - 1] ?? null;
                         if (currentFuncNode &&
                             (ts.isFunctionDeclaration(currentFuncNode) ||
                                 ts.isFunctionExpression(currentFuncNode)) &&
@@ -200,17 +401,19 @@ export class TypeAnalyzer {
                         // And see if it belongs to an outer scope
                         const definingScope = this.scopeManager.currentScope
                             .findScopeFor(node.text);
-                        if (definingScope &&
-                            definingScope !== this.scopeManager.currentScope) {
-                            // This is a potential capture!
-                            // Find which function we are currently in and mark the capture.
-                            if (currentFuncNode) {
+                        if (definingScope) {
+                            const definingFunc = definingScope.ownerFunction;
+                            if (definingFunc !== currentFuncNode) {
+                                // This is a capture!
                                 const type = this.scopeManager.lookup(node.text);
                                 if (type) {
-                                    const info = this.functionTypeInfo.get(currentFuncNode);
-                                    if (info) {
-                                        info.isClosure = true;
-                                        info.captures?.set(node.text, type);
+                                    type.needsHeapAllocation = true;
+                                    if (currentFuncNode) {
+                                        const info = this.functionTypeInfo.get(currentFuncNode);
+                                        if (info) {
+                                            info.isClosure = true;
+                                            info.captures?.set(node.text, type);
+                                        }
                                     }
                                 }
                             }
@@ -218,6 +421,37 @@ export class TypeAnalyzer {
                     }
                 },
             },
+            BinaryExpression: {
+                enter: (node) => {
+                    if (ts.isBinaryExpression(node)) {
+                        const isAssignment = node.operatorToken.kind >=
+                            ts.SyntaxKind.FirstAssignment &&
+                            node.operatorToken.kind <=
+                                ts.SyntaxKind.LastAssignment;
+                        if (isAssignment) {
+                            crossScopeModificationVisitor(node.left);
+                        }
+                    }
+                },
+            },
+            PostfixUnaryExpression: {
+                enter: (node) => {
+                    if (ts.isPostfixUnaryExpression(node)) {
+                        crossScopeModificationVisitor(node.operand);
+                    }
+                },
+            },
+            PrefixUnaryExpression: {
+                enter: (node) => {
+                    if (ts.isPrefixUnaryExpression(node)) {
+                        const op = node.operator;
+                        if (op === ts.SyntaxKind.PlusPlusToken ||
+                            op === ts.SyntaxKind.MinusMinusToken) {
+                            crossScopeModificationVisitor(node.operand);
+                        }
+                    }
+                },
+            },
         };
         this.traverser.traverse(ast, visitor);
     }

package/dist/ast/types.js

@@ -1 +1,7 @@
 import * as ts from "typescript";
+export var DeclaredSymbolType;
+(function (DeclaredSymbolType) {
+    DeclaredSymbolType["letOrConst"] = "letOrConst";
+    DeclaredSymbolType["function"] = "function";
+    DeclaredSymbolType["var"] = "var";
+})(DeclaredSymbolType || (DeclaredSymbolType = {}));

package/dist/cli.js

@@ -16,22 +16,21 @@ async function main() {
     try {
         const jsCode = await fs.readFile(jsFilePath, "utf-8");
         const interpreter = new Interpreter();
-        console.time(`Generated C++ code ${cppFilePath}...`);
         const { cppCode, preludePath } = interpreter.interpret(jsCode);
-        console.timeEnd(`Generated C++ code ${cppFilePath}...`);
+        console.log(`Generated C++ code ${cppFilePath}...`);
         await fs.mkdir(outputDir, { recursive: true });
         await fs.writeFile(cppFilePath, cppCode);
         console.log(`Compiling ${cppFilePath}...`);
         const compile = Bun.spawnSync({
             cmd: [
                 "g++",
-                "-std=c++20",
+                "-std=c++23",
                 cppFilePath,
                 "-o",
                 exeFilePath,
                 "-I",
                 preludePath,
-                "-O2",
+                "-O3",
                 "-DNDEBUG",
                 // "-include",
                 // path.join(process.cwd(), "prelude-build", "index.hpp"),

package/dist/core/codegen/class-handlers.js

@@ -0,0 +1,127 @@
+import ts from "typescript";
+import { CodeGenerator } from "./";
+import { visitObjectPropertyName } from "./expression-handlers";
+export function visitClassDeclaration(node, context) {
+    const className = node.name.getText();
+    // Check extends
+    let extendsExpr = null;
+    if (node.heritageClauses) {
+        for (const clause of node.heritageClauses) {
+            if (clause.token === ts.SyntaxKind.ExtendsKeyword &&
+                clause.types.length > 0) {
+                extendsExpr = clause.types[0].expression;
+            }
+        }
+    }
+    let parentName = "";
+    if (extendsExpr) {
+        parentName = this.visit(extendsExpr, context);
+        if (ts.isIdentifier(extendsExpr)) {
+            const scope = this.getScopeForNode(extendsExpr);
+            const typeInfo = this.typeAnalyzer.scopeManager.lookupFromScope(extendsExpr.getText(), scope);
+            if (typeInfo) {
+                parentName = this.getDerefCode(parentName, this.getJsVarName(extendsExpr), typeInfo);
+            }
+        }
+    }
+    const classContext = {
+        ...context,
+        superClassVar: parentName,
+    };
+    // 1. Constructor
+    const constructor = node.members.find(ts.isConstructorDeclaration);
+    let constructorLambda = "";
+    if (constructor) {
+        constructorLambda = this.generateLambda(constructor, {
+            ...classContext,
+            isInsideFunction: true,
+            lambdaName: className,
+        }, { isClass: true });
+    }
+    else {
+        // Default constructor
+        if (parentName) {
+            constructorLambda =
+                `jspp::AnyValue::make_class([=](const jspp::AnyValue& ${this.globalThisVar}, const std::vector<jspp::AnyValue>& args) mutable -> jspp::AnyValue {
+                 auto __parent = ${parentName};
+                 __parent.as_function("super")->call(${this.globalThisVar}, args);
+                 return jspp::AnyValue::make_undefined();
+             }, "${className}")`;
+        }
+        else {
+            constructorLambda =
+                `jspp::AnyValue::make_class([=](const jspp::AnyValue& ${this.globalThisVar}, const std::vector<jspp::AnyValue>& args) mutable -> jspp::AnyValue {
+                 return jspp::AnyValue::make_undefined();
+             }, "${className}")`;
+        }
+    }
+    let code = `${this.indent()}*${className} = ${constructorLambda};\n`;
+    // Set prototype of class (static inheritance) and prototype object (instance inheritance)
+    if (parentName) {
+        code +=
+            `${this.indent()}(*${className}).set_prototype(${parentName});\n`;
+        code +=
+            `${this.indent()}(*${className}).get_own_property("prototype").set_prototype(${parentName}.get_own_property("prototype"));\n`;
+    }
+    // Members
+    for (const member of node.members) {
+        if (ts.isMethodDeclaration(member)) {
+            const methodName = visitObjectPropertyName.call(this, member.name, {
+                ...context,
+                isObjectLiteralExpression: true, // Reuse this flag to handle computed properties
+            });
+            const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
+            const methodLambda = this.generateLambda(member, {
+                ...classContext,
+                isInsideFunction: true,
+            });
+            if (isStatic) {
+                code +=
+                    `${this.indent()}(*${className}).set_own_property(${methodName}, ${methodLambda});\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}(*${className}).get_own_property("prototype").set_own_property(${methodName}, ${methodLambda});\n`;
+            }
+        }
+        else if (ts.isGetAccessor(member)) {
+            const methodName = visitObjectPropertyName.call(this, member.name, {
+                ...context,
+                isObjectLiteralExpression: true,
+            });
+            const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
+            const lambda = this.generateLambda(member, {
+                ...classContext,
+                isInsideFunction: true,
+            });
+            if (isStatic) {
+                code +=
+                    `${this.indent()}(*${className}).define_getter(${methodName}, ${lambda});\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}(*${className}).get_own_property("prototype").define_getter(${methodName}, ${lambda});\n`;
+            }
+        }
+        else if (ts.isSetAccessor(member)) {
+            const methodName = visitObjectPropertyName.call(this, member.name, {
+                ...context,
+                isObjectLiteralExpression: true,
+            });
+            const isStatic = member.modifiers?.some((m) => m.kind === ts.SyntaxKind.StaticKeyword);
+            const lambda = this.generateLambda(member, {
+                ...classContext,
+                isInsideFunction: true,
+            });
+            if (isStatic) {
+                code +=
+                    `${this.indent()}(*${className}).define_setter(${methodName}, ${lambda});\n`;
+            }
+            else {
+                code +=
+                    `${this.indent()}(*${className}).get_own_property("prototype").define_setter(${methodName}, ${lambda});\n`;
+            }
+        }
+    }
+    return code;
+}