septima-lang 0.0.21 → 0.2.0

package/src/result.ts

@@ -0,0 +1,54 @@
+import { AstNode, UnitId } from './ast-node'
+import { failMe } from './fail-me'
+import { Span } from './location'
+import { SourceUnit } from './septima'
+
+export type ResultSink = {
+  tag: 'sink'
+  where: Span | undefined
+  trace: string | undefined
+  symbols: Record<string, unknown> | undefined
+  message: string
+}
+
+export type Result =
+  | {
+      tag: 'ok'
+      value: unknown
+    }
+  | ResultSink
+
+const sourceCode = (unitId: string, unitByUnitId: Map<UnitId, SourceUnit>) =>
+  (unitByUnitId.get(unitId) ?? failMe(`source code not found for ${unitId}`)).sourceCode
+
+export function formatTrace(trace: AstNode[] | undefined, unitByUnitId: Map<UnitId, SourceUnit>) {
+  if (!trace) {
+    return undefined
+  }
+  const format = (ast: AstNode) => sourceCode(ast.unitId, unitByUnitId).formatAst(ast)
+
+  const spacer = '  '
+  const joined = trace
+    .map(at => format(at))
+    .reverse()
+    .join(`\n${spacer}`)
+  return joined ? `${spacer}${joined}` : undefined
+}
+
+// TODO(imaman): generate a stack trace that is similar to node's a-la:
+// $ node a.js
+// /home/imaman/code/imaman/bigband/d.js:3
+//     return arg.n.foo()
+//                  ^
+//
+// TypeError: Cannot read properties of undefined (reading 'foo')
+//     at d (/home/imaman/code/imaman/bigband/d.js:3:18)
+//     at c (/home/imaman/code/imaman/bigband/c.js:4:15)
+//     at b (/home/imaman/code/imaman/bigband/b.js:4:15)
+//     at Object.<anonymous> (/home/imaman/code/imaman/bigband/a.js:3:1)
+//     at Module._compile (node:internal/modules/cjs/loader:1155:14)
+//     at Object.Module._extensions..js (node:internal/modules/cjs/loader:1209:10)
+//     at Module.load (node:internal/modules/cjs/loader:1033:32)
+//     at Function.Module._load (node:internal/modules/cjs/loader:868:12)
+//     at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:81:12)
+//     at node:internal/main/run_main_module:22:47

package/src/runtime.ts

