Moved `isValidLexicalScopeNode` method to the NodeGuards as `isNodeWithLexicalScopeAndStatements`

src/node-transformers/string-array-transformers/StringArrayTransformer.ts

@@ -123,31 +123,6 @@ export class StringArrayTransformer extends AbstractNodeTransformer {
         this.stringArrayTransformerCustomNodeFactory = stringArrayTransformerCustomNodeFactory;
     }
 
-    /**
-     * @param {Node} node
-     * @returns {boolean}
-     */
-    private static isValidLexicalScopeNode (node: ESTree.Node): node is TNodeWithLexicalScopeAndStatements {
-        if (!NodeGuards.isNodeWithLexicalScope(node)) {
-            return false;
-        }
-
-        const lexicalScopeBodyNode: ESTree.Program | ESTree.BlockStatement | ESTree.Expression =
-            NodeGuards.isProgramNode(node)
-                ? node
-                : node.body;
-
-        // invalid lexical scope node
-        if (
-            !lexicalScopeBodyNode.parentNode
-            || !NodeGuards.isNodeWithLexicalScopeStatements(lexicalScopeBodyNode, lexicalScopeBodyNode.parentNode)
-        ) {
-            return false;
-        }
-
-        return true;
-    }
-
     /**
      * @param {NodeTransformationStage} nodeTransformationStage
      * @returns {IVisitor | null}
@@ -161,7 +136,7 @@ export class StringArrayTransformer extends AbstractNodeTransformer {
                             this.prepareNode(node);
                         }
 
-                        if (StringArrayTransformer.isValidLexicalScopeNode(node)) {
+                        if (NodeGuards.isNodeWithLexicalScopeAndStatements(node)) {
                             this.onLexicalScopeNodeEnter(node);
                         }
 
@@ -170,7 +145,7 @@ export class StringArrayTransformer extends AbstractNodeTransformer {
                         }
                     },
                     leave: (node: ESTree.Node): ESTree.Node | undefined => {
-                        if (StringArrayTransformer.isValidLexicalScopeNode(node)) {
+                        if (NodeGuards.isNodeWithLexicalScopeAndStatements(node)) {
                             this.onLexicalScopeNodeLeave();
 
                             return this.transformLexicalScopeNode(node);

src/node/NodeFactory.ts

@@ -34,6 +34,25 @@ export class NodeFactory {
         };
     }
 
+    /**
+     * @param {Pattern[]} params
+     * @param {boolean} expression
+     * @param {BlockStatement | Expression} body
+     * @returns {ArrowFunctionExpression}
+     */
+    public static arrowFunctionExpressionNode (
+        params: ESTree.Pattern[],
+        expression: boolean,
+        body: ESTree.BlockStatement | ESTree.Expression
+    ): ESTree.ArrowFunctionExpression {
+        return {
+            type: NodeType.ArrowFunctionExpression,
+            params,
+            expression,
+            body
+        };
+    }
+
     /**
      * @param {AssignmentOperator} operator
      * @param {Pattern | MemberExpression} left

src/node/NodeGuards.ts

@@ -1,6 +1,7 @@
 import * as ESTree from 'estree';
 
 import { TNodeWithLexicalScope } from '../types/node/TNodeWithLexicalScope';
+import { TNodeWithLexicalScopeAndStatements } from '../types/node/TNodeWithLexicalScopeAndStatements';
 import { TNodeWithStatements } from '../types/node/TNodeWithStatements';
 
 import { NodeType } from '../enums/node/NodeType';
@@ -270,6 +271,31 @@ export class NodeGuards {
         return NodeGuards.isNodeWithLexicalScope(node) || NodeGuards.isBlockStatementNode(node);
     }
 
+    /**
+     * @param {Node} node
+     * @returns {node is TNodeWithLexicalScopeAndStatements}
+     */
+    public static isNodeWithLexicalScopeAndStatements (node: ESTree.Node): node is TNodeWithLexicalScopeAndStatements {
+        if (!NodeGuards.isNodeWithLexicalScope(node)) {
+            return false;
+        }
+
+        const lexicalScopeBodyNode: ESTree.Program | ESTree.BlockStatement | ESTree.Expression =
+            NodeGuards.isProgramNode(node)
+                ? node
+                : node.body;
+
+        // invalid lexical scope node
+        if (
+            !lexicalScopeBodyNode.parentNode
+            || !NodeGuards.isNodeWithLexicalScopeStatements(lexicalScopeBodyNode, lexicalScopeBodyNode.parentNode)
+        ) {
+            return false;
+        }
+
+        return true;
+    }
+
     /**
      * @param {Node} node
      * @param {Node} parentNode

test/unit-tests/node/node-guards/NodeGuards.spec.ts

@@ -257,4 +257,99 @@ describe('NodeGuards', () => {
             });
         });
     });
+
+    describe('isNodeWithLexicalScopeAndStatements', () => {
+        describe('truthful checks', () => {
+            const expectedResult: boolean = true;
+
+            describe('Variant #1: program node', () => {
+                const node: ESTree.Program = NodeFactory.programNode();
+
+                let result: boolean;
+
+                before(() => {
+                    NodeUtils.parentizeAst(node);
+                    result = NodeGuards.isNodeWithLexicalScopeAndStatements(node);
+                });
+
+                it('should check if node with a lexical scope and statements', () => {
+                    assert.equal(result, expectedResult);
+                });
+            });
+
+            describe('Variant #2: function declaration node', () => {
+                const functionDeclarationNode: ESTree.FunctionDeclaration = NodeFactory.functionDeclarationNode(
+                    'foo',
+                    [],
+                    NodeFactory.blockStatementNode([])
+                );
+                const programNode: ESTree.Program = NodeFactory.programNode([
+                    functionDeclarationNode
+                ]);
+
+                let result: boolean;
+
+                before(() => {
+                    NodeUtils.parentizeAst(programNode);
+                    result = NodeGuards.isNodeWithLexicalScopeAndStatements(functionDeclarationNode);
+                });
+
+                it('should check if node with a lexical scope and statements', () => {
+                    assert.equal(result, expectedResult);
+                });
+            });
+
+            describe('Variant #3: arrow function expression node', () => {
+                const arrowFunctionExpressionNode: ESTree.ArrowFunctionExpression = NodeFactory.arrowFunctionExpressionNode(
+                    [],
+                    false,
+                    NodeFactory.blockStatementNode([])
+                );
+                const programNode: ESTree.Program = NodeFactory.programNode([
+                    NodeFactory.expressionStatementNode(
+                        arrowFunctionExpressionNode
+                    )
+                ]);
+
+                let result: boolean;
+
+                before(() => {
+                    NodeUtils.parentizeAst(programNode);
+                    result = NodeGuards.isNodeWithLexicalScopeAndStatements(arrowFunctionExpressionNode);
+                });
+
+                it('should check if node with a lexical scope and statements', () => {
+                    assert.equal(result, expectedResult);
+                });
+            });
+        });
+
+        describe('false checks', () => {
+            const expectedResult: boolean = false;
+
+            describe('Variant #1: arrow function expression node without statements', () => {
+                const arrowFunctionExpressionNode: ESTree.ArrowFunctionExpression = NodeFactory.arrowFunctionExpressionNode(
+                    [],
+                    true,
+                    NodeFactory.literalNode('foo')
+                );
+                const programNode: ESTree.Program = NodeFactory.programNode([
+                    NodeFactory.expressionStatementNode(
+                        arrowFunctionExpressionNode
+                    )
+                ]);
+
+                let result: boolean;
+
+                before(() => {
+                    NodeUtils.parentizeAst(programNode);
+                    result = NodeGuards.isNodeWithLexicalScopeAndStatements(arrowFunctionExpressionNode);
+                });
+
+                it('should check if node with a lexical scope and statements', () => {
+                    assert.equal(result, expectedResult);
+                });
+            });
+        });
+    });
 });