@grey-ts/transpiler 1.1.1 → 1.2.0

package/dist/index.js

@@ -44,6 +44,7 @@ class NodeHandler {
 }
 NodeHandler.register(ts.SyntaxKind.TypeAliasDeclaration, () => "");
 NodeHandler.register(ts.SyntaxKind.InterfaceDeclaration, () => "");
+NodeHandler.register(ts.SyntaxKind.ModuleDeclaration, () => "");
 NodeHandler.register(ts.SyntaxKind.EndOfFileToken, () => "");
 NodeHandler.register(ts.SyntaxKind.EmptyStatement, () => "");
 
@@ -415,20 +416,28 @@ NodeHandler.register(ts5.SyntaxKind.ClassDeclaration, (node) => {
   let output = `${name} = {}`;
   if (extensions && 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.isMethodDeclaration(member) || ts5.isConstructorDeclaration(member)) {
-      if (!member.body)
-        continue;
-      output += `
-${name}.${NodeHandler.handle(member)}`;
-    } else if (ts5.isPropertyDeclaration(member)) {
-      output += `
-${name}.${NodeHandler.handle(member)}`;
-    } else {
-      output += `
-${name}.${NodeHandler.handle(member)}`;
+    if (ts5.isFunctionLike(member) && "body" in member && !member.body)
+      continue;
+    if (member.name) {
+      const memberName = NodeHandler.handle(member.name);
+      if (declaredNames.has(memberName))
+        throw `The transpiled version of class '${name}' has a duplicate member '${memberName}'.
+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))
+      hasConstructor = true;
+    output += `
+${name}.${NodeHandler.handle(member)}`;
   }
+  if (!hasConstructor && !node.modifiers?.some((m) => m.kind === ts5.SyntaxKind.AbstractKeyword))
+    output += `
+${name}.constructor = function
+	return self
+end function`;
   return output;
 });
 NodeHandler.register(ts5.SyntaxKind.Constructor, (node) => {
@@ -598,14 +607,7 @@ NodeHandler.register(ts7.SyntaxKind.ElementAccessExpression, (node, ctx) => {
   } else {
     right = NodeHandler.handle(node.argumentExpression);
   }
-  const asd = ts7.findAncestor(node, (ancestor) => {
-    if (ancestor.parent && ts7.isBinaryExpression(ancestor.parent) && ancestor === ancestor.parent.left) {
-      const token = ts7.tokenToString(ancestor.parent.operatorToken.kind) || ancestor.parent.operatorToken.getText();
-      return assignmentOperators.has(token);
-    }
-    return false;
-  });
-  if (!asd && !ts7.isNumericLiteral(node.argumentExpression)) {
+  if (!valueIsBeingAssignedToNode(node) && !ts7.isNumericLiteral(node.argumentExpression)) {
     return callUtilFunction("get_property", left, `${right}`);
   }
   return `${left}[${right}]`;
@@ -614,7 +616,7 @@ function handleObjectLiteralExpression(node, ctx, currObj, outObjects, funcs) {
   currObj ??= [];
   outObjects ??= [];
   funcs ??= [];
-  const objectName = ts7.isVariableDeclaration(node.parent) ? NodeHandler.handle(node.parent.name) : ts7.isBinaryExpression(node.parent) && node === node.parent.right ? NodeHandler.handle(node.parent.left) : "";
+  const objectName = ts7.hasOnlyExpressionInitializer(node.parent) ? NodeHandler.handle(node.parent.name) : ts7.isBinaryExpression(node.parent) && node === node.parent.right ? NodeHandler.handle(node.parent.left) : "";
   function pushObj() {
     if (!currObj?.length)
       return "";
@@ -970,13 +972,26 @@ NodeHandler.register(ts8.SyntaxKind.AsExpression, (node) => {
   return NodeHandler.handle(node.expression);
 });
 NodeHandler.register(ts8.SyntaxKind.DeleteExpression, (node) => {
-  if (!ts8.isPropertyAccessExpression(node.expression))
-    throw `Cant handle delete expression for ${ts8.SyntaxKind[node.expression.kind]}`;
-  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 (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 (ts8.isElementAccessExpression(node.expression)) {
+    const pnode = node.expression;
+    const left = NodeHandler.handle(pnode.expression);
+    let right;
+    if (ts8.isStringLiteral(pnode.argumentExpression)) {
+      const leftType = checker.getTypeAtLocation(pnode.expression);
+      right = `"${replaceIdentifier(pnode.argumentExpression.text, leftType, pnode.argumentExpression.text)}"`;
+    } else {
+      right = NodeHandler.handle(pnode.argumentExpression);
+    }
+    return `${left}.remove(${right})`;
+  }
+  throw `Cant handle delete expression for ${ts8.SyntaxKind[node.expression.kind]}`;
 });
 
 // src/visitors/functions.ts
@@ -1016,7 +1031,7 @@ NodeHandler.register(ts9.SyntaxKind.ArrowFunction, (node) => {
   if (ts9.isCallOrNewExpression(node.parent) || ts9.isParenthesizedExpression(node.parent)) {
     return "@" + createAnonFunction(body, params).name;
   }
-  if (ts9.isPropertyAssignment(node.parent) || ts9.isVariableDeclaration(node.parent) || ts9.isBinaryExpression(node.parent) || ts9.isReturnStatement(node.parent)) {
+  if (ts9.hasOnlyExpressionInitializer(node.parent) || ts9.isBinaryExpression(node.parent) || ts9.isReturnStatement(node.parent)) {
     return `function(${params.join(", ")})
 ${body}
 end function`;
@@ -1165,11 +1180,13 @@ NodeHandler.register(ts12.SyntaxKind.ForStatement, (node) => {
     }
     return false;
   }
+  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   if (!hasContinue(node)) {
     return [
       `${initializer}`,
       `while ${condition}`,
       `	${statement.trimStart()}`,
+      ...labelIf ? [labelIf] : [],
       `	${incrementor}`,
       `end while`
     ].join(`
@@ -1186,6 +1203,7 @@ NodeHandler.register(ts12.SyntaxKind.ForStatement, (node) => {
     `	end if`,
     `	${incrementedStateVarName} = 0`,
     `	${statement.trimStart()}`,
+    ...labelIf ? [labelIf] : [],
     `	${incrementor}`,
     `	${incrementedStateVarName} = 1`,
     `end while`
@@ -1202,9 +1220,14 @@ NodeHandler.register(ts12.SyntaxKind.ForOfStatement, (node) => {
   }
   const varName = NodeHandler.handle(node.initializer.declarations[0].name);
   const objToLoop = NodeHandler.handle(node.expression);
-  return `for ${varName} in ${objToLoop}
-${NodeHandler.handle(node.statement)}
-end for`;
+  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
+  return [
+    `for ${varName} in ${objToLoop}`,
+    `${NodeHandler.handle(node.statement)}`,
+    ...labelIf ? [labelIf] : [],
+    `end for`
+  ].join(`
+`);
 });
 NodeHandler.register(ts12.SyntaxKind.ForInStatement, (node) => {
   if (!ts12.isVariableDeclarationList(node.initializer)) {
@@ -1215,9 +1238,14 @@ NodeHandler.register(ts12.SyntaxKind.ForInStatement, (node) => {
   }
   const varName = NodeHandler.handle(node.initializer.declarations[0].name);
   const objToLoop = NodeHandler.handle(node.expression);
-  return `for ${varName} in ${objToLoop}.indexes
-${NodeHandler.handle(node.statement)}
-end for`;
+  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
+  return [
+    `for ${varName} in ${objToLoop}.indexes`,
+    `${NodeHandler.handle(node.statement)}`,
+    ...labelIf ? [labelIf] : [],
+    `end for`
+  ].join(`
+`);
 });
 NodeHandler.register(ts12.SyntaxKind.IfStatement, (node) => {
   const condition = NodeHandler.handle(node.expression);
@@ -1247,20 +1275,24 @@ end if`;
 });
 NodeHandler.register(ts12.SyntaxKind.WhileStatement, (node, ctx) => {
   const expression = NodeHandler.handle(node.expression);
+  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   return [
     `while ${expression}`,
     `	${NodeHandler.handle(node.statement).trimStart()}`,
+    ...labelIf ? [labelIf] : [],
     `end while`
   ].join(`
 `);
 });
 NodeHandler.register(ts12.SyntaxKind.DoStatement, (node, ctx) => {
   const expression = NodeHandler.handle(node.expression);
+  const labelIf = ts12.isLabeledStatement(node.parent) ? `	if ${node.parent.label.text}Broke then break` : "";
   return [
     `did_once = 0`,
     `while not did_once or ${expression}`,
     `	did_once = 1`,
     `	${NodeHandler.handle(node.statement).trimStart()}`,
+    ...labelIf ? [labelIf] : [],
     `end while`
   ].join(`
 `);
@@ -1269,6 +1301,12 @@ NodeHandler.register(ts12.SyntaxKind.ContinueStatement, (node) => {
   return "continue";
 });
 NodeHandler.register(ts12.SyntaxKind.BreakStatement, (node) => {
+  if (node.label) {
+    if (!ts12.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) => {
@@ -1280,13 +1318,17 @@ NodeHandler.register(ts12.SyntaxKind.ReturnStatement, (node) => {
   }
   return `return ${NodeHandler.handle(node.expression)}`;
 });
+NodeHandler.register(ts12.SyntaxKind.LabeledStatement, (node) => {
+  return `${NodeHandler.handle(node.label)}Broke = 0
+${NodeHandler.handle(node.statement)}`;
+});
 
 // src/visitors/variables.ts
 import ts13 from "typescript";
 function handleVariableDeclaration(node, ctx) {
   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)) {
+  if (ts13.isPropertyDeclaration(node) && initializerType?.flags === ts13.TypeFlags.Object && !node.modifiers?.some((mod) => mod.kind === ts13.SyntaxKind.StaticKeyword) && !ts13.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`);
   }
@@ -1308,16 +1350,27 @@ NodeHandler.register(ts13.SyntaxKind.VariableStatement, (node, ctx) => {
 NodeHandler.register(ts13.SyntaxKind.VariableDeclaration, handleVariableDeclaration);
 NodeHandler.register(ts13.SyntaxKind.PropertyDeclaration, handleVariableDeclaration);
 NodeHandler.register(ts13.SyntaxKind.EnumDeclaration, (node) => {
-  const members = node.members.map((member, index) => {
-    const name = NodeHandler.handle(member.name);
+  const members = [];
+  function addMember(name, initializer) {
+    members.push(`${name}: ${initializer}`);
+    if (isNaN(+initializer))
+      return;
+    members.push(`${initializer}: ${name}`);
+  }
+  node.members.forEach((member, index) => {
+    let name = NodeHandler.handle(member.name);
+    if (!ts13.isStringLiteral(member.name))
+      name = `"${name}"`;
     if (member.initializer) {
-      return `${name}: ${NodeHandler.handle(member.initializer)}`;
+      addMember(name, NodeHandler.handle(member.initializer));
+      return;
     }
     const type = checker.getTypeAtLocation(member);
     if ("value" in type) {
-      return `${name}: ${type.value}`;
+      addMember(name, String(type.value));
+      return;
     }
-    return `${name}: ${index}`;
+    addMember(name, index.toString());
   });
   return `${node.name.text} = { ${members.join(", ")} }`;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@grey-ts/transpiler",
-	"version": "1.1.1",
+	"version": "1.2.0",
 	"description": "Transpiles TypeScript into GreyScript",
 	"author": "Okka",
 	"module": "src/index.ts",
@@ -40,6 +40,6 @@
 		"typescript": "^5"
 	},
 	"dependencies": {
-		"@grey-ts/types": "^2.0.0"
+		"@grey-ts/types": "^2.0.1"
 	}
 }