septima-lang 0.1.0 → 0.2.0

package/src/ast-node.ts

@@ -0,0 +1,340 @@
+import { Span } from './location'
+import { Token } from './scanner'
+import { shouldNeverHappen } from './should-never-happen'
+import { switchOn } from './switch-on'
+
+export type Let = { start: Token; ident: Ident; value: AstNode; isExported: boolean }
+
+export type UnitId = string
+
+export type Import = {
+  start: Token
+  ident: Ident
+  pathToImportFrom: Token
+  unitId: UnitId
+}
+
+export type Literal = {
+  tag: 'literal'
+  type: 'str' | 'bool' | 'num' | 'undef'
+  t: Token
+  unitId: UnitId
+}
+
+export type ObjectLiteralPart =
+  | { tag: 'hardName'; k: Ident; v: AstNode }
+  | { tag: 'quotedString'; k: Literal; v: AstNode }
+  | { tag: 'computedName'; k: AstNode; v: AstNode }
+  | { tag: 'spread'; o: AstNode }
+
+export type ArrayLiteralPart = { tag: 'element'; v: AstNode } | { tag: 'spread'; v: AstNode }
+
+export type TemplatePart = { tag: 'string'; value: string } | { tag: 'expression'; expr: AstNode }
+
+export type Ident = {
+  tag: 'ident'
+  t: Token
+  unitId: UnitId
+}
+
+export type FormalArg = {
+  tag: 'formalArg'
+  ident: Ident
+  defaultValue?: AstNode
+  unitId: UnitId
+}
+
+export type Lambda = {
+  tag: 'lambda'
+  start: Token
+  formalArgs: FormalArg[]
+  body: AstNode
+  unitId: UnitId
+}
+
+export type Unit = {
+  tag: 'unit'
+  imports: Import[]
+  expression: AstNode
+  unitId: UnitId
+}
+
+export type AstNode =
+  | Ident
+  | FormalArg
+  | Literal
+  | Unit
+  | {
+      start: Token
+      tag: 'arrayLiteral'
+      parts: ArrayLiteralPart[]
+      end: Token
+      unitId: UnitId
+    }
+  | {
+      start: Token
+      tag: 'objectLiteral'
+      parts: ObjectLiteralPart[]
+      end: Token
+      unitId: UnitId
+    }
+  | {
+      tag: 'binaryOperator'
+      operator: '+' | '-' | '*' | '/' | '**' | '%' | '&&' | '||' | '>' | '<' | '>=' | '<=' | '==' | '!=' | '??'
+      lhs: AstNode
+      rhs: AstNode
+      unitId: UnitId
+    }
+  | {
+      tag: 'unaryOperator'
+      operatorToken: Token
+      operator: '+' | '-' | '!'
+      operand: AstNode
+      unitId: UnitId
+    }
+  | {
+      tag: 'topLevelExpression'
+      definitions: Let[]
+      throwToken?: Token
+      computation?: AstNode
+      unitId: UnitId
+    }
+  | Lambda
+  | {
+      tag: 'ternary'
+      condition: AstNode
+      positive: AstNode
+      negative: AstNode
+      unitId: UnitId
+    }
+  | {
+      tag: 'functionCall'
+      actualArgs: AstNode[]
+      callee: AstNode
+      end: Token
+      unitId: UnitId
+    }
+  | {
+      tag: 'if'
+      condition: AstNode
+      positive: AstNode
+      negative: AstNode
+      unitId: UnitId
+    }
+  | {
+      tag: 'dot'
+      receiver: AstNode
+      ident: Ident
+      unitId: UnitId
+    }
+  | {
+      tag: 'indexAccess'
+      receiver: AstNode
+      index: AstNode
+      unitId: UnitId
+    }
+  | {
+      // A special AST node meant to be generated internally (needed for exporting definition from one unit to another).
+      // Not intended to be parsed from source code. Hence, it is effectively empty, and its location cannot be
+      // determined.
+      tag: 'export*'
+      unitId: UnitId
+    }
+  | {
+      tag: 'templateLiteral'
+      parts: TemplatePart[]
+      start: Token
+      end: Token
+      unitId: UnitId
+    }
+
+export function show(ast: AstNode | AstNode[]): string {
+  if (Array.isArray(ast)) {
+    return ast.map(curr => show(curr)).join(', ')
+  }
+
+  if (ast.tag === 'arrayLiteral') {
+    const parts = ast.parts.map(p => {
+      if (p.tag === 'element') {
+        return show(p.v)
+      }
+
+      if (p.tag === 'spread') {
+        return `...${show(p.v)}`
+      }
+
+      shouldNeverHappen(p)
+    })
+    return `[${parts.join(', ')}]`
+  }
+
+  if (ast.tag === 'binaryOperator') {
+    return `(${show(ast.lhs)} ${ast.operator} ${show(ast.rhs)})`
+  }
+  if (ast.tag === 'dot') {
+    return `${show(ast.receiver)}.${show(ast.ident)}`
+  }
+  if (ast.tag === 'export*') {
+    return `(export*)`
+  }
+  if (ast.tag === 'ternary') {
+    return `${show(ast.condition)} ? ${show(ast.positive)} : ${show(ast.negative)}`
+  }
+  if (ast.tag === 'functionCall') {
+    return `${show(ast.callee)}(${show(ast.actualArgs)})`
+  }
+  if (ast.tag === 'ident') {
+    return ast.t.text
+  }
+  if (ast.tag === 'formalArg') {
+    return ast.defaultValue ? `${show(ast.ident)} = ${show(ast.defaultValue)}` : show(ast.ident)
+  }
+  if (ast.tag === 'if') {
+    return `if (${show(ast.condition)}) ${show(ast.positive)} else ${show(ast.negative)}`
+  }
+  if (ast.tag === 'indexAccess') {
+    return `${show(ast.receiver)}[${show(ast.index)}]`
+  }
+  if (ast.tag === 'lambda') {
+    return `fun (${show(ast.formalArgs)}) ${show(ast.body)}`
+  }
+  if (ast.tag === 'literal') {
+    return switchOn(ast.type, {
+      bool: () => ast.t.text,
+      num: () => ast.t.text,
+      undef: () => 'undefined',
+      str: () => `'${ast.t.text}'`,
+    })
+  }
+  if (ast.tag === 'templateLiteral') {
+    const partsStr = ast.parts
+      .map(p => {
+        if (p.tag === 'string') {
+          return p.value
+        }
+        if (p.tag === 'expression') {
+          return `\${${show(p.expr)}}`
+        }
+        shouldNeverHappen(p)
+      })
+      .join('')
+    return `\`${partsStr}\``
+  }
+  if (ast.tag === 'objectLiteral') {
+    const pairs = ast.parts.map(p => {
+      if (p.tag === 'computedName') {
+        return `[${show(p.k)}]: ${show(p.v)}`
+      }
+
+      if (p.tag === 'hardName') {
+        return `${show(p.k)}: ${show(p.v)}`
+      }
+
+      if (p.tag === 'quotedString') {
+        return `${show(p.k)}: ${show(p.v)}`
+      }
+
+      if (p.tag === 'spread') {
+        return `...${show(p.o)}`
+      }
+
+      shouldNeverHappen(p)
+    })
+    return `{${pairs.join(', ')}}`
+  }
+  if (ast.tag === 'topLevelExpression') {
+    const defs = ast.definitions
+      .map(d => `${d.isExported ? 'export ' : ''}let ${show(d.ident)} = ${show(d.value)}`)
+      .join('; ')
+    const sep = defs && ast.computation ? ' ' : ''
+    return `${defs ? defs + ';' : ''}${sep}${ast.throwToken ? ast.throwToken.text + ' ' : ''}${
+      ast.computation ? show(ast.computation) : ''
+    }`
+  }
+  if (ast.tag === 'unaryOperator') {
+    return `${ast.operator}${show(ast.operand)}`
+  }
+  if (ast.tag === 'unit') {
+    const imports = ast.imports
+      .map(imp => `import * as ${show(imp.ident)} from '${imp.pathToImportFrom.text}';`)
+      .join('\n')
+    return `${imports ? imports + '\n' : ''}${show(ast.expression)}`
+  }
+
+  shouldNeverHappen(ast)
+}
+
+export function span(ast: AstNode): Span {
+  const ofRange = (a: Span, b: Span) => ({ from: a.from, to: b.to })
+  const ofToken = (t: Token) => ({ from: t.location, to: { offset: t.location.offset + t.text.length - 1 } })
+
+  if (ast.tag === 'arrayLiteral') {
+    return ofRange(ofToken(ast.start), ofToken(ast.end))
+  }
+  if (ast.tag === 'binaryOperator') {
+    return ofRange(span(ast.lhs), span(ast.rhs))
+  }
+  if (ast.tag === 'dot') {
+    return ofRange(span(ast.receiver), span(ast.ident))
+  }
+  if (ast.tag === 'functionCall') {
+    return ofRange(span(ast.callee), ofToken(ast.end))
+  }
+  if (ast.tag === 'ident') {
+    return ofToken(ast.t)
+  }
+  if (ast.tag === 'formalArg') {
+    if (ast.defaultValue) {
+      return ofRange(span(ast.ident), span(ast.defaultValue))
+    }
+    return span(ast.ident)
+  }
+
+  if (ast.tag === 'export*') {
+    return { from: { offset: 0 }, to: { offset: 0 } }
+  }
+  if (ast.tag === 'if') {
+    return ofRange(span(ast.condition), span(ast.negative))
+  }
+  if (ast.tag === 'indexAccess') {
+    return ofRange(span(ast.receiver), span(ast.index))
+  }
+  if (ast.tag === 'lambda') {
+    return ofRange(ofToken(ast.start), span(ast.body))
+  }
+  if (ast.tag === 'ternary') {
+    return ofRange(span(ast.condition), span(ast.negative))
+  }
+  if (ast.tag === 'literal') {
+    return ofToken(ast.t)
+  }
+  if (ast.tag === 'templateLiteral') {
+    return ofRange(ofToken(ast.start), ofToken(ast.end))
+  }
+  if (ast.tag === 'objectLiteral') {
+    return ofRange(ofToken(ast.start), ofToken(ast.end))
+  }
+  if (ast.tag === 'topLevelExpression') {
+    if (ast.computation) {
+      const d0 = ast.definitions.find(Boolean)
+      const comp = span(ast.computation)
+      return ofRange(d0 ? ofToken(d0.start) : comp, comp)
+    } else if (ast.definitions.length) {
+      const first = ast.definitions[0]
+      const last = ast.definitions[ast.definitions.length - 1]
+      return ofRange(ofToken(first.start), span(last.value))
+    } else {
+      return { from: { offset: 0 }, to: { offset: 0 } }
+    }
+  }
+  if (ast.tag === 'unaryOperator') {
+    return ofRange(ofToken(ast.operatorToken), span(ast.operand))
+  }
+  if (ast.tag === 'unit') {
+    const i0 = ast.imports.find(Boolean)
+    const exp = span(ast.expression)
+    return ofRange(i0 ? ofToken(i0.start) : exp, exp)
+  }
+
+  shouldNeverHappen(ast)
+}

