DanielXMoore / Civet / 8868035915

"civet coffeePrototype"

import type {

  ComptimeExpression

  ComptimeStatement

  StatementTuple

} from ./types.civet

import {

  gatherRecursive

} from "./traversal.civet"

{ getInitialConfig } from "../parser.hera"

generate, { prune, type Options } from "../generate.civet"

function processComptime(statements: StatementTuple[]): void

  // Prevent comptime setting from being overridden by directives

  // by looking at initialConfig instead of config

  return unless getInitialConfig()?.comptime

  gatherRecursive statements,

    (node): node is (ComptimeStatement | ComptimeExpression) =>

      node.type is "ComptimeStatement" or node.type is "ComptimeExpression"

  .forEach (exp) =>

    content := exp.type is "ComptimeStatement" ? exp.block : exp.expression

    // Convert the comptime block into JS code

    options: Options := js: true

    js := generate prune(content), options

    // If there are any errors, leave the comptime subtree alone

    // (so there's still an error).

    output := eval?.(`"use strict";${js}`)

    if exp.type is "ComptimeExpression"

      let string

      try

        string = serialize output

      exp.children = [string]

    else

      exp.children = []

function serialize(value: ???): string

  stack := new Set<object>

  function recurse(val: ???): string

    switch val

      <? "string"

        // Using JSON.stringify to handle escape sequences

        JSON.stringify val

      <? "number"

        if Object.is -0, val then '-0' else val.toString()

      <? "boolean", == null

        String val // not toString to accomodate null/undefined

      <? "bigint"

        `${val}n`

      <? "function"

        // Some functions can actually be serialized

        string .= Function::toString.call val

        if /\{\s+\[native code]\s+\}$/.test string

          // builtin, or returned from Function::bind

          throw new TypeError "cannot serialize native function"

        if /^class[\s{]/u.test string

          // Skip other checks; properties on the function are `static` things in the class

          return string

        if stack.has val

          throw new Error "circular reference detected"

        stack.add val

        // Check for ES6 methods that have been removed from the object, and add "function" if possible

        if /^(?:async\s*)?(?:\*\s*|[gs]et\s+)?\[/.test string

          // In general, the method name could be an arbitrary JS expression. This is not currently handled.

          throw new Error "cannot serialize method with computed name"

        // Test for old-style classes done by creating a regular function and assigning to its prototype

        protoHasProps := not (or)

          val:: is undefined

          (and)

            Object:: is Object.getPrototypeOf val::

            Object.getOwnPropertyNames(val::)# <= 1 // constructor

            Object.getOwnPropertySymbols(val::)# is 0

            val::constructor is in [val, undefined]

        isGenerator := /^(?:async\s*)?(?:function\s*)?\*/u.test string

        if protoHasProps and not isGenerator

          throw new TypeError "cannot serialize function with modified prototype"

        unless /^(?:async\s+)?(?:(function|class)(?!\p{ID_Continue})|\(|(?:\p{ID_Start}|[_$])(?:\p{ID_Continue}|[\u200C\u200D$])*\s*=>)/u.test string

          // Slightly more annoying than just `'function ' + string`: need to insert it before `async`, and remove `get` or `set` if applicable

          string |>= .replace /^(async\s+)?(?:[gs]et\s+(?=\p{ID_Start}))?/u, (_, maybeAsync = '') => maybeAsync + 'function '

        // Properties that a function may have inherently even if they aren't explicitly assigned

        defaultProps := ["length", "name", "arguments", "caller", "prototype"]

        hasProps := not (and)

          Object.getOwnPropertyNames(val).every & is in defaultProps

          Object.getOwnPropertySymbols(val)# is 0

        if hasProps

          props := Object.getOwnPropertyDescriptors val

          for prop of defaultProps

            delete props[prop]

          string = `Object.defineProperties(${string},${recurse props})`

        stack.delete val

        string

      <? "symbol"

        if key? := Symbol.keyFor val

          return `Symbol.for(${JSON.stringify key})`

        // Handle well-known symbols

        // for-in doesn't find them, but getOwnPropertyNames does

        for name of Object.getOwnPropertyNames Symbol

          sym := (Symbol as! Record<string, symbol>)[name]

          if val is sym

            return `Symbol.${name}`

        throw new TypeError "cannot serialize unique symbol"

      <? "object"

        if stack.has val

          throw new Error "circular reference detected"

        stack.add val

        str :=

          switch Object.getPrototypeOf val

            when RegExp::

              re := val as RegExp

              `/${re.source}/${re.flags}`

            when Date::

              `new Date(${(val as Date).getTime()})`

            when Set::

              "new Set([" + (

                for item of val as Set<???>

                  recurse item

              ).join(",") + "])"

            when Map::

              "new Map([" + (

                for [key, value] of val as Map<???, ???>

                  `[${recurse key},${recurse value}]`

              ).join(",") + "])"

            when Array::

              `[${(val as ???[]).map(recurse).join ","}]`

            when Object::

              // The string representing the object's own enumerable, writable properties

              objStr .= '{'

              // The string representing other property descriptors, if applicable, not including the outermost braces

              descStr .= ''

              descriptors := Object.getOwnPropertyDescriptors(val) as Record<string | symbol, PropertyDescriptor>

              for prop of (Object.getOwnPropertyNames(val) as (string|symbol)[]) ++ Object.getOwnPropertySymbols(val)

                desc := descriptors[prop]

                if desc.enumerable and desc.configurable and desc.writable

                  if prop <? 'symbol'

                    objStr += `[${recurse prop}]`

                  else

                    objStr += JSON.stringify prop

                  objStr += `:${recurse desc.value},`

                else

                  if prop <? 'symbol'

                    descStr += `[${recurse prop}]`

                  else

                    descStr += JSON.stringify prop

                  descStr += `:${recurse desc},`

              objStr += '}'

              if descStr !== ''

                objStr = `Object.defineProperties(${objStr},\{${descStr}\})`

              if not Object.isExtensible val

                objStr = `Object.preventExtensions(${objStr})`

              objStr

            when URL::

              `new URL(${JSON.stringify (val as URL).href})`

            when null

              `Object.create(null,${recurse Object.getOwnPropertyDescriptors val})`

              // There's no "TypedArray" interface in TS

              `new ${val.constructor.name}([${(val as any).join ','}])`

            when BigInt64Array::, BigUint64Array::

              `new ${val.constructor.name}([${Array.from(val as ArrayLike<bigint>, `${&}n`).join ','}])`

            // Spelled differently for browsers, where `Buffer` doesn't exist

            when globalThis.Buffer?.prototype

              `Buffer.from([${(val as Buffer).join ','}])`

            else

              // One day we may handle other classes like so:

              // str += `__proto__:${val.constructor.name}`

              throw new TypeError `cannot serialize object with prototype ${Object.getPrototypeOf val}`

        stack.delete val

  recurse value

export {

  processComptime

  serialize

}