@starpak/lang 0.0.0-stage → 0.1.3

package/src/emit/lua.ts

@@ -0,0 +1,484 @@
+/**
+ * Spak Lang - Lua emitter (basic)
+ *
+ * A deliberately small lowering from the Spak AST to Lua 5.4 source. It
+ * covers the everyday core (locals, functions, if/while/for, tables, calls,
+ * string concatenation) and leaves the heavier sugar (`match`, `try`,
+ * classes, decorators, slicing) as plain, best-effort Lua. It is not used by
+ * the runtime and exists for tooling / round-trip experiments.
+ */
+
+import type {
+  Assign,
+  Binary,
+  Block,
+  Call,
+  ClassDecl,
+  Expr,
+  FnDecl,
+  ForIn,
+  ForNumeric,
+  FunctionExpr,
+  ImportDecl,
+  Index,
+  MatchStmt,
+  Param,
+  Pattern,
+  Program,
+  Statement,
+  StringLit,
+  Table,
+  TablePattern,
+  TryStmt,
+  TypeAliasDecl,
+  TypeAnn,
+  VarDecl,
+} from '../ast'
+
+export interface EmitLuaOptions {
+  /** Header comment; set to an empty string to omit it. */
+  banner?: string
+  /** Indentation unit. Defaults to two spaces. */
+  indent?: string
+}
+
+class LuaEmitter {
+  private lines: string[] = []
+  private level = 0
+  private temp = 0
+  private readonly options: EmitLuaOptions
+
+  constructor(options: EmitLuaOptions = {}) {
+    this.options = options
+  }
+
+  private get unit(): string {
+    return this.options.indent ?? '  '
+  }
+
+  private line(text = ''): void {
+    this.lines.push(text ? this.unit.repeat(this.level) + text : '')
+  }
+
+  private withLevel(fn: () => void): void {
+    this.level++
+    try {
+      fn()
+    } finally {
+      this.level--
+    }
+  }
+
+  emitProgram(program: Program): string {
+    for (const statement of program.body) this.statement(statement)
+    const chunks: string[] = []
+    const banner = this.options.banner ?? '-- Generated by Spak emitLua'
+    if (banner) chunks.push(banner)
+    chunks.push(this.lines.join('\n'))
+    return chunks.filter(Boolean).join('\n\n') + '\n'
+  }
+
+  private statement(node: Statement): void {
+    switch (node.kind) {
+      case 'VarDecl':
+        this.varDecl(node)
+        return
+      case 'Assign':
+        this.assign(node)
+        return
+      case 'FnDecl':
+        this.fnDecl(node)
+        return
+      case 'ClassDecl':
+        this.classDecl(node)
+        return
+      case 'IfStmt': {
+        this.line(`if ${this.expr(node.cond)} then`)
+        this.withLevel(() => this.block(node.then))
+        for (const branch of node.elifs) {
+          this.line(`elseif ${this.expr(branch.cond)} then`)
+          this.withLevel(() => this.block(branch.body))
+        }
+        if (node.else) {
+          this.line('else')
+          this.withLevel(() => this.block(node.else))
+        }
+        this.line('end')
+        return
+      }
+      case 'UnlessStmt':
+        this.line(`if not (${this.expr(node.cond)}) then`)
+        this.withLevel(() => this.block(node.body))
+        this.line('end')
+        return
+      case 'WhileStmt':
+        this.line(`while ${this.expr(node.cond)} do`)
+        this.withLevel(() => this.block(node.body))
+        this.line('end')
+        return
+      case 'RepeatStmt':
+        this.line('repeat')
+        this.withLevel(() => this.block(node.body))
+        this.line(`until ${this.expr(node.cond)}`)
+        return
+      case 'ForNumeric':
+        this.forNumeric(node)
+        return
+      case 'ForIn':
+        this.forIn(node)
+        return
+      case 'ReturnStmt':
+        this.line(node.values.length ? `return ${node.values.map(value => this.expr(value)).join(', ')}` : 'return')
+        return
+      case 'BreakStmt':
+        this.line('break')
+        return
+      case 'ContinueStmt':
+        this.line('-- continue (Lua 5.4 has no continue)')
+        return
+      case 'MatchStmt':
+        this.match(node)
+        return
+      case 'TryStmt':
+        this.try(node)
+        return
+      case 'ImportDecl':
+        this.importDecl(node)
+        return
+      case 'ExportDecl':
+        this.statement(node.declaration)
+        return
+      case 'ExportDefault':
+        this.line(`return ${this.expr(node.expr)}`)
+        return
+      case 'TypeAliasDecl':
+        this.typeAlias(node)
+        return
+      case 'ThrowStmt':
+        this.line(`error(${this.expr(node.value)})`)
+        return
+      case 'SpawnStmt': {
+        const value = this.expr(node.value)
+        this.line(node.value.kind === 'FunctionExpr'
+          ? `coroutine.wrap(${value})()`
+          : `coroutine.wrap(${value})()`)
+        return
+      }
+      case 'ExprStmt':
+        this.line(this.expr(node.expr))
+        return
+      default:
+        this.line(`-- unsupported statement: ${(node as Statement).kind}`)
+    }
+  }
+
+  private block(block: Block | undefined): void {
+    if (!block) return
+    for (const statement of block.body) this.statement(statement)
+  }
+
+  private varDecl(node: VarDecl): void {
+    if (node.doc) this.line(`-- ${node.doc.split(/\r?\n/).join(' ')}`)
+    const names = node.names.map(entry => entry.name).join(', ')
+    const values = node.values.map(value => this.expr(value)).join(', ')
+    const keyword = node.scope === 'global' ? '' : 'local '
+    this.line(values ? `${keyword}${names} = ${values}` : `${keyword}${names}`)
+  }
+
+  private assign(node: Assign): void {
+    node.targets.forEach((target, index) => {
+      const value = node.values[index] ? this.expr(node.values[index]) : 'nil'
+      if (this.isPattern(target)) {
+        this.patternAssign(target, value)
+        return
+      }
+      this.line(`${this.expr(target)} = ${value}`)
+    })
+  }
+
+  private isPattern(target: Expr | Pattern): target is Pattern {
+    return target.kind === 'TablePattern' || target.kind === 'ArrayPattern'
+  }
+
+  private patternAssign(pattern: Pattern, value: string): void {
+    if (pattern.kind === 'ArrayPattern') {
+      this.line(`local ${pattern.elements.join(', ')} = table.unpack(${value})`)
+      return
+    }
+    for (const entry of (pattern as TablePattern).entries) {
+      const target = entry.target ?? entry.key
+      this.line(`local ${target} = ${value}${this.indexSuffix(entry.key)}`)
+    }
+  }
+
+  private indexSuffix(key: string): string {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) ? `.${key}` : `[${JSON.stringify(key)}]`
+  }
+
+  private fnDecl(node: FnDecl): void {
+    if (node.doc) this.line(`-- ${node.doc.split(/\r?\n/).join(' ')}`)
+    const name = node.receiver ? `${node.receiver}:${node.name}` : node.name
+    this.line(`function ${name}(${this.params(node.params)})`)
+    this.withLevel(() => {
+      if (node.exprBody) this.line(`return ${this.expr(node.exprBody)}`)
+      else this.block(node.body)
+    })
+    this.end()
+  }
+
+  private classDecl(node: ClassDecl): void {
+    if (node.doc) this.line(`-- ${node.doc.split(/\r?\n/).join(' ')}`)
+    this.line(`local ${node.name} = {}`)
+    if (node.superClass) this.line(`setmetatable(${node.name}, { __index = ${node.superClass} })`)
+    this.line(`${node.name}.__index = ${node.name}`)
+
+    for (const member of node.members) {
+      if (member.kind === 'VarDecl') {
+        member.names.forEach((entry, index) => {
+          const value = member.values[index]
+          this.line(`${node.name}.${entry.name} = ${value ? this.expr(value) : 'nil'}`)
+        })
+        continue
+      }
+      const name = member.name === 'init' ? 'new' : member.name
+      if (member.name === 'init') {
+        this.line(`function ${node.name}.${name}(${this.params(member.params)})`)
+      } else {
+        this.line(`function ${node.name}:${name}(${this.params(member.params)})`)
+      }
+      this.withLevel(() => {
+        if (member.exprBody) this.line(`return ${this.expr(member.exprBody)}`)
+        else this.block(member.body)
+      })
+      this.end()
+    }
+  }
+
+  private forNumeric(node: ForNumeric): void {
+    const from = this.expr(node.from)
+    const to = node.inclusive ? this.expr(node.to) : `(${this.expr(node.to)}) - 1`
+    const step = node.step ? `, ${this.expr(node.step)}` : ''
+    this.line(`for ${node.varName} = ${from}, ${to}${step} do`)
+    this.withLevel(() => this.block(node.body))
+    this.end()
+  }
+
+  private forIn(node: ForIn): void {
+    const vars = node.vars.join(', ')
+    if (node.iter.kind === 'Range') {
+      const to = node.iter.inclusive ? this.expr(node.iter.to) : `(${this.expr(node.iter.to)}) - 1`
+      this.line(`for ${vars} = ${this.expr(node.iter.from)}, ${to} do`)
+    } else {
+      this.line(`for ${vars} in ${this.expr(node.iter)} do`)
+    }
+    this.withLevel(() => this.block(node.body))
+    this.end()
+  }
+
+  private match(node: MatchStmt): void {
+    const subject = `__match${++this.temp}`
+    this.line(`local ${subject} = ${this.expr(node.subject)}`)
+    node.arms.forEach((arm, index) => {
+      const conditions = arm.patterns.map((pattern) => {
+        if (pattern.kind === 'Ident') return 'true'
+        if (pattern.kind === 'Range') {
+          return `${subject} >= ${this.expr(pattern.from)} and ${subject} ${pattern.inclusive ? '<=' : '<'} ${this.expr(pattern.to)}`
+        }
+        return `${subject} == ${this.expr(pattern)}`
+      }).filter(Boolean)
+      const condition = conditions.join(' or ') || 'true'
+      this.line(`${index === 0 ? 'if' : 'elseif'} ${condition} then`)
+      this.withLevel(() => {
+        for (const pattern of arm.patterns) {
+          if (pattern.kind === 'Ident') this.line(`local ${pattern.name} = ${subject}`)
+        }
+        this.block(arm.body)
+      })
+    })
+    if (node.elseBody) {
+      this.line(node.arms.length ? 'else' : 'do')
+      this.withLevel(() => this.block(node.elseBody))
+      if (!node.arms.length) this.end()
+    }
+    if (node.arms.length) this.line('end')
+  }
+
+  private try(node: TryStmt): void {
+    this.line('local __ok, __err = pcall(function()')
+    this.withLevel(() => this.block(node.body))
+    this.line('end)')
+    if (node.catchBody) {
+      this.line('if not __ok then')
+      this.withLevel(() => {
+        if (node.catchVar) this.line(`local ${node.catchVar} = __err`)
+        this.block(node.catchBody)
+      })
+      this.line('end')
+    }
+    if (node.finallyBody) this.withLevel(() => this.block(node.finallyBody))
+  }
+
+  private importDecl(node: ImportDecl): void {
+    if (!node.clauses.length) {
+      this.line(`require(${JSON.stringify(node.source)})`)
+      return
+    }
+    for (const clause of node.clauses) {
+      if (clause.name === '*') {
+        this.line(`local ${clause.alias ?? 'ns'} = require(${JSON.stringify(node.source)})`)
+        continue
+      }
+      const local = clause.alias ?? clause.name
+      this.line(`local ${local} = require(${JSON.stringify(node.source)}).${clause.name}`)
+    }
+  }
+
+  private typeAlias(node: TypeAliasDecl): void {
+    if (node.doc) this.line(`-- ${node.doc.split(/\r?\n/).join(' ')}`)
+    this.line(`-- type ${node.name} = ${luaType(node.type)}`)
+  }
+
+  private end(): void {
+    this.line('end')
+  }
+
+  private params(params: Param[]): string {
+    return params.map(param => param.rest ? '...' : param.name).join(', ')
+  }
+
+  /* ---------------------------------------------------------------- */
+  /* Expressions                                                       */
+  /* ---------------------------------------------------------------- */
+
+  private expr(node: Expr): string {
+    switch (node.kind) {
+      case 'NumberLit':
+        return Number.isFinite(node.value) ? String(node.value) : '0'
+      case 'StringLit':
+        return this.string(node)
+      case 'BoolLit':
+        return node.value ? 'true' : 'false'
+      case 'NilLit':
+        return 'nil'
+      case 'Ident':
+        return node.name
+      case 'SelfExpr':
+        return 'self'
+      case 'Member':
+        return `${this.expr(node.object)}${node.optional ? ' and ' : '.'}${node.property}`
+      case 'Index':
+        return this.index(node)
+      case 'Call':
+        return this.call(node)
+      case 'Binary':
+        return this.binary(node)
+      case 'Unary':
+        if (node.op === 'not') return `not (${this.expr(node.argument)})`
+        if (node.op === '#') return `#${this.expr(node.argument)}`
+        return `-(${this.expr(node.argument)})`
+      case 'Table':
+        return this.table(node)
+      case 'FunctionExpr':
+        return this.functionExpr(node)
+      case 'Range':
+        return `${this.expr(node.from)}, ${this.expr(node.to)}`
+      case 'AwaitExpr':
+        return this.expr(node.argument)
+      case 'Spread':
+        return node.argument ? `table.unpack(${this.expr(node.argument)})` : 'table.unpack({})'
+      default:
+        return 'nil'
+    }
+  }
+
+  private string(node: StringLit): string {
+    if (node.fstring && node.parts) {
+      const parts = node.parts.map(part => typeof part === 'string'
+        ? JSON.stringify(part)
+        : `tostring(${this.expr(part)})`)
+      return parts.length ? parts.join(' .. ') : '""'
+    }
+    return JSON.stringify(node.value)
+  }
+
+  private index(node: Index): string {
+    const object = this.expr(node.object)
+    if (node.index.kind === 'Range') {
+      // Basic mapping only: Lua has no slice operator, so the range is erased
+      // to a plain reference. Callers that need slicing should use `table.move`.
+      return object
+    }
+    return `${object}[${this.expr(node.index)}]`
+  }
+
+  private call(node: Call): string {
+    const args = node.args.map(arg => this.expr(arg)).join(', ')
+    if (node.callee.kind === 'Member') {
+      const member = node.callee
+      const object = this.expr(member.object)
+      if (!node.isMethod && member.property === 'new') return `${object}.new(${args})`
+      if (node.isMethod) return `${object}:${member.property}(${args})`
+      return `${object}.${member.property}(${args})`
+    }
+    return `${this.expr(node.callee)}(${args})`
+  }
+
+  private binary(node: Binary): string {
+    if (node.op === '|>') {
+      if (node.right.kind === 'Call') {
+        const args = [node.left, ...node.right.args].map(arg => this.expr(arg)).join(', ')
+        if (node.right.callee.kind === 'Member' && node.right.isMethod) {
+          return `${this.expr(node.right.callee.object)}:${node.right.callee.property}(${args})`
+        }
+        return `${this.expr(node.right.callee)}(${args})`
+      }
+      return `${this.expr(node.right)}(${this.expr(node.left)})`
+    }
+    if (node.op === '??') return `(${this.expr(node.left)} or ${this.expr(node.right)})`
+    return `(${this.expr(node.left)} ${node.op} ${this.expr(node.right)})`
+  }
+
+  private table(node: Table): string {
+    const parts = node.fields.map((field) => {
+      if (field.key?.kind === 'Ident') return `${field.key.name} = ${this.expr(field.value)}`
+      if (field.key) return `[${this.expr(field.key)}] = ${this.expr(field.value)}`
+      return this.expr(field.value)
+    })
+    return `{ ${parts.join(', ')} }`
+  }
+
+  private functionExpr(node: FunctionExpr): string {
+    const sub = new LuaEmitter(this.options)
+    sub.level = 0
+    if (node.exprBody) sub.line(`return ${sub.expr(node.exprBody)}`)
+    else sub.block(node.body)
+    const body = sub.lines.map(text => (text ? this.unit + text : text)).join('\n')
+    return `function(${this.params(node.params)})\n${body}\n${this.unit.repeat(this.level)}end`
+  }
+}
+
+function luaType(node: TypeAnn): string {
+  switch (node.kind) {
+    case 'named':
+      return node.name
+    case 'array':
+      return `[${luaType(node.element)}]`
+    case 'dict':
+      return `{ [${luaType(node.key)}]: ${luaType(node.value)} }`
+    case 'record':
+      return `{ ${node.fields.map(field => `${field.name}: ${luaType(field.type)}`).join(', ')} }`
+    case 'union':
+      return node.types.map(luaType).join(' | ')
+    case 'fn':
+      return `(${node.params.map(luaType).join(', ')}) -> ${luaType(node.returns)}`
+    case 'optional':
+      return `${luaType(node.type)}?`
+    default:
+      return 'any'
+  }
+}
+
+/** Lowers a Spak program to basic Lua 5.4 source. */
+export function emitLua(program: Program, options: EmitLuaOptions = {}): string {
+  return new LuaEmitter(options).emitProgram(program)
+}