package/src/extract-message.ts

@@ -0,0 +1,5 @@
+export function extractMessage(e: unknown): string | unknown {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+  const typed = e as { message?: string }
+  return typed.message
+}

package/src/fail-me.ts

@@ -0,0 +1,7 @@
+export function failMe<R>(hint?: string): NonNullable<R> {
+  if (!hint) {
+    throw new Error(`This expression must never be evaluated`)
+  }
+
+  throw new Error(`Bad value: ${hint}`)
+}

package/src/find-array-method.ts

@@ -0,0 +1,124 @@
+import { Value } from './value'
+
+export type CallEvaluator = (callable: Value, args: Value[]) => Value
+/**
+ * return an implementation for array methods. The following Array methods were not implemented
+ * as it is hard to find an intuitive immutable API due to their mutable nature:
+ *  - copyWithin
+ *  - fill
+ *  - forEach
+ *  - keys
+ *  - pop
+ *  - push
+ *  - shift
+ *  - unshift
+ */
+export function findArrayMethod(arr: unknown[], index: string, callEvaluator: CallEvaluator) {
+  const adjustedCallback =
+    (callback: Value) =>
+    (...args: unknown[]) =>
+      callEvaluator(
+        callback,
+        args.map(x => Value.from(x)),
+      )
+
+  const adjustedPredicate =
+    (predicate: Value) =>
+    (...args: unknown[]) =>
+      callEvaluator(
+        predicate,
+        args.map(x => Value.from(x)),
+      ).assertBool()
+
+  if (index === 'at') {
+    return Value.foreign(n => arr.at(n.assertNum()))
+  }
+  if (index === 'concat') {
+    return Value.foreign(arg => arr.concat(arg.assertArr()))
+  }
+  if (index === 'entries') {
+    return Value.foreign(() => [...arr.entries()])
+  }
+  if (index === 'every') {
+    return Value.foreign(predicate => arr.every(adjustedPredicate(predicate)))
+  }
+  if (index === 'filter') {
+    return Value.foreign(predicate => arr.filter(adjustedPredicate(predicate)))
+  }
+  if (index === 'find') {
+    return Value.foreign(predicate => arr.find(adjustedPredicate(predicate)))
+  }
+  if (index === 'findIndex') {
+    return Value.foreign(predicate => arr.findIndex(adjustedPredicate(predicate)))
+  }
+  if (index === 'flatMap') {
+    return Value.foreign(callback => flatten(arr.map(adjustedCallback(callback))))
+  }
+  if (index === 'flat') {
+    return Value.foreign(() => flatten(arr))
+  }
+  if (index === 'includes') {
+    return Value.foreign((arg: Value) => arr.some(curr => Value.from(curr).equalsTo(arg).isTrue()))
+  }
+  if (index === 'indexOf') {
+    return Value.foreign(arg => arr.findIndex(curr => Value.from(curr).equalsTo(arg).isTrue()))
+  }
+  if (index === 'join') {
+    return Value.foreign(arg => arr.join(arg.assertStr()))
+  }
+  if (index === 'lastIndexOf') {
+    return Value.foreign(arg => {
+      for (let i = arr.length - 1; i >= 0; --i) {
+        if (Value.from(arr[i]).equalsTo(arg).isTrue()) {
+          return i
+        }
+      }
+      return -1
+    })
+  }
+  if (index === 'length') {
+    return Value.num(arr.length)
+  }
+  if (index === 'map') {
+    return Value.foreign(callback => arr.map(adjustedCallback(callback)))
+  }
+  if (index === 'reverse') {
+    return Value.foreign(() => [...arr].reverse())
+  }
+  if (index === 'reduce') {
+    return Value.foreign((callback, initialValue) => arr.reduce(adjustedCallback(callback), initialValue))
+  }
+  if (index === 'reduceRight') {
+    return Value.foreign((callback, initialValue) => arr.reduceRight(adjustedCallback(callback), initialValue))
+  }
+  if (index === 'slice') {
+    return Value.foreign((start, end) => arr.slice(start?.assertNum(), end?.assertNum()))
+  }
+  if (index === 'some') {
+    return Value.foreign(predicate => arr.some(adjustedPredicate(predicate)))
+  }
+  if (index === 'sort') {
+    return Value.foreign(callback => {
+      if (callback) {
+        return [...arr].sort((a, b) => callEvaluator(callback, [Value.from(a), Value.from(b)]).assertNum())
+      } else {
+        return [...arr].sort()
+      }
+    })
+  }
+  throw new Error(`Unrecognized array method: ${index}`)
+}
+
+function flatten(input: unknown[]) {
+  const ret = []
+  for (const curr of input) {
+    const v = Value.from(curr)
+    const unwrapped = v.unwrap()
+    if (Array.isArray(unwrapped)) {
+      ret.push(...unwrapped)
+    } else {
+      ret.push(v)
+    }
+  }
+  return ret
+}

