@grey-ts/transpiler 2.0.0 → 2.1.0

package/dist/index.js

@@ -7,7 +7,7 @@ import path6 from "node:path";
 // src/transpiler.ts
 import * as fs2 from "node:fs";
 import * as path5 from "node:path";
-import ts14 from "typescript";
+import ts15 from "typescript";
 
 // src/nodeHandler.ts
 import * as path from "node:path";
@@ -33,9 +33,9 @@ class NodeHandler {
       if (!extra)
         return result;
       return [
-        ...extra.before ? [extra.before] : [],
+        ...extra.before,
         result,
-        ...extra.after ? [extra.after] : []
+        ...extra.after
       ].join(`
 `);
     } catch (error) {
@@ -47,13 +47,13 @@ class NodeHandler {
   static addExtraOutput(node, before, after) {
     let extra = this.transpileContext.extraOutput.get(node);
     if (!extra) {
-      extra = { before: "", after: "" };
+      extra = { before: [], after: [] };
       this.transpileContext.extraOutput.set(node, extra);
     }
     if (before)
-      extra.before += before;
+      extra.before.push(before);
     if (after)
-      extra.after += after;
+      extra.after.push(after);
   }
   static printLineAndCol(node) {
     const source = node.getSourceFile();
@@ -299,6 +299,13 @@ var knownOperators = new Set([
   "*",
   "/",
   "%",
+  "*=",
+  "/=",
+  "%=",
+  "**=",
+  "<<=",
+  ">>=",
+  ">>>=",
   "~",
   "&",
   "|",
@@ -416,7 +423,14 @@ var assignmentOperators = new Set([
   "??=",
   "||=",
   "-=",
-  "+="
+  "+=",
+  "*=",
+  "/=",
+  "%=",
+  "**=",
+  "<<=",
+  ">>=",
+  ">>>="
 ]);
 function valueIsBeingAssignedToNode(node) {
   if (ts3.hasOnlyExpressionInitializer(node.parent) && node === node.parent.name)
@@ -450,21 +464,90 @@ NodeHandler.register(ts4.SyntaxKind.ComputedPropertyName, (node) => {
 });
 
 // src/visitors/classes.ts
+import ts6 from "typescript";
+
+// src/visitors/functions.ts
 import ts5 from "typescript";
-NodeHandler.register(ts5.SyntaxKind.ClassDeclaration, (node) => {
+function handleFunctionBodyAndParams(node, ctx) {
+  const oldBindingElements = Object.keys(ctx.bindingElements);
+  const params = node.parameters.map((param) => NodeHandler.handle(param));
+  const newBindingElements = Object.keys(ctx.bindingElements).filter((b) => !oldBindingElements.includes(b));
+  const body = !node.body ? "" : ts5.isBlock(node.body) ? NodeHandler.handle(node.body) : `	return ${NodeHandler.handle(node.body)}`;
+  for (const bindingElement of newBindingElements) {
+    delete ctx.bindingElements[bindingElement];
+  }
+  const functionOutput = [
+    `function${params.length ? `(${params.join(", ")})` : ""}`,
+    ...body ? [body] : [],
+    `end function`
+  ].join(`
+`);
+  return {
+    body,
+    params,
+    functionOutput
+  };
+}
+NodeHandler.register(ts5.SyntaxKind.Block, (node) => {
+  const output = node.statements.map((val) => {
+    let statement = NodeHandler.handle(val);
+    statement = statement.split(`
+`).filter((s) => !!s).map((line) => `	${line}`).join(`
+`);
+    return statement;
+  }).filter((s) => !!s).join(`
+`);
+  return output;
+});
+NodeHandler.register(ts5.SyntaxKind.MethodDeclaration, (node, ctx) => {
+  const func = handleFunctionBodyAndParams(node, ctx);
+  return `${NodeHandler.handle(node.name)} = ${func.functionOutput}`;
+});
+NodeHandler.register(ts5.SyntaxKind.FunctionDeclaration, (node, ctx) => {
+  if (!node.body)
+    return "";
   if (node.modifiers?.some((m) => m.kind === ts5.SyntaxKind.DeclareKeyword))
     return "";
+  const func = handleFunctionBodyAndParams(node, ctx);
+  const name = node.name ? node.name.text : "anon";
+  return `${name} = ${func.functionOutput}`;
+});
+NodeHandler.register(ts5.SyntaxKind.ArrowFunction, (node, ctx) => {
+  const func = handleFunctionBodyAndParams(node, ctx);
+  if (ts5.isCallOrNewExpression(node.parent) || ts5.isParenthesizedExpression(node.parent)) {
+    const mainNode = ts5.findAncestor(node.parent, (n) => n.parent && (ts5.isBlock(n.parent) || ts5.isSourceFile(n.parent)));
+    if (!mainNode) {
+      return `@${createAnonFunction(func.body, func.params).name}`;
+    }
+    const anon = createAnonFunction(func.body, func.params, false);
+    NodeHandler.addExtraOutput(mainNode, anon.str, null);
+    return `@${anon.name}`;
+  }
+  if (ts5.hasOnlyExpressionInitializer(node.parent) || ts5.isBinaryExpression(node.parent) || ts5.isReturnStatement(node.parent)) {
+    return func.functionOutput;
+  }
+  const kind = ts5.SyntaxKind[node.parent.kind];
+  throw `This kind of arrow function is not yet supported (parent: ${kind} (${node.parent.kind}))`;
+});
+NodeHandler.register(ts5.SyntaxKind.FunctionExpression, (node, ctx) => {
+  return handleFunctionBodyAndParams(node, ctx).functionOutput;
+});
+
+// src/visitors/classes.ts
+NodeHandler.register(ts6.SyntaxKind.ClassDeclaration, (node) => {
+  if (node.modifiers?.some((m) => m.kind === ts6.SyntaxKind.DeclareKeyword))
+    return "";
   const name = node.name ? node.name.text : "anon";
-  const extensions = node.heritageClauses?.filter((h) => h.token === ts5.SyntaxKind.ExtendsKeyword);
+  const extensions = node.heritageClauses?.filter((h) => h.token === ts6.SyntaxKind.ExtendsKeyword);
   let output = `${name} = {}`;
   if (extensions?.length && extensions[0].types.length)
     output = `${name} = new ${NodeHandler.handle(extensions[0].types[0].expression)}`;
   const declaredNames = new Set;
   let hasConstructor = false;
   for (const member of node.members) {
-    if (ts5.isFunctionLike(member) && "body" in member && !member.body)
+    if (ts6.isFunctionLike(member) && "body" in member && !member.body)
       continue;
-    if (ts5.isSemicolonClassElement(member))
+    if (ts6.isSemicolonClassElement(member))
       continue;
     if (member.name) {
       const memberName = NodeHandler.handle(member.name);
@@ -473,78 +556,67 @@ NodeHandler.register(ts5.SyntaxKind.ClassDeclaration, (node) => {
 Modifiers such as 'static' are only for TypeScript for now and are not differentiated in the transpiled version from normal declarations for now`;
       declaredNames.add(memberName);
     }
-    if (ts5.isConstructorDeclaration(member))
+    if (ts6.isConstructorDeclaration(member))
       hasConstructor = true;
     output += `
 ${name}.${NodeHandler.handle(member)}`;
   }
-  if (!hasConstructor && !node.modifiers?.some((m) => m.kind === ts5.SyntaxKind.AbstractKeyword))
+  if (!hasConstructor && !node.modifiers?.some((m) => m.kind === ts6.SyntaxKind.AbstractKeyword))
     output += `
 ${name}.constructor = function
 	return self
 end function`;
   return output;
 });
-NodeHandler.register(ts5.SyntaxKind.Constructor, (node) => {
+NodeHandler.register(ts6.SyntaxKind.Constructor, (node, ctx) => {
   if (!node.body)
     return "";
-  const declaredProperties = [];
-  const params = node.parameters.map((param) => {
-    const res = NodeHandler.handle(param);
-    if (param.modifiers) {
-      const paramName = NodeHandler.handle(param.name);
-      const declaration = `	self.${paramName} = ${paramName}`;
-      declaredProperties.push(declaration);
-    }
-    return res;
-  }).join(", ");
-  let body = NodeHandler.handle(node.body);
-  if (declaredProperties.length) {
-    const propertiesStr = declaredProperties.join(`
+  const func = handleFunctionBodyAndParams(node, ctx);
+  if (ctx.parameterProperties.length) {
+    const propertiesStr = ctx.parameterProperties.join(`
 `);
-    const lines = body.split(`
+    ctx.parameterProperties.length = 0;
+    const lines = func.body.split(`
 `);
     const superIndex = lines.findIndex((line) => line.includes("super.constructor"));
     if (superIndex !== -1) {
-      body = `${lines.slice(0, superIndex + 1).join(`
+      func.body = `${lines.slice(0, superIndex + 1).join(`
 `)}
 ${propertiesStr}
 ${lines.slice(superIndex + 1).join(`
 `)}`;
     } else {
-      body = `${propertiesStr}
-${body}`;
+      func.body = `${propertiesStr}
+${func.body}`;
     }
   }
-  return `constructor = function(${params})
-${body}
-	return self
-end function`;
+  return [
+    `constructor = function${func.params.length ? `(${func.params.join(", ")})` : ""}`,
+    ...func.body ? [func.body] : [],
+    "\treturn self",
+    `end function`
+  ].join(`
+`);
 });
-NodeHandler.register(ts5.SyntaxKind.GetAccessor, (node) => {
+NodeHandler.register(ts6.SyntaxKind.GetAccessor, (node, ctx) => {
   if (!node.body)
     return "";
-  const body = NodeHandler.handle(node.body);
-  return `${NodeHandler.handle(node.name)} = function
-${body}
-end function`;
+  const func = handleFunctionBodyAndParams(node, ctx);
+  return `${NodeHandler.handle(node.name)} = ${func.functionOutput}`;
 });
-NodeHandler.register(ts5.SyntaxKind.SetAccessor, (node) => {
+NodeHandler.register(ts6.SyntaxKind.SetAccessor, (node, ctx) => {
   if (!node.body)
     return "";
-  const body = NodeHandler.handle(node.body);
-  const params = node.parameters.map((param) => NodeHandler.handle(param));
-  return `set_${NodeHandler.handle(node.name)} = function(${params.join(", ")})
-${body}
-end function`;
+  const func = handleFunctionBodyAndParams(node, ctx);
+  return `set_${NodeHandler.handle(node.name)} = ${func.functionOutput}`;
 });
 
 // src/visitors/expressions.ts
-import ts7 from "typescript";
+import ts8 from "typescript";
 
 // src/call_transformers/callTransformer.ts
 import path3 from "node:path";
-import ts6 from "typescript";
+import ts7 from "typescript";
 class CallTransformer {
   static handlers = new Map;
   static register(symbolFullName, handler) {
@@ -587,7 +659,7 @@ CallTransformer.register("GreyHack.include", (_name, _args, node, ctx) => {
   if (!node.arguments.length)
     return "";
   const fileArg = node.arguments[0];
-  if (!ts6.isStringLiteralLike(fileArg))
+  if (!ts7.isStringLiteralLike(fileArg))
     throw "You can't include variables";
   const absPath = path3.resolve(ctx.currentFolder, fileArg.text);
   const sources = getSourceFiles(absPath);
@@ -620,7 +692,7 @@ function hasRestParam(params) {
   if (!params.length)
     return false;
   const lastParam = params[params.length - 1];
-  return !!(lastParam.valueDeclaration && ts7.isParameter(lastParam.valueDeclaration) && lastParam.valueDeclaration.dotDotDotToken);
+  return !!(lastParam.valueDeclaration && ts8.isParameter(lastParam.valueDeclaration) && lastParam.valueDeclaration.dotDotDotToken);
 }
 function handleCallArgs(callNode, ctx) {
   const args = callNode.arguments;
@@ -644,11 +716,11 @@ function handleCallArgs(callNode, ctx) {
     }
   }
   for (const arg of args) {
-    if (!ts7.isSpreadElement(arg)) {
+    if (!ts8.isSpreadElement(arg)) {
       pushArgs(false, NodeHandler.handle(arg));
       continue;
     }
-    if (ts7.isArrayLiteralExpression(arg.expression)) {
+    if (ts8.isArrayLiteralExpression(arg.expression)) {
       const arrayItems = [];
       const outArrs = [];
       handleArrayLiteralExpression(arg.expression, ctx, arrayItems, outArrs);
@@ -700,33 +772,35 @@ function handleCallArgs(callNode, ctx) {
     result.push("[]");
   return result;
 }
-NodeHandler.register(ts7.SyntaxKind.CallExpression, (node, ctx) => {
+NodeHandler.register(ts8.SyntaxKind.CallExpression, (node, ctx) => {
   const args = handleCallArgs(node, ctx);
   const name = NodeHandler.handle(node.expression);
   const type = checker.getTypeAtLocation(node.expression);
   const transformed = CallTransformer.handle(type, name, args, node, ctx);
   if (transformed !== null)
     return transformed;
-  if (!args.length && !ts7.isParenthesizedExpression(node.expression))
+  if (!args.length && !ts8.isParenthesizedExpression(node.expression))
     return name;
   return `${name}(${args.join(", ")})`;
 });
-NodeHandler.register(ts7.SyntaxKind.NewExpression, (node, ctx) => {
+NodeHandler.register(ts8.SyntaxKind.NewExpression, (node, ctx) => {
   const args = handleCallArgs(node, ctx);
   let output = `(new ${NodeHandler.handle(node.expression)}).constructor`;
   if (args.length)
     output += `(${args.join(",")})`;
   return output;
 });
-function shouldHaveOuterPrefix(node, operator) {
+function shouldHaveOuterPrefix(node, operator, ctx) {
   if (!assignmentOperators.has(operator))
     return false;
-  if (!ts7.isIdentifier(node.left))
+  if (!ts8.isIdentifier(node.left))
     return false;
-  const functionAncestor = ts7.findAncestor(node.parent, (n) => ts7.isFunctionLike(n));
+  if (ctx.forceOuterPrefix)
+    return true;
+  const functionAncestor = ts8.findAncestor(node.parent, (n) => ts8.isFunctionLike(n));
   if (!functionAncestor)
     return false;
-  if (!ts7.findAncestor(functionAncestor.parent, (n) => ts7.isFunctionLike(n)))
+  if (!ts8.findAncestor(functionAncestor.parent, (n) => ts8.isFunctionLike(n)))
     return false;
   const leftSymbol = checker.getSymbolAtLocation(node.left);
   if (!leftSymbol?.valueDeclaration)
@@ -736,26 +810,26 @@ function shouldHaveOuterPrefix(node, operator) {
 function isAssignmentChain(node, operator) {
   if (!assignmentOperators.has(operator))
     return false;
-  if (ts7.isBinaryExpression(node.right) && assignmentOperators.has(ts7.tokenToString(node.right.operatorToken.kind) || ""))
+  if (ts8.isBinaryExpression(node.right) && assignmentOperators.has(ts8.tokenToString(node.right.operatorToken.kind) || ""))
     return true;
-  if (ts7.hasOnlyExpressionInitializer(node.parent))
+  if (ts8.hasOnlyExpressionInitializer(node.parent))
     return true;
   return false;
 }
-NodeHandler.register(ts7.SyntaxKind.BinaryExpression, (node, ctx) => {
+NodeHandler.register(ts8.SyntaxKind.BinaryExpression, (node, ctx) => {
   let operatorToken = getOperatorToken(node.operatorToken) || node.operatorToken.getText();
   if (isAssignmentChain(node, operatorToken))
     throw `Assignment chaining is not supported`;
   let right = NodeHandler.handle(node.right);
   if (nodeIsFunctionReference(node.right))
     right = asRef(right);
-  if (ts7.isPropertyAccessExpression(node.left)) {
+  if (ts8.isPropertyAccessExpression(node.left)) {
     const leftType = checker.getTypeAtLocation(node.left.expression);
     const symbol = leftType.getProperty(node.left.name.text);
-    if (symbol?.declarations?.some((decl) => ts7.isSetAccessor(decl))) {
+    if (symbol?.declarations?.some((decl) => ts8.isSetAccessor(decl))) {
       const objName = NodeHandler.handle(node.left.expression);
       const key = node.left.name.text;
-      if (operatorToken !== "=" && symbol.declarations.some((decl) => ts7.isGetAccessor(decl)))
+      if (operatorToken !== "=" && symbol.declarations.some((decl) => ts8.isGetAccessor(decl)))
         throw `Can't handle '${operatorToken}' because '${objName}' doesn't have a getter '${key}'`;
       if (operatorToken === "+=" || operatorToken === "-=") {
         right = `${objName}.${key} ${operatorToken[0]} ${right}`;
@@ -766,11 +840,11 @@ NodeHandler.register(ts7.SyntaxKind.BinaryExpression, (node, ctx) => {
     }
   }
   let left = NodeHandler.handle(node.left);
-  if (shouldHaveOuterPrefix(node, operatorToken))
+  if (shouldHaveOuterPrefix(node, operatorToken, ctx))
     left = `outer.${left}`;
   if (nodeIsFunctionReference(node.left))
     left = asRef(left);
-  if (operatorToken === "or" && ts7.hasOnlyExpressionInitializer(node.parent)) {
+  if (operatorToken === "or" && ts8.hasOnlyExpressionInitializer(node.parent)) {
     return callUtilFunction("or_op", left, right);
   }
   switch (operatorToken) {
@@ -802,28 +876,37 @@ NodeHandler.register(ts7.SyntaxKind.BinaryExpression, (node, ctx) => {
       return `bitwise(">>", ${left}, ${right})`;
     case ">>>":
       return `bitwise(">>>", ${left}, ${right})`;
+    case "<<=":
+    case ">>=":
+    case ">>>=":
+      return `${left} = bitwise("${operatorToken.slice(0, -1)}", ${left}, ${right})`;
+    case "**=":
+      return `${left} = ${left} ^ ${right}`;
     case "+=":
     case "-=":
+    case "*=":
+    case "/=":
+    case "%=":
       return `${left} = ${left} ${operatorToken[0]} ${right}`;
   }
   if (operatorToken === "**")
     operatorToken = "^";
   return `${left} ${operatorToken} ${right}`;
 });
-NodeHandler.register(ts7.SyntaxKind.ParenthesizedExpression, (node) => {
+NodeHandler.register(ts8.SyntaxKind.ParenthesizedExpression, (node) => {
   return `(${NodeHandler.handle(node.expression)})`;
 });
 function handleUnaryExpression(node) {
   const operand = NodeHandler.handle(node.operand);
-  const operator = ts7.tokenToString(node.operator);
+  const operator = ts8.tokenToString(node.operator);
   switch (operator) {
     case "++":
     case "--":
-      if (ts7.hasOnlyExpressionInitializer(node.parent) || ts7.isBinaryExpression(node.parent))
+      if (ts8.hasOnlyExpressionInitializer(node.parent) || ts8.isBinaryExpression(node.parent))
         throw `Operator ${operator} is not supported for this kind of expression yet`;
       return `${operand} = ${operand} ${operator[0]} 1`;
     case "!":
-      if (ts7.isPrefixUnaryExpression(node.parent) && ts7.tokenToString(node.parent.operator) === "!") {
+      if (ts8.isPrefixUnaryExpression(node.parent) && ts8.tokenToString(node.parent.operator) === "!") {
         return `(not ${operand})`;
       }
       return `not ${operand}`;
@@ -837,17 +920,17 @@ function handleUnaryExpression(node) {
       throw `Couldn't handle this UnaryExpression: ${node.getText()}`;
   }
 }
-NodeHandler.register(ts7.SyntaxKind.PrefixUnaryExpression, handleUnaryExpression);
-NodeHandler.register(ts7.SyntaxKind.PostfixUnaryExpression, handleUnaryExpression);
+NodeHandler.register(ts8.SyntaxKind.PrefixUnaryExpression, handleUnaryExpression);
+NodeHandler.register(ts8.SyntaxKind.PostfixUnaryExpression, handleUnaryExpression);
 function handleArrayLiteralExpression(node, ctx, itemStrings, out) {
   itemStrings ??= [];
   out ??= [];
   for (const item of node.elements) {
-    if (!ts7.isSpreadElement(item)) {
+    if (!ts8.isSpreadElement(item)) {
       itemStrings.push(NodeHandler.handle(item));
       continue;
     }
-    if (ts7.isArrayLiteralExpression(item.expression)) {
+    if (ts8.isArrayLiteralExpression(item.expression)) {
       handleArrayLiteralExpression(item.expression, ctx, itemStrings, out);
       continue;
     }
@@ -857,14 +940,14 @@ function handleArrayLiteralExpression(node, ctx, itemStrings, out) {
     }
     out.push(NodeHandler.handle(item.expression));
   }
-  if ((!out.length || itemStrings.length) && !ts7.isSpreadElement(node.parent)) {
+  if ((!out.length || itemStrings.length) && !ts8.isSpreadElement(node.parent)) {
     out.push(`[${itemStrings.join(",")}]`);
     itemStrings.length = 0;
   }
   return out.join(" + ");
 }
-NodeHandler.register(ts7.SyntaxKind.ArrayLiteralExpression, handleArrayLiteralExpression);
-NodeHandler.register(ts7.SyntaxKind.TemplateExpression, (node) => {
+NodeHandler.register(ts8.SyntaxKind.ArrayLiteralExpression, handleArrayLiteralExpression);
+NodeHandler.register(ts8.SyntaxKind.TemplateExpression, (node) => {
   const head = NodeHandler.handle(node.head);
   const strings = [
     ...head ? [`"${head}"`] : [],
@@ -873,51 +956,54 @@ NodeHandler.register(ts7.SyntaxKind.TemplateExpression, (node) => {
   const output = strings.join(" + ");
   return output;
 });
-NodeHandler.register(ts7.SyntaxKind.TemplateHead, (node) => {
+NodeHandler.register(ts8.SyntaxKind.TemplateHead, (node) => {
   return transformString(node.text);
 });
-NodeHandler.register(ts7.SyntaxKind.TemplateSpan, (node) => {
+NodeHandler.register(ts8.SyntaxKind.TemplateSpan, (node) => {
   let output = NodeHandler.handle(node.expression);
-  if (ts7.isBinaryExpression(node.expression))
+  if (ts8.isBinaryExpression(node.expression))
     output = `str(${output})`;
   if (node.literal.text)
     output += ` + "${transformString(node.literal.text)}"`;
   return output;
 });
-NodeHandler.register(ts7.SyntaxKind.NoSubstitutionTemplateLiteral, (node) => {
+NodeHandler.register(ts8.SyntaxKind.NoSubstitutionTemplateLiteral, (node) => {
   return `"${transformString(node.text)}"`;
 });
-NodeHandler.register(ts7.SyntaxKind.ConditionalExpression, (node) => {
-  if (ts7.isCallExpression(node.whenTrue) || ts7.isCallExpression(node.whenFalse)) {
+NodeHandler.register(ts8.SyntaxKind.ConditionalExpression, (node) => {
+  if (ts8.isCallExpression(node.whenTrue) || ts8.isCallExpression(node.whenFalse)) {
     throw "Call expressions are not supported inside conditional expressions yet";
   }
+  if (ts8.isBinaryExpression(node.whenTrue) || ts8.isBinaryExpression(node.whenFalse)) {
+    throw "Binary expressions are not supported inside conditional expressions yet";
+  }
   const condition = NodeHandler.handle(node.condition);
   const whenTrue = NodeHandler.handle(node.whenTrue);
   const whenFalse = NodeHandler.handle(node.whenFalse);
   return callUtilFunction("conditional_expr", condition, whenTrue, whenFalse);
 });
-NodeHandler.register(ts7.SyntaxKind.ExpressionStatement, (node) => {
+NodeHandler.register(ts8.SyntaxKind.ExpressionStatement, (node) => {
   return NodeHandler.handle(node.expression);
 });
-NodeHandler.register(ts7.SyntaxKind.NonNullExpression, (node) => {
+NodeHandler.register(ts8.SyntaxKind.NonNullExpression, (node) => {
   return NodeHandler.handle(node.expression);
 });
-NodeHandler.register(ts7.SyntaxKind.AsExpression, (node) => {
+NodeHandler.register(ts8.SyntaxKind.AsExpression, (node) => {
   return NodeHandler.handle(node.expression);
 });
-NodeHandler.register(ts7.SyntaxKind.DeleteExpression, (node) => {
-  if (ts7.isPropertyAccessExpression(node.expression)) {
+NodeHandler.register(ts8.SyntaxKind.DeleteExpression, (node) => {
+  if (ts8.isPropertyAccessExpression(node.expression)) {
     const pnode = node.expression;
     const left = NodeHandler.handle(pnode.expression);
     const leftType = checker.getTypeAtLocation(pnode.expression);
     const right = replaceIdentifier(NodeHandler.handle(pnode.name), leftType, pnode.name.text);
     return `${left}.remove("${right}")`;
   }
-  if (ts7.isElementAccessExpression(node.expression)) {
+  if (ts8.isElementAccessExpression(node.expression)) {
     const pnode = node.expression;
     const left = NodeHandler.handle(pnode.expression);
     let right;
-    if (ts7.isStringLiteral(pnode.argumentExpression)) {
+    if (ts8.isStringLiteral(pnode.argumentExpression)) {
       const leftType = checker.getTypeAtLocation(pnode.expression);
       right = `"${replaceIdentifier(pnode.argumentExpression.text, leftType, pnode.argumentExpression.text)}"`;
     } else {
@@ -925,62 +1011,7 @@ NodeHandler.register(ts7.SyntaxKind.DeleteExpression, (node) => {
     }
     return `${left}.remove(${right})`;
   }
-  throw `Cant handle delete expression for ${ts7.SyntaxKind[node.expression.kind]}`;
-});
-
-// src/visitors/functions.ts
-import ts8 from "typescript";
-function transpileFunctionBody(node) {
-  const params = node.parameters.map((param) => NodeHandler.handle(param)).join(", ");
-  const body = node.body ? NodeHandler.handle(node.body) : "";
-  return `function(${params})
-${body}
-end function`;
-}
-NodeHandler.register(ts8.SyntaxKind.Block, (node) => {
-  const output = node.statements.map((val) => {
-    let statement = NodeHandler.handle(val);
-    statement = statement.split(`
-`).filter((s) => !!s).map((line) => `	${line}`).join(`
-`);
-    return statement;
-  }).filter((s) => !!s).join(`
-`);
-  return output;
-});
-NodeHandler.register(ts8.SyntaxKind.MethodDeclaration, (node) => {
-  return `${NodeHandler.handle(node.name)} = ${transpileFunctionBody(node)}`;
-});
-NodeHandler.register(ts8.SyntaxKind.FunctionDeclaration, (node) => {
-  if (!node.body)
-    return "";
-  if (node.modifiers?.some((m) => m.kind === ts8.SyntaxKind.DeclareKeyword))
-    return "";
-  const name = node.name ? node.name.text : "anon";
-  return `${name} = ${transpileFunctionBody(node)}`;
-});
-NodeHandler.register(ts8.SyntaxKind.ArrowFunction, (node) => {
-  const params = node.parameters.map((param) => NodeHandler.handle(param));
-  const body = ts8.isBlock(node.body) ? NodeHandler.handle(node.body) : `	return ${NodeHandler.handle(node.body)}`;
-  if (ts8.isCallOrNewExpression(node.parent) || ts8.isParenthesizedExpression(node.parent)) {
-    const mainNode = ts8.findAncestor(node.parent, (n) => n.parent && (ts8.isBlock(n.parent) || ts8.isSourceFile(n.parent)));
-    if (!mainNode) {
-      return `@${createAnonFunction(body, params).name}`;
-    }
-    const anon = createAnonFunction(body, params, false);
-    NodeHandler.addExtraOutput(mainNode, anon.str, null);
-    return `@${anon.name}`;
-  }
-  if (ts8.hasOnlyExpressionInitializer(node.parent) || ts8.isBinaryExpression(node.parent) || ts8.isReturnStatement(node.parent)) {
-    return `function(${params.join(", ")})
-${body}
-end function`;
-  }
-  const kind = ts8.SyntaxKind[node.parent.kind];
-  throw `This kind of arrow function is not yet supported (parent: ${kind} (${node.parent.kind}))`;
-});
-NodeHandler.register(ts8.SyntaxKind.FunctionExpression, (node) => {
-  return transpileFunctionBody(node);
+  throw `Cant handle delete expression for ${ts8.SyntaxKind[node.expression.kind]}`;
 });
 
 // src/visitors/identifiers.ts
@@ -998,14 +1029,22 @@ NodeHandler.register(ts9.SyntaxKind.Identifier, (node, ctx) => {
   if (ctx.namedImports[ctx.currentFilePath] && Object.hasOwn(ctx.namedImports[ctx.currentFilePath], name)) {
     name = ctx.namedImports[ctx.currentFilePath][name];
   }
+  if (Object.hasOwn(ctx.bindingElements, name)) {
+    return ctx.bindingElements[name];
+  }
   if (ts9.isCallOrNewExpression(node.parent) && node !== node.parent.expression) {
     if (nodeIsFunctionReference(node, type))
       name = asRef(name);
   }
   return name;
 });
-NodeHandler.register(ts9.SyntaxKind.Parameter, (node) => {
+NodeHandler.register(ts9.SyntaxKind.Parameter, (node, ctx) => {
   const name = NodeHandler.handle(node.name);
+  if (node.modifiers && ts9.isConstructorDeclaration(node.parent)) {
+    const paramName = name;
+    const declaration = `	self.${paramName} = ${paramName}`;
+    ctx.parameterProperties.push(declaration);
+  }
   if (!node.initializer)
     return name;
   const initializer = NodeHandler.handle(node.initializer);
@@ -1202,9 +1241,35 @@ ${funcs.map((func) => `${objectName}.${func}`).join(`
 }
 NodeHandler.register(ts11.SyntaxKind.ObjectLiteralExpression, handleObjectLiteralExpression);
 
-// src/visitors/statements.ts
+// src/visitors/patterns.ts
 import ts12 from "typescript";
-NodeHandler.register(ts12.SyntaxKind.ForStatement, (node) => {
+NodeHandler.register(ts12.SyntaxKind.ArrayBindingPattern, (node, ctx) => {
+  if (!ts12.isParameter(node.parent))
+    throw `This kind of ArrayBindingPattern is not yet supported (parent: ${ts12.SyntaxKind[node.parent.kind]})`;
+  const index = Object.entries(ctx.bindingElements).length;
+  const paramName = `arr${index || ""}`;
+  for (let i = 0;i < node.elements.length; i++) {
+    const element = node.elements[i];
+    if (ts12.isOmittedExpression(element))
+      continue;
+    const name = NodeHandler.handle(element);
+    if (!name || name === "null")
+      continue;
+    ctx.bindingElements[name] = `${paramName}[${i}]`;
+  }
+  return paramName;
+});
+NodeHandler.register(ts12.SyntaxKind.BindingElement, (node) => {
+  if (node.initializer)
+    throw "Initializers in BindingElement are not yet supported";
+  if (!ts12.isIdentifier(node.name))
+    throw "Nested binding patterns are not supported";
+  return NodeHandler.handle(node.name);
+});
+
+// src/visitors/statements.ts
+import ts13 from "typescript";
+NodeHandler.register(ts13.SyntaxKind.ForStatement, (node) => {
   if (!node.condition || !node.initializer || !node.incrementor) {
     throw "Can't transpile this type of for loop.";
   }
@@ -1214,7 +1279,7 @@ NodeHandler.register(ts12.SyntaxKind.ForStatement, (node) => {
   const statement = NodeHandler.handle(node.statement);
   function hasContinue(n) {
     if (n.getChildren().some((child) => {
-      if (ts12.isContinueStatement(child))
+      if (ts13.isContinueStatement(child))
         return true;
       return hasContinue(child);
     })) {
@@ -1222,7 +1287,7 @@ NodeHandler.register(ts12.SyntaxKind.ForStatement, (node) => {
     }
     return false;
   }
-  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
+  const labelIf = ts13.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   if (!hasContinue(node)) {
     return [
       `${initializer}`,
@@ -1253,8 +1318,8 @@ NodeHandler.register(ts12.SyntaxKind.ForStatement, (node) => {
 `);
   return output;
 });
-NodeHandler.register(ts12.SyntaxKind.ForOfStatement, (node) => {
-  if (!ts12.isVariableDeclarationList(node.initializer)) {
+NodeHandler.register(ts13.SyntaxKind.ForOfStatement, (node) => {
+  if (!ts13.isVariableDeclarationList(node.initializer)) {
     throw `Can't handle this 'for of' statement as '${NodeHandler.handle(node.initializer)}' is not initialized there`;
   }
   if (node.initializer.declarations.length > 1) {
@@ -1262,7 +1327,7 @@ NodeHandler.register(ts12.SyntaxKind.ForOfStatement, (node) => {
   }
   const varName = NodeHandler.handle(node.initializer.declarations[0].name);
   const objToLoop = NodeHandler.handle(node.expression);
-  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
+  const labelIf = ts13.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   return [
     `for ${varName} in ${objToLoop}`,
     `${NodeHandler.handle(node.statement)}`,
@@ -1271,8 +1336,8 @@ NodeHandler.register(ts12.SyntaxKind.ForOfStatement, (node) => {
   ].join(`
 `);
 });
-NodeHandler.register(ts12.SyntaxKind.ForInStatement, (node) => {
-  if (!ts12.isVariableDeclarationList(node.initializer)) {
+NodeHandler.register(ts13.SyntaxKind.ForInStatement, (node) => {
+  if (!ts13.isVariableDeclarationList(node.initializer)) {
     throw `Can't handle this 'for in' statement as '${NodeHandler.handle(node.initializer)}' is not initialized there`;
   }
   if (node.initializer.declarations.length > 1) {
@@ -1280,7 +1345,7 @@ NodeHandler.register(ts12.SyntaxKind.ForInStatement, (node) => {
   }
   const varName = NodeHandler.handle(node.initializer.declarations[0].name);
   const objToLoop = NodeHandler.handle(node.expression);
-  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
+  const labelIf = ts13.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   return [
     `for ${varName} in ${objToLoop}.indexes`,
     `${NodeHandler.handle(node.statement)}`,
@@ -1289,19 +1354,19 @@ NodeHandler.register(ts12.SyntaxKind.ForInStatement, (node) => {
   ].join(`
 `);
 });
-NodeHandler.register(ts12.SyntaxKind.IfStatement, (node) => {
+NodeHandler.register(ts13.SyntaxKind.IfStatement, (node) => {
   const condition = NodeHandler.handle(node.expression);
   const thenStatement = NodeHandler.handle(node.thenStatement);
-  if (!ts12.isBlock(node.thenStatement) && !ts12.isIfStatement(node.thenStatement) && !ts12.isIfStatement(node.parent)) {
+  if (!ts13.isBlock(node.thenStatement) && !ts13.isIfStatement(node.thenStatement) && !ts13.isIfStatement(node.parent)) {
     if (!node.elseStatement)
       return `if ${condition} then ${thenStatement}`;
-    else if (!ts12.isBlock(node.elseStatement) && !ts12.isIfStatement(node.elseStatement))
+    else if (!ts13.isBlock(node.elseStatement) && !ts13.isIfStatement(node.elseStatement))
       return `if ${condition} then ${thenStatement} else ${NodeHandler.handle(node.elseStatement)}`;
   }
   let output = `if ${condition} then
 	${thenStatement.trimStart()}`;
   if (node.elseStatement) {
-    if (ts12.isIfStatement(node.elseStatement)) {
+    if (ts13.isIfStatement(node.elseStatement)) {
       output += `
 else ${NodeHandler.handle(node.elseStatement)}`;
       return output;
@@ -1315,9 +1380,9 @@ else
 end if`;
   return output;
 });
-NodeHandler.register(ts12.SyntaxKind.WhileStatement, (node) => {
+NodeHandler.register(ts13.SyntaxKind.WhileStatement, (node) => {
   const expression = NodeHandler.handle(node.expression);
-  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
+  const labelIf = ts13.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   return [
     `while ${expression}`,
     `	${NodeHandler.handle(node.statement).trimStart()}`,
@@ -1326,9 +1391,9 @@ NodeHandler.register(ts12.SyntaxKind.WhileStatement, (node) => {
   ].join(`
 `);
 });
-NodeHandler.register(ts12.SyntaxKind.DoStatement, (node) => {
+NodeHandler.register(ts13.SyntaxKind.DoStatement, (node) => {
   const expression = NodeHandler.handle(node.expression);
-  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
+  const labelIf = ts13.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   return [
     `did_once = 0`,
     `while not did_once or ${expression}`,
@@ -1339,38 +1404,38 @@ NodeHandler.register(ts12.SyntaxKind.DoStatement, (node) => {
   ].join(`
 `);
 });
-NodeHandler.register(ts12.SyntaxKind.ContinueStatement, (_node) => {
+NodeHandler.register(ts13.SyntaxKind.ContinueStatement, (_node) => {
   return "continue";
 });
-NodeHandler.register(ts12.SyntaxKind.BreakStatement, (node) => {
+NodeHandler.register(ts13.SyntaxKind.BreakStatement, (node) => {
   if (node.label) {
-    if (!ts12.isBlock(node.parent))
+    if (!ts13.isBlock(node.parent))
       throw "A break statement with a label must be in a block";
     return `${NodeHandler.handle(node.label)}Broke = 1
 break`;
   }
   return "break";
 });
-NodeHandler.register(ts12.SyntaxKind.ReturnStatement, (node) => {
+NodeHandler.register(ts13.SyntaxKind.ReturnStatement, (node) => {
   if (!node.expression) {
-    if (ts12.findAncestor(node, (n) => ts12.isConstructorDeclaration(n)) && !ts12.findAncestor(node, (n) => ts12.isFunctionLike(n))) {
+    if (ts13.findAncestor(node, (n) => ts13.isConstructorDeclaration(n)) && !ts13.findAncestor(node, (n) => ts13.isFunctionLike(n))) {
       return "return self";
     }
     return "return";
   }
   return `return ${NodeHandler.handle(node.expression)}`;
 });
-NodeHandler.register(ts12.SyntaxKind.LabeledStatement, (node) => {
+NodeHandler.register(ts13.SyntaxKind.LabeledStatement, (node) => {
   return `${NodeHandler.handle(node.label)}Broke = 0
 ${NodeHandler.handle(node.statement)}`;
 });
 
 // src/visitors/variables.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 function handleVariableDeclaration(node) {
   const left = NodeHandler.handle(node.name);
   const initializerType = node.initializer ? checker.getTypeAtLocation(node.initializer) : undefined;
-  if (ts13.isPropertyDeclaration(node) && initializerType?.flags === ts13.TypeFlags.Object && !node.modifiers?.some((mod) => mod.kind === ts13.SyntaxKind.StaticKeyword) && !ts13.isFunctionLike(node.initializer)) {
+  if (ts14.isPropertyDeclaration(node) && initializerType?.flags === ts14.TypeFlags.Object && !node.modifiers?.some((mod) => mod.kind === ts14.SyntaxKind.StaticKeyword) && !ts14.isFunctionLike(node.initializer)) {
     console.warn(`You shouldn't initialize '${left}' with an Array or an Object because in GreyScript, every instantiation refers to the same '${left}' variable.
 Initialize them in the constructor instead`);
   }
@@ -1380,18 +1445,18 @@ Initialize them in the constructor instead`);
   }
   return `${left} = ${right}`;
 }
-NodeHandler.register(ts13.SyntaxKind.VariableDeclarationList, (node) => {
+NodeHandler.register(ts14.SyntaxKind.VariableDeclarationList, (node) => {
   return node.declarations.map((decl) => handleVariableDeclaration(decl)).join(`
 `);
 });
-NodeHandler.register(ts13.SyntaxKind.VariableStatement, (node) => {
-  if (node.modifiers?.some((modifier) => modifier.kind === ts13.SyntaxKind.DeclareKeyword))
+NodeHandler.register(ts14.SyntaxKind.VariableStatement, (node) => {
+  if (node.modifiers?.some((modifier) => modifier.kind === ts14.SyntaxKind.DeclareKeyword))
     return "";
   return NodeHandler.handle(node.declarationList);
 });
-NodeHandler.register(ts13.SyntaxKind.VariableDeclaration, handleVariableDeclaration);
-NodeHandler.register(ts13.SyntaxKind.PropertyDeclaration, handleVariableDeclaration);
-NodeHandler.register(ts13.SyntaxKind.EnumDeclaration, (node) => {
+NodeHandler.register(ts14.SyntaxKind.VariableDeclaration, handleVariableDeclaration);
+NodeHandler.register(ts14.SyntaxKind.PropertyDeclaration, handleVariableDeclaration);
+NodeHandler.register(ts14.SyntaxKind.EnumDeclaration, (node) => {
   const members = [];
   function addMember(name, initializer) {
     members.push(`${name}: ${initializer}`);
@@ -1401,7 +1466,7 @@ NodeHandler.register(ts13.SyntaxKind.EnumDeclaration, (node) => {
   }
   node.members.forEach((member, index) => {
     let name = NodeHandler.handle(member.name);
-    if (!ts13.isStringLiteral(member.name))
+    if (!ts14.isStringLiteral(member.name))
       name = `"${name}"`;
     if (member.initializer) {
       addMember(name, NodeHandler.handle(member.initializer));
@@ -1880,9 +1945,12 @@ function createAnonFunction(body, params, insertToUtils = true) {
   const defaultParams = new Array(3).fill(0).map((_, i) => `param${i}`);
   const nextName = `func_${anonFunctionsCreated}`;
   const paramString = Object.assign(defaultParams, params).join(",");
-  const result = `${nextName} = function(${paramString})
-${body}
-end function`;
+  const result = [
+    `${nextName} = function(${paramString})`,
+    ...body ? [body] : [],
+    `end function`
+  ].join(`
+`);
   anonFunctionsCreated++;
   if (insertToUtils)
     utilitiesToInsert.set(nextName, result);
@@ -1896,7 +1964,9 @@ function createContext(currentFileName = "file.ts") {
     namespaceImports: {},
     visitedFiles: new Set,
     output: [],
-    extraOutput: new Map
+    extraOutput: new Map,
+    bindingElements: {},
+    parameterProperties: []
   };
 }
 function transpileProgram(entryFileRelativePath) {
@@ -1909,15 +1979,15 @@ function transpileProgram(entryFileRelativePath) {
   }
   let start = Date.now();
   const tsconfigPath = `${findProjectRoot(process.cwd(), "tsconfig.json")}/tsconfig.json`;
-  const res = ts14.readConfigFile(tsconfigPath, ts14.sys.readFile);
-  const parsed = ts14.parseJsonConfigFileContent(res.config, ts14.sys, path5.dirname(tsconfigPath));
+  const res = ts15.readConfigFile(tsconfigPath, ts15.sys.readFile);
+  const parsed = ts15.parseJsonConfigFileContent(res.config, ts15.sys, path5.dirname(tsconfigPath));
   if (!parsed.options.types)
     parsed.options.types = [];
   if (!parsed.options.types.includes("@grey-ts/types")) {
     parsed.options.types.push("@grey-ts/types");
   }
   parsed.options.noLib = true;
-  program = ts14.createProgram({
+  program = ts15.createProgram({
     rootNames: parsed.fileNames,
     options: parsed.options
   });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@grey-ts/transpiler",
-	"version": "2.0.0",
+	"version": "2.1.0",
 	"description": "Transpiles TypeScript into GreyScript",
 	"author": "Okka",
 	"module": "src/index.ts",