@@ -0,0 +1,462 @@
+import crypto from 'crypto'
+
+import { AstNode, show, Unit, UnitId } from './ast-node'
+import { extractMessage } from './extract-message'
+import { failMe } from './fail-me'
+import { shouldNeverHappen } from './should-never-happen'
+import * as Stack from './stack'
+import { switchOn } from './switch-on'
+import { SymbolTable, Visibility } from './symbol-table'
+import { Value } from './value'
+
+interface Placeholder {
+  destination: undefined | Value
+}
+
+class SymbolFrame implements SymbolTable {
+  constructor(
+    readonly symbol: string,
+    readonly placeholder: Placeholder,
+    private readonly earlier: SymbolTable,
+    private readonly visibility: Visibility,
+  ) {}
+
+  lookup(sym: string): Value {
+    if (this.symbol === sym) {
+      const ret = this.placeholder.destination
+      if (ret === undefined) {
+        throw new Error(`Unresolved definition: ${this.symbol}`)
+      }
+      return ret
+    }
+
+    return this.earlier.lookup(sym)
+  }
+
+  export() {
+    const ret = this.earlier.export()
+    ret[this.symbol] = this.placeholder.destination?.export() ?? failMe(`Unbounded symbol: ${this.symbol}`)
+    return ret
+  }
+
+  exportValue(): Record<string, Value> {
+    const ret = this.earlier.exportValue()
+    if (this.visibility === 'INTERNAL') {
+      return ret
+    }
+
+    if (this.visibility === 'EXPORTED') {
+      ret[this.symbol] = this.placeholder.destination ?? failMe(`Unbounded symbol: ${this.symbol}`)
+      return ret
+    }
+
+    shouldNeverHappen(this.visibility)
+  }
+}
+
+class EmptySymbolTable implements SymbolTable {
+  lookup(sym: string): Value {
+    throw new Error(`Symbol ${sym} was not found`)
+  }
+
+  export() {
+    return {}
+  }
+
+  exportValue(): Record<string, Value> {
+    return {}
+  }
+}
+
+export type Verbosity = 'quiet' | 'trace'
+export type Outputter = (u: unknown) => void
+
+export class Runtime {
+  private stack: Stack.T = undefined
+  constructor(
+    private readonly root: AstNode,
+    private readonly verbosity: Verbosity = 'quiet',
+    private readonly getAstOf: (importerAsPathFromSourceRoot: string, relativePathFromImporter: string) => Unit,
+    private readonly args: Record<string, unknown>,
+    private readonly consoleLog?: Outputter,
+  ) {}
+
+  private output(v: Value) {
+    const logger = this.consoleLog ?? console.log // eslint-disable-line no-console
+    logger(JSON.stringify(v))
+  }
+
+  private buildInitialSymbolTable(generateTheArgsObject: boolean) {
+    const empty = new EmptySymbolTable()
+
+    const keys = Value.foreign(o => o.keys())
+    const entries = Value.foreign(o => o.entries())
+    const fromEntries = Value.foreign(o => o.fromEntries())
+    const isArray = Value.foreign(o => o.isArray())
+    const log = Value.foreign(o => {
+      this.output(o)
+      return o
+    })
+
+    const parse = Value.foreign(o => JSON.parse(o.toString()))
+    const hash224 = Value.foreign(o => crypto.createHash('sha224').update(JSON.stringify(o.unwrap())).digest('hex'))
+
+    let lib = new SymbolFrame('Object', { destination: Value.obj({ keys, entries, fromEntries }) }, empty, 'INTERNAL')
+    lib = new SymbolFrame('String', { destination: Value.foreign(o => Value.str(o.toString())) }, lib, 'INTERNAL')
+    lib = new SymbolFrame('Boolean', { destination: Value.foreign(o => Value.bool(o.toBoolean())) }, lib, 'INTERNAL')
+    lib = new SymbolFrame('Number', { destination: Value.foreign(o => Value.num(o.toNumber())) }, lib, 'INTERNAL')
+    lib = new SymbolFrame('Array', { destination: Value.obj({ isArray }) }, lib, 'INTERNAL')
+    lib = new SymbolFrame('console', { destination: Value.obj({ log }) }, lib, 'INTERNAL')
+    lib = new SymbolFrame('JSON', { destination: Value.obj({ parse }) }, lib, 'INTERNAL')
+    lib = new SymbolFrame('crypto', { destination: Value.obj({ hash224 }) }, lib, 'INTERNAL')
+
+    if (generateTheArgsObject) {
+      lib = new SymbolFrame('args', { destination: Value.from(this.args) }, lib, 'INTERNAL')
+    }
+
+    return lib
+  }
+
+  compute() {
+    try {
+      const value = this.evalNode(this.root, this.buildInitialSymbolTable(true))
+      return { value }
+    } catch (e) {
+      const trace: AstNode[] = []
+      for (let curr = this.stack; curr; curr = curr?.next) {
+        trace.push(curr.ast)
+      }
+      return {
+        expressionTrace: trace,
+        errorMessage: extractMessage(e),
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        stack: (e as { stack?: string[] }).stack,
+      }
+    }
+  }
+
+  private evalNode(ast: AstNode, table: SymbolTable): Value {
+    this.stack = Stack.push(ast, this.stack)
+    const ret = this.evalNodeImpl(ast, table)
+    switchOn(this.verbosity, {
+      quiet: () => {},
+      trace: () => {
+        // eslint-disable-next-line no-console
+        console.log(`output of <|${show(ast)}|> is ${JSON.stringify(ret)}  // ${ast.tag}`)
+      },
+    })
+    this.stack = Stack.pop(this.stack)
+    return ret
+  }
+
+  private importDefinitions(importerAsPathFromSourceRoot: UnitId, relativePathFromImporter: string): Value {
+    const importee = this.getAstOf(importerAsPathFromSourceRoot, relativePathFromImporter)
+    const exp = importee.expression
+    if (
+      exp.tag === 'arrayLiteral' ||
+      exp.tag === 'binaryOperator' ||
+      exp.tag === 'dot' ||
+      exp.tag === 'export*' ||
+      exp.tag === 'functionCall' ||
+      exp.tag === 'ident' ||
+      exp.tag === 'formalArg' ||
+      exp.tag === 'if' ||
+      exp.tag === 'ternary' ||
+      exp.tag === 'indexAccess' ||
+      exp.tag === 'lambda' ||
+      exp.tag === 'literal' ||
+      exp.tag === 'objectLiteral' ||
+      exp.tag === 'templateLiteral' ||
+      exp.tag === 'unaryOperator' ||
+      exp.tag === 'unit'
+    ) {
+      // TODO(imaman): throw an error on non-exporting unit?
+      return Value.obj({})
+    }
+
+    if (exp.tag === 'topLevelExpression') {
+      // Construct a syntehtic unit which is similar to importedUnit but override its expression with an expression that
+      // just returns the importee's definitions bundled in a single object (an export* expression), and evaluate it.
+      // This is the trick that allows the importer to gain access to the importee's own stuff.
+      const exporStarUnit: AstNode = {
+        tag: 'unit',
+        imports: importee.imports,
+        unitId: importee.unitId,
+        expression: {
+          tag: 'topLevelExpression',
+          definitions: exp.definitions,
+          unitId: importee.unitId,
+          computation: { tag: 'export*', unitId: importee.unitId },
+        },
+      }
+      return this.evalNode(exporStarUnit, this.buildInitialSymbolTable(false))
+    }
+
+    shouldNeverHappen(exp)
+  }
+
+  private evalNodeImpl(ast: AstNode, table: SymbolTable): Value {
+    if (ast.tag === 'unit') {
+      let newTable = table
+      for (const imp of ast.imports) {
+        const o = this.importDefinitions(ast.unitId, imp.pathToImportFrom.text)
+        newTable = new SymbolFrame(imp.ident.t.text, { destination: o }, newTable, 'INTERNAL')
+      }
+      return this.evalNode(ast.expression, newTable)
+    }
+    if (ast.tag === 'topLevelExpression') {
+      let newTable = table
+      for (const def of ast.definitions) {
+        const name = def.ident.t.text
+        const placeholder: Placeholder = { destination: undefined }
+        newTable = new SymbolFrame(name, placeholder, newTable, def.isExported ? 'EXPORTED' : 'INTERNAL')
+        const v = this.evalNode(def.value, newTable)
+        placeholder.destination = v
+      }
+
+      if (!ast.computation) {
+        return Value.str('')
+      }
+      const c = this.evalNode(ast.computation, newTable)
+      if (ast.throwToken) {
+        throw new Error(JSON.stringify(c))
+      }
+
+      return c
+    }
+
+    if (ast.tag === 'export*') {
+      return Value.obj(table.exportValue())
+    }
+
+    if (ast.tag === 'binaryOperator') {
+      const lhs = this.evalNode(ast.lhs, table)
+      if (ast.operator === '||') {
+        return lhs.or(() => this.evalNode(ast.rhs, table))
+      }
+      if (ast.operator === '&&') {
+        return lhs.and(() => this.evalNode(ast.rhs, table))
+      }
+
+      const rhs = this.evalNode(ast.rhs, table)
+      if (ast.operator === '!=') {
+        return lhs.equalsTo(rhs).not()
+      }
+      if (ast.operator === '==') {
+        return lhs.equalsTo(rhs)
+      }
+
+      if (ast.operator === '<=') {
+        const comp = lhs.order(rhs)
+        return comp.isToZero('<=')
+      }
+      if (ast.operator === '<') {
+        const comp = lhs.order(rhs)
+        return comp.isToZero('<')
+      }
+      if (ast.operator === '>=') {
+        const comp = lhs.order(rhs)
+        return comp.isToZero('>=')
+      }
+      if (ast.operator === '>') {
+        const comp = lhs.order(rhs)
+        return comp.isToZero('>')
+      }
+      if (ast.operator === '%') {
+        return lhs.modulo(rhs)
+      }
+      if (ast.operator === '*') {
+        return lhs.times(rhs)
+      }
+      if (ast.operator === '**') {
+        return lhs.power(rhs)
+      }
+      if (ast.operator === '+') {
+        return lhs.plus(rhs)
+      }
+      if (ast.operator === '-') {
+        return lhs.minus(rhs)
+      }
+      if (ast.operator === '/') {
+        return lhs.over(rhs)
+      }
+
+      if (ast.operator === '??') {
+        return lhs.coalesce(() => this.evalNode(ast.rhs, table))
+      }
+
+      shouldNeverHappen(ast.operator)
+    }
+
+    if (ast.tag === 'unaryOperator') {
+      const operand = this.evalNode(ast.operand, table)
+      if (ast.operator === '!') {
+        return operand.not()
+      }
+      if (ast.operator === '+') {
+        // We intentionally do <0 + operand> instead of just <operand>. This is due to type-checking: the latter will
+        // evaluate to the operand as-is, making expression such as `+true` dynamically valid (which is not the desired
+        // behavior)
+        return Value.num(0).plus(operand)
+      }
+      if (ast.operator === '-') {
+        return operand.negate()
+      }
+
+      shouldNeverHappen(ast.operator)
+    }
+    if (ast.tag === 'ident') {
+      return table.lookup(ast.t.text)
+    }
+
+    if (ast.tag === 'formalArg') {
+      if (ast.defaultValue) {
+        return this.evalNode(ast.defaultValue, table)
+      }
+
+      // This error should not be reached. The call flow should evaluate a formalArg node only when if it has
+      // a default value sud-node.
+      throw new Error(`no default value for ${ast}`)
+    }
+
+    if (ast.tag === 'literal') {
+      if (ast.type === 'bool') {
+        // TODO(imaman): stricter checking of 'false'
+        return Value.bool(ast.t.text === 'true' ? true : false)
+      }
+      if (ast.type === 'num') {
+        return Value.num(Number(ast.t.text))
+      }
+      if (ast.type === 'str') {
+        return Value.str(ast.t.text)
+      }
+
+      if (ast.type === 'undef') {
+        return Value.undef()
+      }
+      shouldNeverHappen(ast.type)
+    }
+
+    if (ast.tag === 'templateLiteral') {
+      const result = ast.parts
+        .map(part => {
+          if (part.tag === 'string') {
+            return part.value
+          }
+          if (part.tag === 'expression') {
+            return this.evalNode(part.expr, table).toString()
+          }
+          shouldNeverHappen(part)
+        })
+        .join('')
+      return Value.str(result)
+    }
+
+    if (ast.tag === 'arrayLiteral') {
+      const arr: Value[] = []
+      for (const curr of ast.parts) {
+        if (curr.tag === 'element') {
+          arr.push(this.evalNode(curr.v, table))
+        } else if (curr.tag === 'spread') {
+          const v = this.evalNode(curr.v, table)
+          if (v.isUndefined()) {
+            continue
+          }
+          arr.push(...v.assertArr())
+        } else {
+          shouldNeverHappen(curr)
+        }
+      }
+
+      return Value.arr(arr)
+    }
+
+    if (ast.tag === 'objectLiteral') {
+      const entries: [string, Value][] = ast.parts.flatMap(at => {
+        if (at.tag === 'hardName') {
+          return [[at.k.t.text, this.evalNode(at.v, table)]]
+        }
+        if (at.tag === 'quotedString') {
+          return [[at.k.t.text, this.evalNode(at.v, table)]]
+        }
+        if (at.tag === 'computedName') {
+          return [[this.evalNode(at.k, table).assertStr(), this.evalNode(at.v, table)]]
+        }
+        if (at.tag === 'spread') {
+          const o = this.evalNode(at.o, table)
+          if (o.isUndefined()) {
+            return []
+          }
+          return Object.entries(o.assertObj())
+        }
+
+        shouldNeverHappen(at)
+      })
+
+      // TODO(imaman): verify type of all keys (strings, maybe also numbers)
+      return Value.obj(Object.fromEntries(entries.filter(([_, v]) => !v.isUndefined())))
+    }
+
+    if (ast.tag === 'lambda') {
+      return Value.lambda(ast, table)
+    }
+
+    if (ast.tag === 'functionCall') {
+      const argValues = ast.actualArgs.map(a => this.evalNode(a, table))
+      const callee = this.evalNode(ast.callee, table)
+
+      return this.call(callee, argValues)
+    }
+
+    if (ast.tag === 'if' || ast.tag === 'ternary') {
+      const c = this.evalNode(ast.condition, table)
+      return c.ifElse(
+        () => this.evalNode(ast.positive, table),
+        () => this.evalNode(ast.negative, table),
+      )
+    }
+
+    if (ast.tag === 'dot') {
+      const rec = this.evalNode(ast.receiver, table)
+      if (rec === undefined || rec === null) {
+        throw new Error(`Cannot access attribute .${ast.ident.t.text} of ${rec}`)
+      }
+      return rec.access(ast.ident.t.text, (callee, args) => this.call(callee, args))
+    }
+
+    if (ast.tag === 'indexAccess') {
+      const rec = this.evalNode(ast.receiver, table)
+      const index = this.evalNode(ast.index, table)
+      return rec.access(index, (callee, args) => this.call(callee, args))
+    }
+
+    shouldNeverHappen(ast)
+  }
+
+  call(callee: Value, actualValues: Value[]) {
+    return callee.call(actualValues, (formals, body, lambdaTable: SymbolTable) => {
+      const requiredCount = formals.filter(f => !f.defaultValue).length
+      if (actualValues.length < requiredCount) {
+        throw new Error(`Expected at least ${requiredCount} argument(s) but got ${actualValues.length}`)
+      }
+
+      let newTable = lambdaTable
+      for (let i = 0; i < formals.length; ++i) {
+        const formal = formals[i]
+        let actual = actualValues.at(i)
+        const useDefault = actual === undefined || (actual.isUndefined() && formal.defaultValue)
+
+        if (useDefault && formal.defaultValue) {
+          actual = this.evalNode(formal.defaultValue, lambdaTable)
+        }
+
+        if (actual === undefined) {
+          throw new Error(`A value must be passed to formal argument: ${show(formal.ident)}`)
+        }
+
+        newTable = new SymbolFrame(formal.ident.t.text, { destination: actual }, newTable, 'INTERNAL')
+      }
+      return this.evalNode(body, newTable)
+    })
+  }
+}

