private scanSourceFile()

in src/shared/typescriptLambdaHandlerSearch.ts [78:128]
38 lines of code
13 McCabe index (conditional complexity)

    private scanSourceFile(sourceFile: ts.SourceFile): void {
        sourceFile.forEachChild((node: ts.Node) => {
            // Function declarations
            if (ts.isFunctionLike(node)) {
                if (TypescriptLambdaHandlerSearch.isFunctionLambdaHandlerCandidate(node)) {
                    this._candidateDeclaredFunctionNames.add(node.name!.getText())
                }
            }

            // Arrow Function declarations "const foo = (arg) => { }"
            if (ts.isVariableStatement(node)) {
                node.declarationList.forEachChild(declaration => {
                    if (ts.isVariableDeclaration(declaration)) {
                        const declarationName: string = declaration.name.getText()

                        if (
                            declarationName.length > 0 &&
                            declaration.initializer &&
                            ts.isFunctionLike(declaration.initializer) &&
                            TypescriptLambdaHandlerSearch.isFunctionLambdaHandlerCandidate(
                                declaration.initializer,
                                false // initializers do not have a name value, it is up in declaration.name
                            )
                        ) {
                            this._candidateDeclaredFunctionNames.add(declarationName)
                        }
                    }
                })
            }

            // export function xxx / "export const xxx = () => {}"
            // We grab all of these and filter them later on in order to better deal with the VariableStatement entries
            if (TypescriptLambdaHandlerSearch.isNodeExported(node)) {
                this._candidateExportNodes.push(node)
            }

            // Things like "exports.handler = ..."
            // Grab all, cull after we've found all valid functions that can be referenced on rhs
            if (ts.isExpressionStatement(node)) {
                if (TypescriptLambdaHandlerSearch.isModuleExportsAssignment(node)) {
                    this._candidateModuleExportsExpressions.push(node)
                }
            }

            // Things like "export { xxx }"
            // Grab all, cull after we've found all valid functions that can be referenced in brackets
            if (ts.isExportDeclaration(node)) {
                this._candidateExportDeclarations.push(node)
            }
        })
    }