Rule proposal: Ensure yield on call to generator function

[Bartel-C8]

As proposed, but rejected due that Generator functions deemed a niche use-case: typescript-eslint/typescript-eslint#7749
And apparently proposed before: typescript-eslint/typescript-eslint#1068

Description

My suggested rule would check that every call to a generator, inside another generator is called with yield

Fail Cases

function* parentGenerator(){
  console.log("parentGenerator:: start");
  childGeneratorOne();
  yield* childGeneratorTwo();
  console.log("parentGenerator:: end");
}

function* childGeneratorOne(){
  console.log("childGeneratorOne:: start");
}

function* childGeneratorTwo(){
  console.log("childGeneratorTwo:: start");
}

const itr = parentGenerator();
console.log(itr.next());

Pass Cases

function* parentGenerator(){
  console.log("parentGenerator:: start");
  yield* childGeneratorOne();
  yield* childGeneratorTwo();
  console.log("parentGenerator:: end");
}

function* childGeneratorOne(){
  console.log("childGeneratorOne:: start");
}

function* childGeneratorTwo(){
  console.log("childGeneratorTwo:: start");
}

const itr = parentGenerator();
console.log(itr.next());

Additional Info

In the failing case, the childGeneratorOne is never called, which you won't expect if you miss that yield is lacking...

Was suggested before eslint/eslint#5193 but, as described in the issue, type info is needed to make this work.

[Bartel-C8]

Own (working for my code-base) attempt of creating this rule.
But this is my first eslint rule ever, so don't know about the quality of it...

Inspired by:

https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/eslint-plugin/src/rules/require-await.ts
and
https://github.com/pke/eslint-plugin-redux-saga/blob/master/lib/rules/no-yield-in-race.js

If it seems okay and you're open for a PR, I am happy to polish it and provide test cases.

const { AST_NODE_TYPES, TSESLint, TSESTree } = require("@typescript-eslint/experimental-utils");
const tsutils = require("tsutils");
const util = require("@typescript-eslint/eslint-plugin/dist/util");

module.exports = {
  meta: {
    type: "suggestion",
    docs: {
      description: "Disallow calling generator functions without `yield` expression",
      recommended: "error",
      requiresTypeChecking: true,
      extendsBaseRule: true,
    },
    hasSuggestions: true,
    schema: [],
    messages: {
      missingYield: "{{name}} has no 'yield' expression.",
    },
  },
  defaultOptions: [],
  create(context) {
    const parserServices = util.getParserServices(context);
    const checker = parserServices.program.getTypeChecker();

    const sourceCode = context.getSourceCode();
    let scopeInfo = null;

    function isGenerator(node) {
      const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
      const type = checker.getTypeAtLocation(tsNode);
      const symbol = type.getSymbol();
      let gen = false;
      if (symbol?.getName() === "Generator") {
        gen = true;
      }
      return gen;
    }

    function checkExpression(node) {
      const expression = node.expression;
      if (!scopeInfo) return;

      if (scopeInfo.isGen) {
        const type = expression.type;
        if (type === "CallExpression") {
          const isGenExp = isGenerator(expression);

          if (!isEmptyFunction(expression) && isGenExp)
            context.report({
              node,
              loc: getFunctionHeadLoc(node, sourceCode),
              messageId: "missingYield",
              data: {
                name: "Generator function " + expression.callee.name,
              },
              suggest: [
                {
                  desc: "Add yield*",
                  fix: function (fixer) {
                    return fixer.insertTextBefore(expression, "yield* ");
                  },
                },
                {
                  desc: "Add yield",
                  fix: function (fixer) {
                    return fixer.insertTextBefore(expression, "yield ");
                  },
                },
              ],
            });
        }
      }
    }

    /**
     * Push the scope info object to the stack.
     */
    function enterFunction(node) {
      if (scopeInfo) scopeInfo.hasYield = false;
      scopeInfo = {
        upper: scopeInfo,
        hasYield: false,
        name: node.id?.name ?? node?.argument?.callee?.name ?? node.callee?.name,
        // hasAsync: node.async,
        isGen: node.generator || false,
        // isAsyncYield: false,
      };
    }

    /**
     * Pop the top scope info object from the stack.
     * Also, it reports the function if needed.
     */
    function exitFunction() {
      /* istanbul ignore if */ if (!scopeInfo) {
        // this shouldn't ever happen, as we have to exit a function after we enter it
        return;
      }
      scopeInfo = scopeInfo.upper;
    }

    return {
      FunctionDeclaration: enterFunction,
      FunctionExpression: enterFunction,

      ExpressionStatement: checkExpression,

      "FunctionDeclaration:exit": exitFunction,
      "FunctionExpression:exit": exitFunction,

      ReturnStatement() {
        // short circuit early to avoid unnecessary type checks
        if (!scopeInfo || !scopeInfo.isGen) {
          return;
        }
      },
    };
  },
};

function isEmptyFunction(node) {
  return node.body?.type === AST_NODE_TYPES.BlockStatement && node.body.body.length === 0;
}

// https://github.com/eslint/eslint/blob/03a69dbe86d5b5768a310105416ae726822e3c1c/lib/rules/utils/ast-utils.js#L382-L392
/**
 * Gets the `(` token of the given function node.
 */
function getOpeningParenOfParams(node, sourceCode) {
  return util.nullThrows(
    node.id
      ? sourceCode.getTokenAfter(node.id, util.isOpeningParenToken)
      : sourceCode.getFirstToken(node, util.isOpeningParenToken),
    util.NullThrowsReasons.MissingToken("(", node.type)
  );
}

// https://github.com/eslint/eslint/blob/03a69dbe86d5b5768a310105416ae726822e3c1c/lib/rules/utils/ast-utils.js#L1220-L1242
/**
 * Gets the location of the given function node for reporting.
 */
function getFunctionHeadLoc(node, sourceCode) {
  const parent = util.nullThrows(node.parent, util.NullThrowsReasons.MissingParent);
  let start = null;
  let end = null;

  if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) {
    const arrowToken = util.nullThrows(
      sourceCode.getTokenBefore(node.body, util.isArrowToken),
      util.NullThrowsReasons.MissingToken("=>", node.type)
    );

    start = arrowToken.loc.start;
    end = arrowToken.loc.end;
  } else if (parent.type === AST_NODE_TYPES.Property || parent.type === AST_NODE_TYPES.MethodDefinition) {
    start = parent.loc.start;
    end = getOpeningParenOfParams(node, sourceCode).loc.start;
  } else {
    start = node.loc.start;
    end = getOpeningParenOfParams(node, sourceCode).loc.start;
  }

  return {
    start,
    end,
  };
}

[pke]

Thanks for bringing this up @Bartel-C8
I am just not sure if that should be part of the redux-saga eslint rule-set. This looks to me more like a general generator function call lint rule, which may be covered in other eslint rules already?

Maybe the default eslint require-yield rule would do what you want?

[Bartel-C8]

Thought so too, but couldn't find any existing rule...

The default eslint require-yield only checks that at least one yield is existing inside the body of the generator function. But not that the generator function is yielded itself...

It was proposed also long time ago to eslint itself, but deemed not possible due to the lack of typing: eslint/eslint#5193

So, bottom line: not possible in eslint, too niche for typescript-eslint. So this repo is a great fit, and the last resort. Or a new separate repo, but it's very relevant for redux-saga users...

[pke]

Cool then. Just wanted so save you some work ;) Go on then an create a PR and we will make it happen!