@grey-ts/transpiler 1.4.2 → 1.4.4

package/dist/index.js

@@ -2,16 +2,16 @@
 
 // src/index.ts
 import * as fs3 from "node:fs";
-import path5 from "node:path";
+import path6 from "node:path";
 
 // src/transpiler.ts
 import * as fs2 from "node:fs";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 import ts14 from "typescript";
 
 // src/nodeHandler.ts
+import * as path from "node:path";
 import ts from "typescript";
-
 class NodeHandler {
   static handlers = new Map;
   static transpileContext;
@@ -29,13 +29,30 @@ class NodeHandler {
     }
     try {
       const result = handler(node, this.transpileContext);
-      return result;
+      const extra = this.transpileContext.extraOutput.get(node);
+      if (!extra)
+        return result;
+      return [
+        ...extra.before ? [extra.before] : [],
+        result,
+        ...extra.after ? [extra.after] : []
+      ].join(`
+`);
     } catch (error) {
       console.error(error);
       this.printLineAndCol(node);
       return ts.isBlock(node.parent) || ts.isSourceFile(node.parent) ? "" : "null";
     }
   }
+  static addExtraOutput(node, before, after) {
+    if (!this.transpileContext.extraOutput.has(node))
+      this.transpileContext.extraOutput.set(node, { before: "", after: "" });
+    const extra = this.transpileContext.extraOutput.get(node);
+    if (before)
+      extra.before += before;
+    if (after)
+      extra.after += after;
+  }
   static printLineAndCol(node) {
     const source = node.getSourceFile();
     const lineAndChar = source.getLineAndCharacterOfPosition(node.pos);
@@ -47,6 +64,29 @@ NodeHandler.register(ts.SyntaxKind.InterfaceDeclaration, () => "");
 NodeHandler.register(ts.SyntaxKind.ModuleDeclaration, () => "");
 NodeHandler.register(ts.SyntaxKind.EndOfFileToken, () => "");
 NodeHandler.register(ts.SyntaxKind.EmptyStatement, () => "");
+NodeHandler.register(ts.SyntaxKind.SourceFile, (sourceFile, ctx) => {
+  if (ctx.visitedFiles.has(sourceFile.fileName))
+    return "";
+  ctx.visitedFiles.add(sourceFile.fileName);
+  if (sourceFile.isDeclarationFile)
+    return "";
+  if (program.isSourceFileDefaultLibrary(sourceFile) || program.isSourceFileFromExternalLibrary(sourceFile))
+    return "";
+  const prevFile = ctx.currentFilePath;
+  ctx.currentFilePath = sourceFile.fileName;
+  ctx.currentFolder = path.dirname(sourceFile.fileName);
+  ctx.namedImports[sourceFile.fileName] = {};
+  ctx.namespaceImports[sourceFile.fileName] = new Set;
+  sourceFile.forEachChild((node) => {
+    const result = NodeHandler.handle(node);
+    if (!result)
+      return;
+    ctx.output.push(result);
+  });
+  ctx.currentFilePath = prevFile;
+  ctx.currentFolder = path.dirname(prevFile);
+  return "";
+});
 
 // src/parser.ts
 import ts2 from "typescript";
@@ -57,7 +97,7 @@ var parser_default = parseCode;
 
 // src/utils.ts
 import fs from "node:fs";
-import path from "node:path";
+import path2 from "node:path";
 import ts3 from "typescript";
 
 // src/replaceKeywords.ts
@@ -326,7 +366,7 @@ function getSourceFiles(absPath) {
     const file = filePaths.shift();
     const stat = fs.statSync(file);
     if (stat.isDirectory()) {
-      filePaths.push(...fs.readdirSync(file).map((name) => path.join(file, name)));
+      filePaths.push(...fs.readdirSync(file).map((name) => path2.join(file, name)));
       continue;
     }
     const existing = program.getSourceFile(file);
@@ -376,8 +416,8 @@ function replacePropertyAccess(original, symbol) {
   return replaceValue;
 }
 function findProjectRoot(dir, fileToSearch = "package.json") {
-  while (!fs.existsSync(path.join(dir, fileToSearch))) {
-    const parent = path.dirname(dir);
+  while (!fs.existsSync(path2.join(dir, fileToSearch))) {
+    const parent = path2.dirname(dir);
     if (parent === dir)
       throw new Error(`No ${fileToSearch} found`);
     dir = parent;
@@ -441,6 +481,8 @@ NodeHandler.register(ts5.SyntaxKind.ClassDeclaration, (node) => {
   for (const member of node.members) {
     if (ts5.isFunctionLike(member) && "body" in member && !member.body)
       continue;
+    if (ts5.isSemicolonClassElement(member))
+      continue;
     if (member.name) {
       const memberName = NodeHandler.handle(member.name);
       if (declaredNames.has(memberName))
@@ -518,7 +560,7 @@ end function`;
 import ts7 from "typescript";
 
 // src/call_transformers/callTransformer.ts
-import path2 from "node:path";
+import path3 from "node:path";
 import ts6 from "typescript";
 class CallTransformer {
   static handlers = new Map;
@@ -555,10 +597,10 @@ CallTransformer.register("GreyHack.include", (name, args, node, ctx) => {
   const fileArg = node.arguments[0];
   if (!ts6.isStringLiteralLike(fileArg))
     throw "You can't include variables";
-  const absPath = path2.resolve(ctx.currentFolder, fileArg.text);
+  const absPath = path3.resolve(ctx.currentFolder, fileArg.text);
   const sources = getSourceFiles(absPath);
   for (const source of sources) {
-    transpileSourceFile(source, ctx);
+    NodeHandler.handle(source);
   }
   return "";
 });
@@ -678,7 +720,7 @@ NodeHandler.register(ts7.SyntaxKind.CallExpression, (node, ctx) => {
   const transformed = CallTransformer.handle(symbolFullName, name, args, node, ctx);
   if (transformed !== null)
     return transformed;
-  if (!args.length)
+  if (!args.length && !ts7.isParenthesizedExpression(node.expression))
     return name;
   return `${name}(${args.join(", ")})`;
 });
@@ -702,7 +744,7 @@ function shouldHaveOuterPrefix(node, operator) {
   const leftSymbol = checker.getSymbolAtLocation(node.left);
   if (!leftSymbol?.valueDeclaration)
     return false;
-  return leftSymbol.valueDeclaration.pos < functionAncestor.pos || leftSymbol.valueDeclaration.pos > functionAncestor.end;
+  return leftSymbol.valueDeclaration.end < functionAncestor.pos || leftSymbol.valueDeclaration.pos > functionAncestor.end;
 }
 function isAssignmentChain(node, operator) {
   if (!assignmentOperators.has(operator))
@@ -904,10 +946,10 @@ NodeHandler.register(ts8.SyntaxKind.Block, (node) => {
   const output = node.statements.map((val) => {
     let statement = NodeHandler.handle(val);
     statement = statement.split(`
-`).map((line) => "\t" + line).join(`
+`).filter((s) => !!s).map((line) => "\t" + line).join(`
 `);
     return statement;
-  }).join(`
+  }).filter((s) => !!s).join(`
 `);
   return output;
 });
@@ -926,7 +968,13 @@ 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)) {
-    return "@" + createAnonFunction(body, params).name;
+    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(", ")})
@@ -1007,35 +1055,23 @@ NodeHandler.register(ts9.SyntaxKind.RegularExpressionLiteral, (node) => {
 });
 
 // src/visitors/imports.ts
-import path3 from "node:path";
+import path4 from "node:path";
 import ts10 from "typescript";
-function importFile(filePath, ctx, returnResult) {
-  let srcPath = path3.resolve(ctx.currentFolder, filePath);
-  if (!path3.extname(srcPath))
+function importFile(filePath, ctx) {
+  let srcPath = path4.resolve(ctx.currentFolder, filePath);
+  if (!path4.extname(srcPath))
     srcPath += ".ts";
   const source = program.getSourceFile(srcPath);
   if (!source) {
     console.error(`Failed to find source ${srcPath}`);
     return "";
   }
-  return transpileSourceFile(source, ctx, returnResult);
+  return NodeHandler.handle(source);
 }
 NodeHandler.register(ts10.SyntaxKind.ImportDeclaration, (node, ctx) => {
   if (!node.importClause) {
     const moduleName = node.moduleSpecifier.text;
-    const transpiledFile = importFile(moduleName, ctx, true);
-    if (!transpiledFile)
-      return "";
-    const rndName = "func_" + (Date.now() * Math.random()).toString().slice(0, 6);
-    return [
-      `${rndName} = function`,
-      transpiledFile.split(`
-`).map((line) => "\t" + line).join(`
-`),
-      "end function",
-      `${rndName}()`
-    ].join(`
-`);
+    return importFile(moduleName, ctx);
   }
   if (node.importClause.phaseModifier)
     return "";
@@ -1756,27 +1792,34 @@ end function`,
 	return when_false
 end function`
 };
-function createAnonFunction(body, params) {
+var anonFunctionsCreated = 0;
+function createAnonFunction(body, params, insertToUtils = true) {
   const defaultParams = new Array(3).fill(0).map((_, i) => `param${i}`);
-  const nextName = `func_${utilitiesToInsert.size}`;
+  const nextName = `func_${anonFunctionsCreated}`;
   const paramString = Object.assign(defaultParams, params).join(",");
   const result = `${nextName} = function(${paramString})
 ${body}
 end function`;
-  utilitiesToInsert.set(nextName, result);
+  anonFunctionsCreated++;
+  if (insertToUtils)
+    utilitiesToInsert.set(nextName, result);
   return { name: nextName, str: result };
 }
-function transpileProgram(entryFileRelativePath) {
-  const ctx = {
-    currentFolder: "",
-    currentFilePath: path4.resolve(process.cwd(), entryFileRelativePath),
+function createContext(currentFileName = "file.ts") {
+  return {
+    currentFolder: process.cwd(),
+    currentFilePath: path5.resolve(process.cwd(), currentFileName),
     namedImports: {},
     namespaceImports: {},
-    visitedFiles: {},
-    output: []
+    visitedFiles: new Set,
+    output: [],
+    extraOutput: new Map
   };
+}
+function transpileProgram(entryFileRelativePath) {
+  const ctx = createContext(entryFileRelativePath);
   NodeHandler.transpileContext = ctx;
-  ctx.currentFolder = path4.dirname(ctx.currentFilePath);
+  ctx.currentFolder = path5.dirname(ctx.currentFilePath);
   if (!fs2.existsSync(ctx.currentFilePath)) {
     console.error(`Error: file '${ctx.currentFilePath}' doesn't exist`);
     process.exit(1);
@@ -1784,7 +1827,7 @@ 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, path4.dirname(tsconfigPath));
+  const parsed = ts14.parseJsonConfigFileContent(res.config, ts14.sys, path5.dirname(tsconfigPath));
   if (!parsed.options.types)
     parsed.options.types = [];
   if (!parsed.options.types.includes("@grey-ts/types")) {
@@ -1803,7 +1846,7 @@ function transpileProgram(entryFileRelativePath) {
     console.error(`Error: failed to find '${ctx.currentFilePath}' from the included sources`);
     process.exit(1);
   }
-  transpileSourceFile(entry, ctx);
+  NodeHandler.handle(entry);
   if (utilitiesToInsert.size) {
     ctx.output.unshift(...utilitiesToInsert.values());
     utilitiesToInsert.clear();
@@ -1811,34 +1854,6 @@ function transpileProgram(entryFileRelativePath) {
   console.log(`Transpiling took ${Date.now() - start} ms`);
   return ctx.output;
 }
-function transpileSourceFile(sourceFile, ctx, returnResult) {
-  if (ctx.visitedFiles[sourceFile.fileName])
-    return "";
-  ctx.visitedFiles[sourceFile.fileName] = true;
-  if (sourceFile.isDeclarationFile)
-    return "";
-  if (program.isSourceFileDefaultLibrary(sourceFile) || program.isSourceFileFromExternalLibrary(sourceFile))
-    return "";
-  const prevFile = ctx.currentFilePath;
-  ctx.currentFilePath = sourceFile.fileName;
-  ctx.currentFolder = path4.dirname(sourceFile.fileName);
-  ctx.namedImports[sourceFile.fileName] = {};
-  ctx.namespaceImports[sourceFile.fileName] = new Set;
-  const output = [];
-  sourceFile.forEachChild((node) => {
-    const result = NodeHandler.handle(node);
-    if (!result)
-      return;
-    if (!returnResult)
-      ctx.output.push(result);
-    else
-      output.push(result);
-  });
-  ctx.currentFilePath = prevFile;
-  ctx.currentFolder = path4.dirname(prevFile);
-  return output.join(`
-`);
-}
 
 // src/index.ts
 var noMoreFlags = false;
@@ -1870,7 +1885,7 @@ function createOutputFile(fileIndex, basename, content) {
   if (fileIndex > 0)
     basename = `${basename}-${fileIndex}`;
   const outFileName = args.length > 1 ? args[1] : `${basename}.src`;
-  const outFilePath = path5.join(outDirPath, outFileName);
+  const outFilePath = path6.join(outDirPath, outFileName);
   fs3.writeFileSync(outFilePath, content);
 }
 if (command === "transpile") {
@@ -1879,7 +1894,7 @@ if (command === "transpile") {
     process.exit(2);
   }
   const entryFile = args[0];
-  const basename = path5.basename(entryFile, ".ts");
+  const basename = path6.basename(entryFile, ".ts");
   const transpiledStatements = transpileProgram(entryFile);
   if (flags.includes("--print") || flags.includes("-p")) {
     console.log(transpiledStatements.join(`

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@grey-ts/transpiler",
-	"version": "1.4.2",
+	"version": "1.4.4",
 	"description": "Transpiles TypeScript into GreyScript",
 	"author": "Okka",
 	"module": "src/index.ts",
@@ -31,7 +31,7 @@
 	],
 	"scripts": {
 		"prepare": "bun run build",
-		"build": "bun run scripts/build.ts"
+		"build": "bun test --only-failures && bun run scripts/build.ts"
 	},
 	"devDependencies": {
 		"@types/bun": "latest",