Check out cool esmeta project

[safinaskar]

https://github.com/es-meta/esmeta . This is Scala program, which parses ecmascript spec and... converts it into actual interpreter!

[overlookmotel]

This does look cool. But can you summarize how you think it might be applied/useful to Oxc? I don't have a formal computer science background, so some of the jargon is unfamiliar to me ("mechanized specification"?).

If you have time, and you do understand it, would you be able to explain at a bit of a more "tell it to me like I'm 5" level what its purpose is?

[safinaskar]

@overlookmotel . No formal computer science background is needed. You just need to understand interpreters. esmeta simply reads ECMAScript spec and translates it to so-called Intermediate Representations for ECMAScript Specification (IRES). For example, this is fragment of ECMAScript spec:

10.1.2.1 OrdinarySetPrototypeOf ( O, V )

The abstract operation OrdinarySetPrototypeOf takes arguments O (an Object) and V (an Object or null) and returns a Boolean. It performs the following steps when called:

1. Let current be O.[[Prototype]].
2. If SameValue(V, current) is true, return true.
3. Let extensible be O.[[Extensible]].
4. If extensible is false, return false.
5. Let p be V.
6. Let done be false.
7. Repeat, while done is false,
  a. If p is null, then
    i. Set done to true.
  b. Else if SameValue(p, O) is true, then
    i. Return false.
  c. Else,
    i. If p.[[GetPrototypeOf]] is not the ordinary object internal method defined in 10.1.1, set done to true.
    ii. Else, set p to p.[[Prototype]].
8. Set O.[[Prototype]] to V.
9. Return true.

Esmeta converts this text to the following IRES:

def OrdinarySetPrototypeOf(
  O: Object,
  V: Object | Null,
): Boolean {
  let current = O.Prototype
  call %0 = clo<SameValue>(V, current)
  if (= %0 true) {
    return true
  } else {}
  let extensible = O.Extensible
  if (= extensible false) {
    return false
  } else {}
  let p = V
  let done = false
  loop[repeat] (= done false) {
    if (= p null) {
      done = true
    } else {
      call %1 = clo<SameValue>(p, O)
      if (= %1 true) {
        return false
      } else {
        if (! (= p.GetPrototypeOf clo<OrdinaryObject.GetPrototypeOf>)) {
          done = true
        } else {
          p = p.Prototype
        }
      }
    }
  }
  O.Prototype = V
  return true
}

As well as I understand, this conversion is performed using some generic algorithm. Unfortunately, the generic algorithm sometimes doesn't work, so esmeta resorts to hardcoded ad hoc list of English phrases: https://github.com/es-meta/esmeta/blob/main/src/main/resources/manuals/rule.json .

Also, ECMAScript spec contains js grammar. Esmeta reads this grammar and builds parser out of it.

Also, esmeta is unfinished. Not all algorithms can be converted right now. Here is current statistics: https://github.com/es-meta/esmeta/blob/main/src/main/resources/result/spec-summary .

ECMAScript consists of algorithms like above. It is essentially ready-to-use interpreter. So, after conversion to IRES we essentially get interpreter. (But some parts are still needed to be written manually, for example, obscure parts of parser.)

Okay, so we got interpreter. Then we can run it on test262 tests.

Also, esmeta has debugger, which can debug ECMAScript spec, i. e. you can actually step-by-step debug algorithms with steps like If SameValue(V, current) is true, return true. See https://www.youtube.com/watch?v=syfZ3v6JNg8 at 2:16 - 3:00.

Esmeta helped to fix many bugs in ECMAScript spec. Now esmeta is part of CI at https://github.com/tc39/ecma262 , so every PR is checked using esmeta.

would you be able to explain at a bit of a more "tell it to me like I'm 5" level what its purpose is?

To generate js interpreter directly from ECMAScript spec. This enables us to check resulting interpreter against test262 and against other js implementations. Also, in process of converting esmeta performs some consistency checks of the specification.

how you think it might be applied/useful to Oxc?

As well as I understand, Nova is based on Oxc. This post ( https://trynova.dev/blog/why-build-a-js-engine ) about Nova contains this phrase:

We could go and try to refactor Object inheritance in eg. V8, or Kiesel, or LibJS. But it's most likely that this would never be accepted

Esmeta solves exactly this problem! With esmeta you can just edit specification itself and get interpreter for modified version!