Stage 1 Draft / February 29, 2024

Dynamic Code Brand Checks

1 Runtime Semantics: IsCodeLike ( x )

The abstract operation IsCodeLike takes argument x (an Object) and returns a Boolean. It checks if x contains the host-defined [[HostDefinedIsCodeLike]] internal slot. It performs the following steps:

  1. If x does not have a [[HostDefinedIsCodeLike]] internal slot, return false.
  2. Assert x.[[HostDefinedIsCodeLike]] is a Boolean.
  3. Return x.[[HostDefinedIsCodeLike]].
 Note
Hosts should ensure that [[HostDefinedIsCodeLike]] internal slot value for objects doesn't change. This is to allow for passing code-like objects without handing out capabilities to change the code that they wrap.

2 HostEnsureCanCompileStrings ( calleeRealm, parameterStrings, bodyString, direct, codeString, compilationType, parameterArgs, bodyArg )

The host-defined abstract operation HostEnsureCanCompileStrings takes arguments calleeRealm (a Realm Record), parameterStrings (a List of Strings), bodyString (a String), direct (a Boolean), codeString (a String), compilationType (DIRECT-EVAL, INDIRECT-EVAL, or FUNCTION), parameterArgs (a List of ECMAScript language values), and bodyArg (an ECMAScript language value) and returns either a normal completion containing UNUSED or a throw completion. It allows host environments to block certain ECMAScript functions which allow developers to interpret and evaluate strings as ECMAScript code.

parameterStrings represents the strings that, when using one of the function constructors, will be concatenated together to build the parameters list. bodyString represents the function body or the string passed to an eval call. direct signifies whether the evaluation is a direct eval. codeString represents the full code string, compilationType is an enum that indicates what type of compilation this is, parameterArgs represents the list of values passed when using one of the function constructors, bodyArg represents the function body or the value passed to an eval call.

The default implementation of HostEnsureCanCompileStrings is to return NormalCompletion(UNUSED).

3 PerformEval ( x, strictCaller, direct )

The abstract operation PerformEval takes arguments x (an ECMAScript language value), strictCaller (a Boolean), and direct (a Boolean) and returns either a normal completion containing an ECMAScript language value or a throw completion. It performs the following steps when called:

  1. Assert: If direct is false, then strictCaller is also false.
  2. If x is an Object, set isCodeLike to ! IsCodeLike(x).
  3. Else, set isCodeLike to false.
  4. If x is not a String, and isCodeLike is false, return x.
  5. If x is a String, set xStr to x.
  6. Else, set xStr to ? ToString(x).
  7. If x is not a String, return x.
  8. Let evalRealm be the current Realm Record.
  9. NOTE: In the case of a direct eval, evalRealm is the realm of both the caller of eval and of the eval function itself.
  10. Set type to DIRECT-EVAL if direct is true, or INDIRECT-EVAL if direct is false.
  11. Perform ? HostEnsureCanCompileStrings(evalRealm, « », x, directxStr, xStr, type, « », x).
  12. ...

4 CreateDynamicFunction ( constructor, newTarget, kind, parameterArgs, bodyArg )

The abstract operation CreateDynamicFunction takes arguments constructor (a constructor), newTarget (a constructor), kind (normal, generator, async, or async-generator), parameterArgs (a List of ECMAScript language values), and bodyArg (an ECMAScript language value) and returns either a normal completion containing an ECMAScript function object or a throw completion. constructor is the constructor function that is performing this action. newTarget is the constructor that new was initially applied to. parameterArgs and bodyArg reflect the argument values that were passed to constructor. It performs the following steps when called:

  1. If newTarget is undefined, set newTarget to constructor.
  2. If kind is normal, then
    1. Let prefix be "function".
    2. Let exprSym be the grammar symbol FunctionExpression.
    3. Let bodySym be the grammar symbol FunctionBody[~Yield, ~Await].
    4. Let parameterSym be the grammar symbol FormalParameters[~Yield, ~Await].
    5. Let fallbackProto be "%Function.prototype%".
  3. Else if kind is generator, then
    1. Let prefix be "function*".
    2. Let exprSym be the grammar symbol GeneratorExpression.
    3. Let bodySym be the grammar symbol GeneratorBody.
    4. Let parameterSym be the grammar symbol FormalParameters[+Yield, ~Await].
    5. Let fallbackProto be "%GeneratorFunction.prototype%".
  4. Else if kind is async, then
    1. Let prefix be "async function".
    2. Let exprSym be the grammar symbol AsyncFunctionExpression.
    3. Let bodySym be the grammar symbol AsyncFunctionBody.
    4. Let parameterSym be the grammar symbol FormalParameters[~Yield, +Await].
    5. Let fallbackProto be "%AsyncFunction.prototype%".
  5. Else,
    1. Assert: kind is async-generator.
    2. Let prefix be "async function*".
    3. Let exprSym be the grammar symbol AsyncGeneratorExpression.
    4. Let bodySym be the grammar symbol AsyncGeneratorBody.
    5. Let parameterSym be the grammar symbol FormalParameters[+Yield, +Await].
    6. Let fallbackProto be "%AsyncGeneratorFunction.prototype%".
  6. Let argCount be the number of elements in parameterArgs.
  7. Let parameterStrings be a new empty List.
  8. For each element arg of parameterArgs, do
    1. Append ? ToString(arg) to parameterStrings.
  9. Let bodyString be ? ToString(bodyArg).
  10. Let currentRealm be the current Realm Record.
  11. Perform ? HostEnsureCanCompileStrings(currentRealm, parameterStrings, bodyString, false).
  12. Let P be the empty String.
  13. If argCount > 0, then
    1. Set P to parameterStrings[0].
    2. Let k be 1.
    3. Repeat, while k < argCount,
      1. Let nextArgString be parameterStrings[k].
      2. Set P to the string-concatenation of P, "," (a comma), and nextArgString.
      3. Set k to k + 1.
  14. Let bodyParseString be the string-concatenation of 0x000A (LINE FEED), bodyString, and 0x000A (LINE FEED).
  15. Let sourceString be the string-concatenation of prefix, " anonymous(", P, 0x000A (LINE FEED), ") {", bodyParseString, and "}".
  16. Perform ? HostEnsureCanCompileStrings(currentRealm, parameterStrings, bodyString, sourceString, FUNCTION, parameterArgs, bodyArg).
  17. ...
 Note

CreateDynamicFunction defines a "prototype" property on any function it creates whose kind is not async to provide for the possibility that the function will be used as a constructor.

A Host Layering Points

A.1 Host-defined Fields

[[HostDefinedIsCodeLike]]: A Boolean. See IsCodeLike.