naider 1.15.0 → 1.17.0

package/src/generator-dart.js

@@ -162,6 +162,8 @@ export class DartGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`// unknown: ${node.type}`);
     }
@@ -1364,6 +1366,12 @@ export class DartGenerator {
   generateCall(node) {
     const args = node.args.map(a => this.expr(a)).join(', ');
 
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     if (node.callee.type === 'Identifier') {
       const name = node.callee.name;
       if (name === 'parseInt') return `int.parse(${args})`;
@@ -1566,4 +1574,65 @@ export class DartGenerator {
     this.inFunction = wasInFunction;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`enum ${node.name} {`);
+    this.indent++;
+    node.values.forEach(v => {
+      this.emit(`${v.toLowerCase()},`);
+    });
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`{ final _tmp = ${a}; ${a} = ${b}; ${b} = _tmp; }`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.length`;
+      case 'sort': return `(List.from(${args[0]})..sort())`;
+      case 'reverse': return `${args[0]}.reversed.toList()`;
+      case 'unique': return `${args[0]}.toSet().toList()`;
+      case 'upper': return `${args[0]}.toUpperCase()`;
+      case 'lower': return `${args[0]}.toLowerCase()`;
+      case 'trim': return `${args[0]}.trim()`;
+      case 'split': return `${args[0]}.split(${args[1] || '","'})`;
+      case 'join': return `${args[0]}.join(${args[1] || '","'})`;
+      case 'contains': return `${args[0]}.contains(${args[1]})`;
+      case 'replace': return `${args[0]}.replaceAll(${args[1]}, ${args[2]})`;
+      case 'keys': return `${args[0]}.keys.toList()`;
+      case 'values': return `${args[0]}.values.toList()`;
+      case 'entries': return `${args[0]}.entries.toList()`;
+      case 'range': return args.length >= 2 ? `List.generate(${args[1]} - ${args[0]}, (i) => i + ${args[0]})` : `List.generate(${args[0]}, (i) => i)`;
+      case 'abs': return `${args[0]}.abs()`;
+      case 'sqrt': { this.addImport('dart:math'); return `sqrt(${args[0]}.toDouble())`; }
+      case 'pow': { this.addImport('dart:math'); return `pow(${args[0]}, ${args[1]})`; }
+      case 'ceil': return `${args[0]}.ceil()`;
+      case 'floor': return `${args[0]}.floor()`;
+      case 'round': return `${args[0]}.round()`;
+      case 'sum': return `${args[0]}.reduce((a, b) => a + b)`;
+      case 'flat': return `${args[0]}.expand((x) => x).toList()`;
+      case 'zip': return `List.generate(${args[0]}.length, (i) => [${args[0]}[i], ${args[1]}[i]])`;
+      case 'chunk': return `[for (var i = 0; i < ${args[0]}.length; i += ${args[1]}) ${args[0]}.sublist(i, i + ${args[1]} > ${args[0]}.length ? ${args[0]}.length : i + ${args[1]})]`;
+      case 'str': return `${args[0]}.toString()`;
+      case 'int': return `int.parse(${args[0]})`;
+      case 'float': return `double.parse(${args[0]})`;
+      case 'json_parse': { this.addImport('dart:convert'); return `jsonDecode(${args[0]})`; }
+      case 'json_str': { this.addImport('dart:convert'); return `jsonEncode(${args[0]})`; }
+      case 'now': return `DateTime.now().millisecondsSinceEpoch`;
+      case 'time': return `DateTime.now().toIso8601String()`;
+      case 'exit': return `exit(${args[0] || '0'})`;
+      case 'sleep': return `await Future.delayed(Duration(milliseconds: ${args[0]}))`;
+      case 'random': { this.addImport('dart:math'); return args.length >= 2 ? `(Random().nextInt(${args[1]} - ${args[0]} + 1) + ${args[0]})` : `Random().nextDouble()`; }
+      case 'read': { this.addImport('dart:io'); return `File(${args[0]}).readAsStringSync()`; }
+      case 'write': { this.addImport('dart:io'); return `File(${args[0]}).writeAsStringSync(${args[1]})`; }
+      case 'ask': { this.addImport('dart:io'); return `((){stdout.write(${args[0] || '""'}); return stdin.readLineSync() ?? "";}())`; }
+      default: return null;
+    }
+  }
 }

package/src/generator-go.js

@@ -116,6 +116,8 @@ export class GoGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`// unknown: ${node.type}`);
     }
@@ -1614,6 +1616,12 @@ export class GoGenerator {
   }
 
   generateCall(node) {
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     const args = node.args.map(a => this.expr(a)).join(', ');
 
     // Map common JS global functions to Go
@@ -1778,4 +1786,58 @@ export class GoGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`type ${node.name} int`);
+    this.emit(`const (`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      if (i === 0) {
+        this.emit(`${v} ${node.name} = iota`);
+      } else {
+        this.emit(`${v}`);
+      }
+    });
+    this.indent--;
+    this.emit(`)`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`${a}, ${b} = ${b}, ${a}`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `len(${args[0]})`;
+      case 'str': { this.addImport('strconv'); return `strconv.Itoa(${args[0]})`; }
+      case 'int': { this.addImport('strconv'); return `func() int { v, _ := strconv.Atoi(${args[0]}); return v }()`; }
+      case 'float': { this.addImport('strconv'); return `func() float64 { v, _ := strconv.ParseFloat(${args[0]}, 64); return v }()`; }
+      case 'upper': { this.addImport('strings'); return `strings.ToUpper(${args[0]})`; }
+      case 'lower': { this.addImport('strings'); return `strings.ToLower(${args[0]})`; }
+      case 'trim': { this.addImport('strings'); return `strings.TrimSpace(${args[0]})`; }
+      case 'split': { this.addImport('strings'); return `strings.Split(${args[0]}, ${args[1] || '","'})`; }
+      case 'join': { this.addImport('strings'); return `strings.Join(${args[0]}, ${args[1] || '","'})`; }
+      case 'contains': { this.addImport('strings'); return `strings.Contains(${args[0]}, ${args[1]})`; }
+      case 'replace': { this.addImport('strings'); return `strings.ReplaceAll(${args[0]}, ${args[1]}, ${args[2]})`; }
+      case 'abs': { this.addImport('math'); return `math.Abs(${args[0]})`; }
+      case 'sqrt': { this.addImport('math'); return `math.Sqrt(${args[0]})`; }
+      case 'pow': { this.addImport('math'); return `math.Pow(${args[0]}, ${args[1]})`; }
+      case 'ceil': { this.addImport('math'); return `math.Ceil(${args[0]})`; }
+      case 'floor': { this.addImport('math'); return `math.Floor(${args[0]})`; }
+      case 'round': { this.addImport('math'); return `math.Round(${args[0]})`; }
+      case 'exit': { this.addImport('os'); return `os.Exit(${args[0] || '0'})`; }
+      case 'sleep': { this.addImport('time'); return `time.Sleep(time.Duration(${args[0]}) * time.Millisecond)`; }
+      case 'now': { this.addImport('time'); return `time.Now().UnixMilli()`; }
+      case 'time': { this.addImport('time'); return `time.Now().Format(time.RFC3339)`; }
+      case 'json_parse': { this.addImport('encoding/json'); return `func() interface{} { var v interface{}; json.Unmarshal([]byte(${args[0]}), &v); return v }()`; }
+      case 'json_str': { this.addImport('encoding/json'); return `func() string { b, _ := json.Marshal(${args[0]}); return string(b) }()`; }
+      case 'random': { this.addImport('math/rand'); return args.length >= 2 ? `rand.Intn(${args[1]}-${args[0]}+1)+${args[0]}` : `rand.Float64()`; }
+      case 'sort': { this.addImport('sort'); return `func() []int { s := make([]int, len(${args[0]})); copy(s, ${args[0]}); sort.Ints(s); return s }()`; }
+      case 'reverse': return `func() []interface{} { s := make([]interface{}, len(${args[0]})); copy(s, ${args[0]}); for i, j := 0, len(s)-1; i < j; i, j = i+1, j-1 { s[i], s[j] = s[j], s[i] }; return s }()`;
+      default: return null;
+    }
+  }
 }