package/src/find-string-method.ts

@@ -0,0 +1,84 @@
+import { Value } from './value'
+
+export function findStringMethod(s: string, indexValue: string | Value) {
+  const index = Value.toStringOrNumber(indexValue)
+  if (typeof index === 'number') {
+    throw new Error(`Index is of type number - not supported`)
+  }
+  if (index === 'at') {
+    return Value.foreign(n => s.at(n.assertNum()))
+  }
+  if (index === 'charAt') {
+    return Value.foreign(n => s.charAt(n.assertNum()))
+  }
+  if (index === 'concat') {
+    return Value.foreign(arg => s.concat(arg.assertStr()))
+  }
+  if (index === 'endsWith') {
+    return Value.foreign(arg => s.endsWith(arg.assertStr()))
+  }
+  if (index === 'includes') {
+    return Value.foreign(arg => s.includes(arg.assertStr()))
+  }
+  if (index === 'indexOf') {
+    return Value.foreign(searchString => s.indexOf(searchString.assertStr()))
+  }
+  if (index === 'lastIndexOf') {
+    return Value.foreign(searchString => s.lastIndexOf(searchString.assertStr()))
+  }
+  if (index === 'length') {
+    return Value.num(s.length)
+  }
+  if (index === 'match') {
+    return Value.foreign(r => s.match(r.assertStr()))
+  }
+  if (index === 'matchAll') {
+    return Value.foreign(r => [...s.matchAll(new RegExp(r.assertStr(), 'g'))])
+  }
+  if (index === 'padEnd') {
+    return Value.foreign((maxLength, fillString) => s.padEnd(maxLength.assertNum(), fillString?.assertStr()))
+  }
+  if (index === 'padStart') {
+    return Value.foreign((maxLength, fillString) => s.padStart(maxLength.assertNum(), fillString?.assertStr()))
+  }
+  if (index === 'repeat') {
+    return Value.foreign(count => s.repeat(count.assertNum()))
+  }
+  if (index === 'replace') {
+    return Value.foreign((searchValue, replacer) => s.replace(searchValue.assertStr(), replacer.assertStr()))
+  }
+  if (index === 'replaceAll') {
+    return Value.foreign((searchValue, replacer) => s.replaceAll(searchValue.assertStr(), replacer.assertStr()))
+  }
+  if (index === 'search') {
+    return Value.foreign(searcher => s.search(searcher.assertStr()))
+  }
+  if (index === 'slice') {
+    return Value.foreign((start, end) => s.slice(start?.assertNum(), end?.assertNum()))
+  }
+  if (index === 'split') {
+    return Value.foreign(splitter => s.split(splitter.assertStr()))
+  }
+  if (index === 'startsWith') {
+    return Value.foreign(arg => s.startsWith(arg.assertStr()))
+  }
+  if (index === 'substring') {
+    return Value.foreign((start, end) => s.substring(start.assertNum(), end?.assertNum()))
+  }
+  if (index === 'toLowerCase') {
+    return Value.foreign(() => s.toLowerCase())
+  }
+  if (index === 'toUpperCase') {
+    return Value.foreign(() => s.toUpperCase())
+  }
+  if (index === 'trim') {
+    return Value.foreign(() => s.trim())
+  }
+  if (index === 'trimEnd') {
+    return Value.foreign(() => s.trimEnd())
+  }
+  if (index === 'trimStart') {
+    return Value.foreign(() => s.trimStart())
+  }
+  throw new Error(`Unrecognized string method: ${index}`)
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './septima'

package/src/location.ts

@@ -0,0 +1,13 @@
+export interface Location {
+  readonly offset: number
+}
+
+export interface Span {
+  from: Location
+  to: Location
+}
+
+export interface Location2d {
+  line: number
+  col: number
+}