package/src/scanner.ts

@@ -0,0 +1,136 @@
+import { Location } from './location'
+import { SourceCode } from './source-code'
+
+export interface Token {
+  readonly text: string
+  readonly location: Location
+}
+
+type ConsumeIfBasicPattern = RegExp | string
+type ConsumeIfPattern = { either: ConsumeIfBasicPattern[]; noneOf: ConsumeIfBasicPattern[] }
+
+export class Scanner {
+  constructor(readonly sourceCode: SourceCode, private offset = 0) {
+    if (this.offset === 0) {
+      this.eatWhitespace()
+    }
+  }
+
+  get sourceRef() {
+    return this.sourceCode.sourceRef(this.sourceCode.expandToEndOfLine({ offset: this.offset }))
+  }
+
+  private curr() {
+    return this.sourceCode.input.substring(this.offset)
+  }
+
+  private eatBlockComment() {
+    const startedAt = this.sourceRef
+    while (true) {
+      if (this.eof()) {
+        throw new Error(`Block comment that started at ${startedAt} is missing its closing (*/)`)
+      }
+      if (this.consumeIf('*/')) {
+        return
+      }
+
+      // By default, the . symbol in regexp does _not_ match newline. we use /./s to override the default.
+      this.consume(/./s, false)
+    }
+  }
+
+  private eatWhitespace() {
+    while (true) {
+      if (this.consumeIf(/\s*/, false)) {
+        continue
+      }
+      if (this.consumeIf('//', false)) {
+        this.consume(/[^\n]*/, false)
+        continue
+      }
+      if (this.consumeIf('/*', false)) {
+        this.eatBlockComment()
+        continue
+      }
+
+      return
+    }
+  }
+
+  eof(): boolean {
+    return this.offset >= this.sourceCode.input.length
+  }
+
+  synopsis() {
+    const c = this.curr()
+    let lookingAt = c.substring(0, 20)
+    if (lookingAt.length !== c.length) {
+      lookingAt = `${lookingAt}...`
+    }
+
+    return {
+      position: this.offset,
+      lookingAt,
+    }
+  }
+
+  headMatches(...patterns: (ConsumeIfPattern | ConsumeIfBasicPattern)[]): boolean {
+    const alt = new Scanner(this.sourceCode, this.offset)
+    for (const p of patterns) {
+      const t = alt.consumeIf(p, true)
+      if (t === undefined) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  consume(r: RegExp | string, eatWhitespace = true): Token {
+    const text = this.match(r)
+    if (text === undefined) {
+      throw new Error(`Expected ${r} ${this.sourceRef}`)
+    }
+
+    const offset = this.offset
+    this.offset += text.length
+
+    if (eatWhitespace) {
+      this.eatWhitespace()
+    }
+    return { location: { offset }, text }
+  }
+
+  consumeIf(p: ConsumeIfBasicPattern | ConsumeIfPattern, eatWhitespace = true): Token | undefined {
+    const pattern = typeof p === 'string' ? { either: [p], noneOf: [] } : isRegExp(p) ? { either: [p], noneOf: [] } : p
+
+    const found = pattern.either.find(r => this.match(r))
+    const hasNegative = pattern.noneOf.some(r => this.match(r))
+    const ret = found && !hasNegative
+    if (!ret) {
+      return undefined
+    }
+
+    return this.consume(found, eatWhitespace)
+  }
+
+  private match(r: RegExp | string): string | undefined {
+    if (typeof r === 'string') {
+      if (this.curr().startsWith(r)) {
+        return r
+      }
+      return undefined
+    }
+
+    const m = this.curr().match(r)
+    if (m && m.index === 0) {
+      return m[0]
+    }
+
+    return undefined
+  }
+}
+
+function isRegExp(u: object): u is RegExp {
+  return u.constructor.name === 'RegExp'
+}