package/src/generator-java.js

@@ -226,6 +226,8 @@ export class JavaGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -1598,6 +1600,12 @@ export class JavaGenerator {
   }
 
   generateCall(node) {
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     const args = node.args.map(a => this.expr(a)).join(', ');
 
     if (node.callee.type === 'Identifier') {
@@ -1811,4 +1819,57 @@ export class JavaGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`enum ${node.name} {`);
+    this.indent++;
+    this.emit(node.values.join(', ') + ';');
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`{ var _tmp = ${a}; ${a} = ${b}; ${b} = _tmp; }`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.size()`;
+      case 'sort': return `${args[0]}.stream().sorted().collect(java.util.stream.Collectors.toList())`;
+      case 'reverse': return `{ var _l = new java.util.ArrayList<>(${args[0]}); java.util.Collections.reverse(_l); return _l; }`;
+      case 'contains': return `${args[0]}.contains(${args[1]})`;
+      case 'keys': return `new java.util.ArrayList<>(${args[0]}.keySet())`;
+      case 'values': return `new java.util.ArrayList<>(${args[0]}.values())`;
+      case 'entries': return `new java.util.ArrayList<>(${args[0]}.entrySet())`;
+      case 'abs': return `Math.abs(${args[0]})`;
+      case 'sqrt': return `Math.sqrt(${args[0]})`;
+      case 'pow': return `Math.pow(${args[0]}, ${args[1]})`;
+      case 'ceil': return `Math.ceil(${args[0]})`;
+      case 'floor': return `Math.floor(${args[0]})`;
+      case 'round': return `Math.round(${args[0]})`;
+      case 'random': return args.length >= 2 ? `new java.util.Random().nextInt(${args[1]} - ${args[0]} + 1) + ${args[0]}` : `Math.random()`;
+      case 'str': return `String.valueOf(${args[0]})`;
+      case 'int': return `Integer.parseInt(${args[0]})`;
+      case 'float': return `Double.parseDouble(${args[0]})`;
+      case 'upper': return `${args[0]}.toUpperCase()`;
+      case 'lower': return `${args[0]}.toLowerCase()`;
+      case 'trim': return `${args[0]}.trim()`;
+      case 'split': return `java.util.Arrays.asList(${args[0]}.split(${args[1] || '","'}))`;
+      case 'join': return `String.join(${args[1] || '","'}, ${args[0]})`;
+      case 'replace': return `${args[0]}.replace(${args[1]}, ${args[2]})`;
+      case 'sum': return `${args[0]}.stream().mapToInt(Integer::intValue).sum()`;
+      case 'unique': return `new java.util.ArrayList<>(new java.util.LinkedHashSet<>(${args[0]}))`;
+      case 'exit': return `System.exit(${args[0] || '0'})`;
+      case 'sleep': return `Thread.sleep(${args[0]})`;
+      case 'now': return `System.currentTimeMillis()`;
+      case 'time': return `java.time.LocalDateTime.now().toString()`;
+      case 'json_parse': return `new com.google.gson.Gson().fromJson(${args[0]}, Object.class)`;
+      case 'json_str': return `new com.google.gson.Gson().toJson(${args[0]})`;
+      case 'range': return args.length >= 2 ? `java.util.stream.IntStream.range(${args[0]}, ${args[1]}).boxed().collect(java.util.stream.Collectors.toList())` : `java.util.stream.IntStream.range(0, ${args[0]}).boxed().collect(java.util.stream.Collectors.toList())`;
+      default: return null;
+    }
+  }
 }

package/src/generator-kotlin.js

@@ -137,6 +137,8 @@ export class KotlinGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`// unknown: ${node.type}`);
     }
