@xnoxs/flux-lang 3.1.1

package/src/self/codegen.flux

@@ -0,0 +1,555 @@
+// ============================================================
+//  Flux Self-Hosted Code Generator
+//  src/self/codegen.flux — written in Flux, compiled by stage-0
+// ============================================================
+
+import { Lexer, lexerize, T } from './lexer'
+import { Parser, makeParser }   from './parser'
+
+fn extractFormatSpec(raw):
+  val ci = raw.lastIndexOf(':')
+  if ci < 1: return null
+  val spec = raw.slice(ci + 1).trim()
+  if spec.length > 0 and /[.<>^,dbeEfFgGoOxXs%bcn]/.test(spec) and /^([.<>^0\-+ #,]*[0-9]*\.?[0-9]*[dbeEfFgGoOxXs%bcn]?[,]?)$/.test(spec):
+    return { expr: raw.slice(0, ci).trim(), fmt: spec }
+  return null
+
+val FMT_HELPER = `
+function _fmt(v, s) {
+  if (s === ',') return (+v).toLocaleString();
+  if (s === '%') return ((+v)*100).toFixed(0)+'%';
+  var m = s.match(/^([0-9,]*)?\.([0-9]+)([fdgGeEb%x])$/);
+  if (m) {
+    var d=+m[2], t=m[3], comma=s[0]===',';
+    if (t==='f'||t==='d') return comma ? (+v).toLocaleString(void 0,{minimumFractionDigits:d,maximumFractionDigits:d}) : (+v).toFixed(d);
+    if (t==='e'||t==='E') return (+v).toExponential(d);
+    if (t==='%') return ((+v)*100).toFixed(d)+'%';
+    if (t==='b') return Math.round(+v).toString(2);
+    if (t==='x') return Math.round(+v).toString(16);
+  }
+  var m2 = s.match(/^([0-9]*)d$/); if (m2) return Math.round(+v).toString();
+  return String(v);
+}`
+
+fn buildClassRegistry(ast):
+  val reg = {}
+  for node in ast.body:
+    val n = node.type == 'ExportDecl' ? node.decl : node
+    if n.type == 'ClassDecl':
+      reg[n.name] = { fields: n.fields, superClass: n.superClass }
+  return reg
+
+fn getAllFields(name, reg, visited):
+  val vis = visited ?? new Set([])
+  if not name or not reg[name] or vis.has(name): return []
+  vis.add(name)
+  val parent = getAllFields(reg[name].superClass, reg, vis)
+  return [...parent, ...reg[name].fields]
+
+export class CodeGenerator:
+  ind: string
+  level: int
+  lines: any[]
+  clsReg: any
+  smBuilder: any
+  _needsFmt: bool
+  _loopDepth: int
+
+  fn i():
+    var s = ''
+    var n = self.level
+    while n > 0:
+      s += self.ind
+      n = n - 1
+    return s
+
+  fn emit(s):
+    self.lines.push(self.i() + s)
+
+  fn emitRaw(s):
+    self.lines.push(s)
+
+  fn blank():
+    self.lines.push('')
+
+  fn indIn():
+    self.level = self.level + 1
+
+  fn indOut():
+    if self.level > 0: self.level = self.level - 1
+
+  fn generate(ast):
+    self.clsReg    = buildClassRegistry(ast)
+    self.lines     = []
+    self.level     = 0
+    self._needsFmt = false
+    self.emit('// Generated by Flux Transpiler v3.1.0 (self-hosted)')
+    self.emit('"use strict";')
+    self.blank()
+    for node in ast.body: self.genStmt(node)
+    if self._needsFmt:
+      self.lines.splice(2, 0, FMT_HELPER)
+    return { code: self.lines.join('\n'), smBuilder: self.smBuilder }
+
+  fn genStmt(node):
+    if node.type == 'VarDecl':         self.genVar(node)
+    else if node.type == 'DestructureDecl': self.genDestructure(node)
+    else if node.type == 'FnDecl':     self.genFn(node, '')
+    else if node.type == 'ClassDecl':  self.genClass(node)
+    else if node.type == 'IfStmt':     self.genIf(node)
+    else if node.type == 'ForInStmt':  self.genFor(node)
+    else if node.type == 'WhileStmt':  self.genWhile(node)
+    else if node.type == 'MatchStmt':  self.genMatch(node)
+    else if node.type == 'ReturnStmt': self.genReturn(node)
+    else if node.type == 'TryCatchStmt': self.genTryCatch(node)
+    else if node.type == 'ThrowStmt':  self.genThrow(node)
+    else if node.type == 'DoWhileStmt': self.genDoWhile(node)
+    else if node.type == 'BreakStmt':  self.emit('break;')
+    else if node.type == 'ContinueStmt': self.emit('continue;')
+    else if node.type == 'ImportDecl': self.genImport(node)
+    else if node.type == 'ExportDecl': self.genExport(node)
+    else if node.type == 'TypeDecl':   self.genTypeDecl(node)
+    else if node.type == 'InterfaceDecl': self.genInterfaceDecl(node)
+    else if node.type == 'EnumDecl':   self.genEnumDecl(node)
+    else if node.type == 'ExprStmt':   self.emit(self.genExpr(node.expr) + ';')
+    else:
+      throw new Error("Unknown statement: {node.type}")
+
+  fn genVar(node):
+    val kw   = node.kind == 'val' ? 'const' : 'let'
+    val init = node.init ? ' = ' + self.genExpr(node.init) : ''
+    self.emit(kw + ' ' + node.name + init + ';')
+
+  fn genObjPair(p):
+    if p.spread: return '...' + self.genExpr(p.value)
+    val isIdent = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.key)
+    val keyStr  = isIdent ? p.key : '"' + p.key + '"'
+    if isIdent and p.value and p.value.type == 'Identifier' and p.value.name == p.key:
+      return p.key
+    return keyStr + ': ' + self.genExpr(p.value)
+
+  fn genDestructProp(p):
+    if p.rest: return '...' + p.key
+    var s = p.alias != p.key ? p.key + ': ' + p.alias : p.key
+    if p.defaultVal: s = s + ' = ' + self.genExpr(p.defaultVal)
+    return s
+
+  fn genDestructItem(p):
+    if not p: return ''
+    if p.rest: return '...' + p.name
+    var s = p.name
+    if p.defaultVal: s = s + ' = ' + self.genExpr(p.defaultVal)
+    return s
+
+  fn genDestructure(node):
+    val kw   = node.kind == 'val' ? 'const' : 'let'
+    val init = self.genExpr(node.init)
+    if node.patternType == 'object':
+      val props = node.pattern.map(p -> self.genDestructProp(p)).join(', ')
+      self.emit(kw + ' { ' + props + ' } = ' + init + ';')
+    else:
+      val items = node.pattern.map(p -> self.genDestructItem(p)).join(', ')
+      self.emit(kw + ' [' + items + '] = ' + init + ';')
+
+  fn genFn(node, prefix):
+    val asyncKw = node.async ? 'async ' : ''
+    val name    = node.name ?? ''
+    val params  = node.params.map(p ->
+      p.rest ? '...' + p.name :
+      p.defaultVal ? p.name + ' = ' + self.genExpr(p.defaultVal) :
+      p.name
+    ).join(', ')
+    if node.inline:
+      self.emit(prefix + asyncKw + 'function ' + name + '(' + params + ') { return ' + self.genExpr(node.body) + '; }')
+    else:
+      self.emit(prefix + asyncKw + 'function ' + name + '(' + params + ') {')
+      self.indIn()
+      for s in node.body: self.genStmt(s)
+      self.indOut()
+      self.emit('}')
+
+  fn genClass(node):
+    val ext = node.superClass ? ' extends ' + node.superClass : ''
+    self.emit('class ' + node.name + ext + ' {')
+    self.indIn()
+    val allFields = getAllFields(node.name, self.clsReg, null)
+    if allFields.length > 0:
+      val params = allFields.map(f -> f.name).join(', ')
+      self.emit('constructor(' + params + ') {')
+      self.indIn()
+      if node.superClass and self.clsReg[node.superClass]:
+        val parentFields = getAllFields(node.superClass, self.clsReg, null)
+        if parentFields.length > 0:
+          self.emit('super(' + parentFields.map(f -> f.name).join(', ') + ');')
+      for f in node.fields: self.emit('this.' + f.name + ' = ' + f.name + ';')
+      self.indOut()
+      self.emit('}')
+      self.blank()
+    for m in node.methods:
+      val asyncKw  = m.async ? 'async ' : ''
+      val staticKw = (m.modifiers and m.modifiers.has('static')) ? 'static ' : ''
+      val params   = m.params.map(p ->
+        p.rest ? '...' + p.name :
+        p.defaultVal ? p.name + ' = ' + self.genExpr(p.defaultVal) :
+        p.name
+      ).join(', ')
+      if m.inline:
+        self.emit(staticKw + asyncKw + m.name + '(' + params + ') { return ' + self.genExpr(m.body) + '; }')
+      else:
+        self.emit(staticKw + asyncKw + m.name + '(' + params + ') {')
+        self.indIn()
+        for s in m.body: self.genStmt(s)
+        self.indOut()
+        self.emit('}')
+      self.blank()
+    self.indOut()
+    self.emit('}')
+    self.blank()
+
+  fn genIf(node):
+    self.emit('if (' + self.genExpr(node.cond) + ') {')
+    self.indIn()
+    for s in node.then: self.genStmt(s)
+    self.indOut()
+    self.emit('}')
+    for ei in node.elseifs:
+      self.emitRaw(self.i() + 'else if (' + self.genExpr(ei.cond) + ') {')
+      self.indIn()
+      for s in ei.body: self.genStmt(s)
+      self.indOut()
+      self.emit('}')
+    if node.else_:
+      self.emitRaw(self.i() + 'else {')
+      self.indIn()
+      for s in node.else_: self.genStmt(s)
+      self.indOut()
+      self.emit('}')
+
+  fn genFor(node):
+    val varName = node["var"]
+    val iter = node.iter
+    if iter.type == 'RangeExpr':
+      val s = self.genExpr(iter.start)
+      val e = self.genExpr(iter.end)
+      self.emit('for (let ' + varName + ' = ' + s + '; ' + varName + ' < ' + e + '; ' + varName + '++) {')
+    else if node.isAwait:
+      self.emit('for await (const ' + varName + ' of ' + self.genExpr(iter) + ') {')
+    else:
+      self.emit('for (const ' + varName + ' of ' + self.genExpr(iter) + ') {')
+    self._loopDepth = self._loopDepth + 1
+    self.indIn()
+    for s in node.body: self.genStmt(s)
+    self.indOut()
+    self._loopDepth = self._loopDepth - 1
+    self.emit('}')
+
+  fn genWhile(node):
+    self.emit('while (' + self.genExpr(node.cond) + ') {')
+    self._loopDepth = self._loopDepth + 1
+    self.indIn()
+    for s in node.body: self.genStmt(s)
+    self.indOut()
+    self._loopDepth = self._loopDepth - 1
+    self.emit('}')
+
+  fn genMatch(node):
+    val subj = self.genExpr(node.subject)
+    val arms = node.arms
+    var hasOpenIf = false
+    for arm in arms:
+      val pat = arm.pattern
+      var cond = ""
+      val bindings = []
+      if pat.type == 'WildcardPat':
+        cond = ""
+      else if pat.type == 'RangePat':
+        val lo = self.genExpr(pat.start)
+        val hi = self.genExpr(pat.end)
+        cond = subj + ' >= ' + lo + ' && ' + subj + ' <= ' + hi
+      else if pat.type == 'VariantPat':
+        cond = subj + '?.__type === "' + pat.variant + '"'
+        var bi = 0
+        for b in pat.bindings:
+          bindings.push('const ' + b + ' = ' + subj + '.__args[' + bi + '];')
+          bi = bi + 1
+      else:
+        val patExpr = self.genExpr(pat.value)
+        if pat.value.type == 'Identifier' and /^[A-Z]/.test(pat.value.name):
+          cond = '(' + subj + ' === ' + patExpr + ' || ' + subj + '?.__type === "' + pat.value.name + '")'
+        else:
+          cond = subj + ' === ' + patExpr
+      if arm.guard:
+        val guardSrc = self.genExpr(arm.guard)
+        if bindings.length > 0:
+          val rebindings = bindings.map(bx -> bx.replace('const ', 'var ')).join(' ')
+          val iife = '(function(){ ' + rebindings + ' return (' + guardSrc + '); }())'
+          cond = cond ? '(' + cond + ') && ' + iife : iife
+        else:
+          cond = cond ? '(' + cond + ') && (' + guardSrc + ')' : guardSrc
+      if not hasOpenIf and cond:
+        self.emit('if (' + cond + ') {')
+        hasOpenIf = true
+      else if not hasOpenIf and not cond:
+        self.emit('if (true) {')
+        hasOpenIf = true
+      else if hasOpenIf and cond:
+        self.emitRaw(self.i() + 'else if (' + cond + ') {')
+      else:
+        self.emitRaw(self.i() + 'else {')
+      self.indIn()
+      for b in bindings: self.emit(b)
+      if arm.inline:
+        val exprSrc = self.genExpr(arm.body[0].expr)
+        if self._loopDepth > 0:
+          self.emit(exprSrc + ';')
+        else:
+          self.emit('return ' + exprSrc + ';')
+      else:
+        for s in arm.body: self.genStmt(s)
+      self.indOut()
+      self.emit('}')
+
+  fn genInterfaceDecl(node):
+    self.blank()
+    self.emit('// interface ' + node.name)
+    self.blank()
+
+  fn genEnumDecl(node):
+    self.blank()
+    val pairs = node.members.map(m -> m.name + ': ' + self.genExpr(m.value)).join(', ')
+    self.emit('const ' + node.name + ' = Object.freeze({ ' + pairs + ' });')
+    self.blank()
+
+  fn genTypeDecl(node):
+    self.blank()
+    self.emit('// ADT type: ' + node.name)
+    for v in node.variants:
+      if v.fields.length == 0:
+        self.emit('const ' + v.name + ' = Object.freeze({ __type: "' + v.name + '", __args: [] });')
+      else:
+        val params  = v.fields.join(', ')
+        val argsArr = '[' + v.fields.join(', ') + ']'
+        val fieldsObj = v.fields.map(f -> f + ': ' + f).join(', ')
+        self.emit('function ' + v.name + '(' + params + ') { return Object.freeze({ __type: "' + v.name + '", __args: ' + argsArr + ', ' + fieldsObj + ' }); }')
+    self.blank()
+
+  fn genReturn(node):
+    if node.value: self.emit('return ' + self.genExpr(node.value) + ';')
+    else: self.emit('return;')
+
+  fn genTryCatch(node):
+    self.emit('try {')
+    self.indIn()
+    for s in node.tryBody: self.genStmt(s)
+    self.indOut()
+    self.emit('}')
+    if node.catchBody:
+      val param = node.catchParam ? '(' + node.catchParam + ')' : '(_err)'
+      self.emitRaw(self.i() + 'catch ' + param + ' {')
+      self.indIn()
+      for s in node.catchBody: self.genStmt(s)
+      self.indOut()
+      self.emit('}')
+    if node.finallyBody:
+      self.emitRaw(self.i() + 'finally {')
+      self.indIn()
+      for s in node.finallyBody: self.genStmt(s)
+      self.indOut()
+      self.emit('}')
+
+  fn genThrow(node):
+    self.emit('throw ' + self.genExpr(node.value) + ';')
+
+  fn genDoWhile(node):
+    self.emit('do {')
+    self.indIn()
+    for s in node.body: self.genStmt(s)
+    self.indOut()
+    self.emit('} while (' + self.genExpr(node.cond) + ');')
+
+  fn genImport(node):
+    val src = String(node.source)
+    if node.namespaceName:
+      self.emit('const ' + node.namespaceName + ' = require("' + src + '");')
+    else if node.defaultName:
+      self.emit('const ' + node.defaultName + ' = require("' + src + '");')
+    else if node.names.length:
+      val parts = node.names.map(n -> (typeof n == 'string' ? n : (n.name != n.alias ? n.name + ': ' + n.alias : n.name))).join(', ')
+      self.emit('const { ' + parts + ' } = require("' + src + '");')
+
+  fn genExport(node):
+    if node.isDefault:
+      self.emit('module.exports = ' + self.genExpr(node.decl) + ';')
+      return
+    val decl = node.decl
+    if decl.type == 'FnDecl':
+      val asyncKw = decl.async ? 'async ' : ''
+      val params  = decl.params.map(p ->
+        p.rest ? '...' + p.name :
+        p.defaultVal ? p.name + ' = ' + self.genExpr(p.defaultVal) :
+        p.name
+      ).join(', ')
+      if decl.inline:
+        self.emit(asyncKw + 'function ' + decl.name + '(' + params + ') { return ' + self.genExpr(decl.body) + '; }')
+      else:
+        self.emit(asyncKw + 'function ' + decl.name + '(' + params + ') {')
+        self.indIn()
+        for s in decl.body: self.genStmt(s)
+        self.indOut()
+        self.emit('}')
+      self.emit('module.exports.' + decl.name + ' = ' + decl.name + ';')
+    else if decl.type == 'ClassDecl':
+      self.genClass(decl)
+      self.emit('module.exports.' + decl.name + ' = ' + decl.name + ';')
+    else if decl.type == 'TypeDecl':
+      self.genTypeDecl(decl)
+      for v in decl.variants: self.emit('module.exports.' + v.name + ' = ' + v.name + ';')
+    else if decl.type == 'InterfaceDecl':
+      self.genInterfaceDecl(decl)
+    else if decl.type == 'EnumDecl':
+      self.genEnumDecl(decl)
+      self.emit('module.exports.' + decl.name + ' = ' + decl.name + ';')
+    else if decl.type == 'VarDecl':
+      val kw = decl.kind == 'val' ? 'const' : 'let'
+      self.emit(kw + ' ' + decl.name + ' = ' + self.genExpr(decl.init) + ';')
+      self.emit('module.exports.' + decl.name + ' = ' + decl.name + ';')
+    else:
+      self.genStmt(decl)
+
+  fn genExpr(node):
+    if not node: return 'undefined'
+    if node.type == 'NumberLit':  return String(node.value)
+    if node.type == 'BoolLit':    return String(node.value)
+    if node.type == 'NullLit':    return 'null'
+    if node.type == 'SelfExpr':   return 'this'
+    if node.type == 'Identifier': return node.name == 'print' ? 'console.log' : node.name
+    if node.type == 'StringLit':  return JSON.stringify(node.value)
+    if node.type == 'RegexLit':   return '/' + node.value.pattern + '/' + node.value.flags
+    if node.type == 'TemplateLit': return self.genTemplate(node.parts)
+    if node.type == 'BinaryExpr':
+      return '(' + self.genExpr(node.left) + ' ' + node.op + ' ' + self.genExpr(node.right) + ')'
+    if node.type == 'UnaryExpr':
+      return node.op + self.genExpr(node.operand)
+    if node.type == 'UpdateExpr':
+      if node.prefix: return node.op + self.genExpr(node.operand)
+      return self.genExpr(node.operand) + node.op
+    if node.type == 'TernaryExpr':
+      return '(' + self.genExpr(node.cond) + ' ? ' + self.genExpr(node.then) + ' : ' + self.genExpr(node.else_) + ')'
+    if node.type == 'AssignExpr':
+      return self.genExpr(node.target) + ' ' + node.op + ' ' + self.genExpr(node.value)
+    if node.type == 'AwaitExpr':
+      return 'await ' + self.genExpr(node.operand)
+    if node.type == 'TypeofExpr':
+      return 'typeof ' + self.genExpr(node.operand)
+    if node.type == 'SpreadExpr':
+      return '...' + self.genExpr(node.expr)
+    if node.type == 'CallExpr':
+      val callee = self.genExpr(node.callee)
+      val args   = node.args.map(a -> self.genExpr(a)).join(', ')
+      return callee + '(' + args + ')'
+    if node.type == 'MemberExpr':
+      val objSrc = self.genExpr(node.obj)
+      val wrapped = node.obj.type == 'NumberLit' ? '(' + objSrc + ')' : objSrc
+      return wrapped + '.' + node.prop
+    if node.type == 'OptMemberExpr':
+      return self.genExpr(node.obj) + '?.' + node.prop
+    if node.type == 'OptIndexExpr':
+      return self.genExpr(node.obj) + '?.[' + self.genExpr(node.idx) + ']'
+    if node.type == 'OptCallExpr':
+      val args = node.args.map(a -> self.genExpr(a)).join(', ')
+      return self.genExpr(node.callee) + '?.(' + args + ')'
+    if node.type == 'IndexExpr':
+      return self.genExpr(node.obj) + '[' + self.genExpr(node.idx) + ']'
+    if node.type == 'NewExpr':
+      val args = node.args.map(a -> self.genExpr(a)).join(', ')
+      return 'new ' + node.callee + '(' + args + ')'
+    if node.type == 'LambdaExpr':
+      val params = node.params.map(p -> p.rest ? '...' + p.name : p.name).join(', ')
+      return '(' + params + ') => ' + self.genExpr(node.body)
+    if node.type == 'FnDecl':
+      val asyncKw = node.async ? 'async ' : ''
+      val params  = node.params.map(p ->
+        p.rest ? '...' + p.name :
+        p.defaultVal ? p.name + ' = ' + self.genExpr(p.defaultVal) :
+        p.name
+      ).join(', ')
+      if node.inline:
+        return asyncKw + 'function(' + params + ') { return ' + self.genExpr(node.body) + '; }'
+      val saved = self.lines.length
+      val savedLevel = self.level
+      self.emit(asyncKw + 'function(' + params + ') {')
+      self.indIn()
+      for s in node.body: self.genStmt(s)
+      self.indOut()
+      self.emit('}')
+      val block = self.lines.splice(saved).map(l -> l.trimStart()).join(' ')
+      self.level = savedLevel
+      return block
+    if node.type == 'MatchStmt':
+      val saved = self.lines.length
+      val savedLevel = self.level
+      val savedLoop = self._loopDepth
+      self._loopDepth = 0
+      self.emit('(() => {')
+      self.indIn()
+      self.genMatch(node)
+      self.indOut()
+      self.emit('})()')
+      self._loopDepth = savedLoop
+      val block = self.lines.splice(saved).map(l -> l.trimStart()).join(' ')
+      self.level = savedLevel
+      return block
+    if node.type == 'ArrayExpr':
+      return '[' + node.items.map(i -> self.genExpr(i)).join(', ') + ']'
+    if node.type == 'ObjectExpr':
+      val pairs = node.pairs.map(p -> self.genObjPair(p)).join(', ')
+      return '{ ' + pairs + ' }'
+    if node.type == 'RangeExpr':
+      return 'Array.from({ length: ' + self.genExpr(node.end) + ' - ' + self.genExpr(node.start) + ' }, (_, i) => i + ' + self.genExpr(node.start) + ')'
+    if node.type == 'PipeExpr':
+      return self.genPipe(node)
+    if node.type == 'CastExpr':     return self.genExpr(node.expr)
+    if node.type == 'AsConstExpr':  return 'Object.freeze(' + self.genExpr(node.expr) + ')'
+    if node.type == 'SatisfiesExpr': return self.genExpr(node.expr)
+    if node.type == 'IsExpr':       return self.genExpr(node.expr)
+    if node.type == 'NonNullExpr':  return self.genExpr(node.expr)
+    throw new Error("Unknown expression: {node.type}")
+
+  fn genTemplate(parts):
+    var result = '`'
+    for p in parts:
+      if p.type == 'text':
+        result += p.value.replace(/`/g, '\\`').replace(/\$/g, '\\$')
+      else:
+        val fmtInfo = extractFormatSpec(p.value)
+        val exprSrc = fmtInfo ? fmtInfo.expr : p.value
+        val fmt     = fmtInfo ? fmtInfo.fmt  : null
+        try:
+          val tokens = lexerize(exprSrc).tokenize()
+          val expr   = makeParser(tokens).parseExpr()
+          val gen    = self.genExpr(expr)
+          if fmt:
+            self._needsFmt = true
+            result += '$' + '{_fmt(' + gen + ', ' + JSON.stringify(fmt) + ')}'
+          else:
+            result += '$' + '{' + gen + '}'
+        catch(err):
+          result += '$' + '{' + p.value + '}'
+    result += '`'
+    return result
+
+  fn genPipe(node):
+    val left  = self.genExpr(node.left)
+    val right = node.right
+    if right.type == 'Identifier':
+      return self.genExpr(right) + '(' + left + ')'
+    if right.type == 'CallExpr':
+      val fn_   = self.genExpr(right.callee)
+      val rest  = right.args.map(a -> self.genExpr(a)).join(', ')
+      return rest ? fn_ + '(' + left + ', ' + rest + ')' : fn_ + '(' + left + ')'
+    return '(' + self.genExpr(right) + ')(' + left + ')'
+
+export fn makeCodeGen(opts):
+  val ind = opts?.indent ?? '    '
+  val smb = opts?.smBuilder ?? null
+  return new CodeGenerator(ind, 0, [], {}, smb, false, 0)