Function includesProxiesOrGetters

lib/internal/repl/completion.js:660–769

* Utility used to determine if an expression includes object getters or proxies. * * Example: given `obj.foo`, the function lets you know if `foo` has a getter function * associated to it, or if `obj` is a proxy * @param {any} expr The expression, in AST format to analyze * @param {string} expr

(expr, exprStr, evalFn, ctx, callback)

 * @returns {void}
 */
function includesProxiesOrGetters(expr, exprStr, evalFn, ctx, callback) {
  if (expr?.type !== 'MemberExpression') {
    // If the expression is not a member one for obvious reasons no getters are involved
    return callback(false);
  }

  if (expr.object.type === 'MemberExpression') {
    // The object itself is a member expression, so we need to recurse (e.g. the expression is `obj.foo.bar`)
    return includesProxiesOrGetters(
      expr.object,
      exprStr.slice(0, expr.object.end),
      evalFn,
      ctx,
      (includes, lastEvaledObj) => {
        if (includes) {
          // If the recurred call found a getter we can also terminate
          return callback(includes);
        }

        if (isProxy(lastEvaledObj)) {
          return callback(true);
        }

        // If a getter/proxy hasn't been found by the recursion call we need to check if maybe a getter/proxy
        // is present here (e.g. in `obj.foo.bar` we found that `obj.foo` doesn't involve any getters so we now
        // need to check if `bar` on `obj.foo` (i.e. `lastEvaledObj`) has a getter or if `obj.foo.bar` is a proxy)
        return hasGetterOrIsProxy(lastEvaledObj, expr.property, (doesHaveGetterOrIsProxy) => {
          return callback(doesHaveGetterOrIsProxy);
        });
      },
    );
  }

  // This is the base of the recursion we have an identifier for the object and an identifier or literal
  // for the property (e.g. we have `obj.foo` or `obj['foo']`, `obj` is the object identifier and `foo`
  // is the property identifier/literal)
  if (expr.object.type === 'Identifier') {
    return evalFn(`try { ${expr.object.name} } catch {}`, ctx, getREPLResourceName(), (err, obj) => {
      if (err) {
        return callback(false);
      }

      if (isProxy(obj)) {
        return callback(true);
      }

      return hasGetterOrIsProxy(obj, expr.property, (doesHaveGetterOrIsProxy) => {
        if (doesHaveGetterOrIsProxy) {
          return callback(true);
        }

        return evalFn(
          `try { ${exprStr} } catch {} `, ctx, getREPLResourceName(), (err, obj) => {
            if (err) {
              return callback(false);
            }
            return callback(false, obj);
          });