@@ -1641,6 +1643,12 @@ export class KotlinGenerator {
   generateCall(node) {
     const args = node.args.map(a => this.expr(a)).join(', ');
 
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     if (node.callee.type === 'Identifier') {
       const name = node.callee.name;
       if (name === 'parseInt') return `(${args}).toInt()`;
@@ -1816,4 +1824,63 @@ export class KotlinGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`enum class ${node.name} {`);
+    this.indent++;
+    this.emit(node.values.join(', '));
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`${a} = ${b}.also { ${b} = ${a} }`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.size`;
+      case 'sort': return `${args[0]}.sorted()`;
+      case 'reverse': return `${args[0]}.reversed()`;
+      case 'unique': return `${args[0]}.distinct()`;
+      case 'upper': return `${args[0]}.uppercase()`;
+      case 'lower': return `${args[0]}.lowercase()`;
+      case 'trim': return `${args[0]}.trim()`;
+      case 'split': return `${args[0]}.split(${args[1] || '","'})`;
+      case 'join': return `${args[0]}.joinToString(${args[1] || '","'})`;
+      case 'contains': return `${args[0]}.contains(${args[1]})`;
+      case 'replace': return `${args[0]}.replace(${args[1]}, ${args[2]})`;
+      case 'keys': return `${args[0]}.keys.toList()`;
+      case 'values': return `${args[0]}.values.toList()`;
+      case 'entries': return `${args[0]}.entries.toList()`;
+      case 'range': return args.length >= 2 ? `(${args[0]} until ${args[1]}).toList()` : `(0 until ${args[0]}).toList()`;
+      case 'abs': return `kotlin.math.abs(${args[0]})`;
+      case 'sqrt': return `kotlin.math.sqrt(${args[0]}.toDouble())`;
+      case 'pow': return `kotlin.math.pow(${args[0]}.toDouble(), ${args[1]}.toDouble())`;
+      case 'ceil': return `kotlin.math.ceil(${args[0]}.toDouble())`;
+      case 'floor': return `kotlin.math.floor(${args[0]}.toDouble())`;
+      case 'round': return `kotlin.math.round(${args[0]}.toDouble())`;
+      case 'sum': return `${args[0]}.sum()`;
+      case 'flat': return `${args[0]}.flatten()`;
+      case 'zip': return `${args[0]}.zip(${args[1]})`;
+      case 'chunk': return `${args[0]}.chunked(${args[1]})`;
+      case 'str': return `${args[0]}.toString()`;
+      case 'int': return `${args[0]}.toInt()`;
+      case 'float': return `${args[0]}.toDouble()`;
+      case 'json_parse': return `com.google.gson.Gson().fromJson(${args[0]}, Any::class.java)`;
+      case 'json_str': return `com.google.gson.Gson().toJson(${args[0]})`;
+      case 'now': return `System.currentTimeMillis()`;
+      case 'time': return `java.time.LocalDateTime.now().toString()`;
+      case 'exit': return `kotlin.system.exitProcess(${args[0] || '0'})`;
+      case 'sleep': return `Thread.sleep(${args[0]}.toLong())`;
+      case 'random': return args.length >= 2 ? `(${args[0]}..${args[1]}).random()` : `kotlin.random.Random.nextDouble()`;
+      case 'read': return `java.io.File(${args[0]}).readText()`;
+      case 'write': return `java.io.File(${args[0]}).writeText(${args[1]})`;
+      case 'ask': return `(print(${args[0] || '""'}); readLine() ?: "")`;
+      default: return null;
+    }
+  }
 }

package/src/generator-php.js

@@ -103,6 +103,8 @@ export class PhpGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`/* unknown: ${node.type} */`);
     }
@@ -1366,6 +1368,12 @@ export class PhpGenerator {
   }
 
   generateCall(node) {
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     const args = node.args.map(a => this.expr(a)).join(', ');
 
     // Map global function calls
@@ -1573,4 +1581,65 @@ export class PhpGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`class ${node.name} {`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      this.emit(`const ${v} = ${i};`);
+    });
+    this.indent--;
+    this.emit(`}`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`[$${a.replace('$','')}, $${b.replace('$','')}] = [$${b.replace('$','')}, $${a.replace('$','')}];`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `count(${args[0]})`;
+      case 'sort': return `(function($a) { sort($a); return $a; })(${args[0]})`;
+      case 'reverse': return `array_reverse(${args[0]})`;
+      case 'unique': return `array_values(array_unique(${args[0]}))`;
+      case 'upper': return `strtoupper(${args[0]})`;
+      case 'lower': return `strtolower(${args[0]})`;
+      case 'trim': return `trim(${args[0]})`;
+      case 'split': return `explode(${args[1] || '","'}, ${args[0]})`;
+      case 'join': return `implode(${args[1] || '","'}, ${args[0]})`;
+      case 'contains': return `in_array(${args[1]}, ${args[0]})`;
+      case 'replace': return `str_replace(${args[1]}, ${args[2]}, ${args[0]})`;
+      case 'keys': return `array_keys(${args[0]})`;
+      case 'values': return `array_values(${args[0]})`;
+      case 'entries': return `array_map(null, array_keys(${args[0]}), array_values(${args[0]}))`;
+      case 'range': return args.length >= 2 ? `range(${args[0]}, ${args[1]} - 1)` : `range(0, ${args[0]} - 1)`;
+      case 'abs': return `abs(${args[0]})`;
+      case 'round': return `round(${args[0]})`;
+      case 'ceil': return `ceil(${args[0]})`;
+      case 'floor': return `floor(${args[0]})`;
+      case 'sqrt': return `sqrt(${args[0]})`;
+      case 'pow': return `pow(${args[0]}, ${args[1]})`;
+      case 'sum': return `array_sum(${args[0]})`;
+      case 'flat': return `array_merge(...${args[0]})`;
+      case 'str': return `strval(${args[0]})`;
+      case 'int': return `intval(${args[0]})`;
+      case 'float': return `floatval(${args[0]})`;
+      case 'json_parse': return `json_decode(${args[0]}, true)`;
+      case 'json_str': return `json_encode(${args[0]})`;
+      case 'now': return `(int)(microtime(true) * 1000)`;
+      case 'time': return `date('c')`;
+      case 'exit': return `exit(${args[0] || '0'})`;
+      case 'sleep': return `usleep(${args[0]} * 1000)`;
+      case 'random': return args.length >= 2 ? `random_int(${args[0]}, ${args[1]})` : `(mt_rand() / mt_getrandmax())`;
+      case 'read': return `file_get_contents(${args[0]})`;
+      case 'write': return `file_put_contents(${args[0]}, ${args[1]})`;
+      case 'ask': return `readline(${args[0] || '""'})`;
+      case 'chunk': return `array_chunk(${args[0]}, ${args[1]})`;
+      case 'zip': return `array_map(null, ${args[0]}, ${args[1]})`;
+      default: return null;
+    }
+  }
 }

package/src/generator-python.js

@@ -162,6 +162,8 @@ export class PythonGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`# unknown: ${node.type}`);
     }
@@ -1068,6 +1070,12 @@ export class PythonGenerator {
   generateCall(node) {
     const args = node.args.map(a => this.expr(a)).join(', ');
 
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b !== null) return b;
+    }
+
     // Map common JS global functions to Python
     if (node.callee.type === 'Identifier') {
       const name = node.callee.name;
@@ -2466,4 +2474,69 @@ export class PythonGenerator {
     this.emit(`${name.replace(/\W/g, '_')} = ${name.charAt(0).toUpperCase() + name.slice(1).replace(/\W/g, '_')}()`);
     this.emitRaw('');
   }
+
+  // ===== Enum =====
+  visitEnum(node) {
+    this.addFromImport('enum', 'Enum');
+    this.emit(`class ${node.name}(Enum):`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      this.emit(`${v} = ${i}`);
+    });
+    this.indent--;
+    this.emitRaw('');
+  }
+
+  // ===== Swap =====
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`${a}, ${b} = ${b}, ${a}`);
+  }
+
+  // ===== Builtins =====
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'ask': return `input(${args[0] || '""'})`;
+      case 'sleep': { this.addImport('time'); return `time.sleep(${args[0]} / 1000)`; }
+      case 'exit': { this.addImport('sys'); return `sys.exit(${args[0] || '0'})`; }
+      case 'read': return `open(${args[0]}).read()`;
+      case 'write': return `open(${args[0]}, 'w').write(${args[1]})`;
+      case 'fetch_json': { this.addImport('requests'); return `requests.get(${args[0]}).json()`; }
+      case 'random': { this.addImport('random'); return args.length >= 2 ? `random.randint(${args[0]}, ${args[1]})` : `random.random()`; }
+      case 'sort': return `sorted(${args[0]})`;
+      case 'reverse': return `list(reversed(${args[0]}))`;
+      case 'unique': return `list(set(${args[0]}))`;
+      case 'len': return `len(${args[0]})`;
+      case 'upper': return `${args[0]}.upper()`;
+      case 'lower': return `${args[0]}.lower()`;
+      case 'trim': return `${args[0]}.strip()`;
+      case 'split': return `${args[0]}.split(${args[1] || ''})`;
+      case 'join': return `${args[1] || '","'}.join(${args[0]})`;
+      case 'contains': return `(${args[1]} in ${args[0]})`;
+      case 'replace': return `${args[0]}.replace(${args[1]}, ${args[2]})`;
+      case 'keys': return `list(${args[0]}.keys())`;
+      case 'values': return `list(${args[0]}.values())`;
+      case 'entries': return `list(${args[0]}.items())`;
+      case 'range': return args.length >= 2 ? `list(range(${args[0]}, ${args[1]}))` : `list(range(${args[0]}))`;
+      case 'abs': return `abs(${args[0]})`;
+      case 'round': return `round(${args[0]})`;
+      case 'ceil': { this.addImport('math'); return `math.ceil(${args[0]})`; }
+      case 'floor': { this.addImport('math'); return `math.floor(${args[0]})`; }
+      case 'sqrt': { this.addImport('math'); return `math.sqrt(${args[0]})`; }
+      case 'pow': return `${args[0]} ** ${args[1]}`;
+      case 'sum': return `sum(${args[0]})`;
+      case 'flat': return `[x for sub in ${args[0]} for x in sub]`;
+      case 'zip': return `list(zip(${args[0]}, ${args[1]}))`;
+      case 'str': return `str(${args[0]})`;
+      case 'int': return `int(${args[0]})`;
+      case 'float': return `float(${args[0]})`;
+      case 'json_parse': { this.addImport('json'); return `json.loads(${args[0]})`; }
+      case 'json_str': { this.addImport('json'); return `json.dumps(${args[0]})`; }
+      case 'now': { this.addImport('time'); return `int(time.time() * 1000)`; }
+      case 'time': { this.addFromImport('datetime', 'datetime'); return `datetime.now().isoformat()`; }
+      case 'chunk': return `[${args[0]}[i:i+${args[1]}] for i in range(0, len(${args[0]}), ${args[1]})]`;
+      default: return null;
+    }
+  }
 }

package/src/generator-ruby.js

@@ -111,6 +111,8 @@ export class RubyGenerator {
       case 'GrpcDecl': return this.visitGrpc(node);
       case 'WebrtcDecl': return this.visitWebrtc(node);
       case 'BlockchainDecl': return this.visitBlockchain(node);
+      case 'EnumDecl': return this.visitEnum(node);
+      case 'Swap': return this.visitSwap(node);
       default:
         this.emit(`# unknown: ${node.type}`);
     }
@@ -1330,6 +1332,12 @@ export class RubyGenerator {
   }
 
   generateCall(node) {
+    if (node.callee.type === 'Identifier') {
+      const argList = node.args.map(a => this.expr(a));
+      const b = this.generateBuiltin(node.callee.name, argList);
+      if (b) return b;
+    }
+
     const args = node.args.map(a => this.expr(a)).join(', ');
 
     // Map global function calls
@@ -1527,4 +1535,65 @@ export class RubyGenerator {
     this.indent = savedIndent;
     return result;
   }
+
+  visitEnum(node) {
+    this.emit(`module ${node.name}`);
+    this.indent++;
+    node.values.forEach((v, i) => {
+      this.emit(`${v} = ${i}`);
+    });
+    this.indent--;
+    this.emit(`end`);
+    this.emitRaw('');
+  }
+
+  visitSwap(node) {
+    const a = this.expr(node.a);
+    const b = this.expr(node.b);
+    this.emit(`${a}, ${b} = ${b}, ${a}`);
+  }
+
+  generateBuiltin(name, args) {
+    switch (name) {
+      case 'len': return `${args[0]}.length`;
+      case 'sort': return `${args[0]}.sort`;
+      case 'reverse': return `${args[0]}.reverse`;
+      case 'unique': return `${args[0]}.uniq`;
+      case 'upper': return `${args[0]}.upcase`;
+      case 'lower': return `${args[0]}.downcase`;
+      case 'trim': return `${args[0]}.strip`;
+      case 'split': return `${args[0]}.split(${args[1] || '","'})`;
+      case 'join': return `${args[0]}.join(${args[1] || '","'})`;
+      case 'contains': return `${args[0]}.include?(${args[1]})`;
+      case 'replace': return `${args[0]}.gsub(${args[1]}, ${args[2]})`;
+      case 'keys': return `${args[0]}.keys`;
+      case 'values': return `${args[0]}.values`;
+      case 'entries': return `${args[0]}.to_a`;
+      case 'range': return args.length >= 2 ? `(${args[0]}...${args[1]}).to_a` : `(0...${args[0]}).to_a`;
+      case 'abs': return `${args[0]}.abs`;
+      case 'round': return `${args[0]}.round`;
+      case 'ceil': return `${args[0]}.ceil`;
+      case 'floor': return `${args[0]}.floor`;
+      case 'sqrt': return `Math.sqrt(${args[0]})`;
+      case 'pow': return `${args[0]} ** ${args[1]}`;
+      case 'sum': return `${args[0]}.sum`;
+      case 'flat': return `${args[0]}.flatten`;
+      case 'zip': return `${args[0]}.zip(${args[1]})`;
+      case 'chunk': return `${args[0]}.each_slice(${args[1]}).to_a`;
+      case 'str': return `${args[0]}.to_s`;
+      case 'int': return `${args[0]}.to_i`;
+      case 'float': return `${args[0]}.to_f`;
+      case 'json_parse': return `JSON.parse(${args[0]})`;
+      case 'json_str': return `JSON.generate(${args[0]})`;
+      case 'now': return `(Time.now.to_f * 1000).to_i`;
+      case 'time': return `Time.now.iso8601`;
+      case 'exit': return `exit(${args[0] || '0'})`;
+      case 'sleep': return `sleep(${args[0]} / 1000.0)`;
+      case 'random': return args.length >= 2 ? `rand(${args[0]}..${args[1]})` : `rand`;
+      case 'read': return `File.read(${args[0]})`;
+      case 'write': return `File.write(${args[0]}, ${args[1]})`;
+      case 'ask': return `(print(${args[0] || '""'}); gets.chomp)`;
+      default: return null;
+    }
+  }
 }