Symbolic links are ignored #13551

{
    "env": {
        "browser": true
    },
    "extends": [
        "eslint:recommended",
        "plugin:@typescript-eslint/recommended",
        "plugin:@typescript-eslint/recommended-requiring-type-checking"
    ],
    "parser": "@typescript-eslint/parser",
    "parserOptions": {
        "ecmaVersion": 6,
        "sourceType": "module",
        "project": ["./tsconfig.json"]
    },
    "plugins": [ "@typescript-eslint" ],
    "rules": {
        "brace-style": ["error", "allman", { "allowSingleLine": true }],
        "eol-last": ["error", "always"],
        "eqeqeq": ["error", "always"],
        "indent": ["error", 4, { "SwitchCase": 1 }],
        "linebreak-style": ["error", "unix"],
        "lines-between-class-members": ["error", "always"],
        "max-len": ["error", { "code": 120 }],
        "new-cap": "error",
        "no-irregular-whitespace": ["off"],
        "no-multiple-empty-lines": "error",
        "no-nested-ternary": "error",
        "no-trailing-spaces": "error",
        "no-unexpected-multiline": ["off"],
        "object-curly-spacing": ["error", "always"],
        "object-property-newline": "error",
        "one-var": ["error", "never"],
        "quotes": ["error", "double"],
        "semi": ["error", "always"],
        "space-before-blocks": ["error", "always"],
        "space-in-parens": ["error", "always"],
        "spaced-comment": ["error", "always", {
            "block": { "balanced": true },
            "exceptions": []
        }],
        "@typescript-eslint/no-empty-interface": ["error", { "allowSingleExtends": true }],
        "@typescript-eslint/no-explicit-any": ["error"],
        "@typescript-eslint/no-floating-promises": ["error"],
        "@typescript-eslint/no-non-null-assertion": ["error"],
        "@typescript-eslint/no-unsafe-assignment": ["error"],
        "@typescript-eslint/no-unsafe-call": ["error"],
        "@typescript-eslint/no-unsafe-member-access": ["error"],
        "@typescript-eslint/no-unsafe-return": ["error"],
        "@typescript-eslint/no-unused-vars": ["error"],
        "@typescript-eslint/restrict-template-expressions": ["error"]
    }
}

    *_iterateFilesRecursive(directoryPath, options) {
        debug(`Enter the directory: ${directoryPath}`);
        const { configArrayFactory } = internalSlotsMap.get(this);

        /** @type {ConfigArray|null} */
        let config = null;

        // Enumerate the files of this directory.
        for (const entry of readdirSafeSync(directoryPath)) {
            const filePath = path.join(directoryPath, entry.name);

            // --- CUSTOM CODE STARTS HERE --- //

            // A decision will be made differently if the path represents a symbolic link.
            let isFile = false;
            let isDirectory = false;

            if (entry.isSymbolicLink()) {
                const fileStat = statSafeSync(filePath);

                if (!fileStat) {
                    continue;
                }

                isFile = fileStat.isFile();
                isDirectory = fileStat.isDirectory();

                if (isFile) {
                    console.log('\nCarefully use symbolic links for files since imports may not be resolved correctly!\n');
                }
            } else {
                isFile = entry.isFile();
                isDirectory = entry.isDirectory();
            }

            // --- CUSTOM CODE ENDS HERE --- //

            // Check if the file is matched.
            if (isFile) { // -- CHANGED FROM `entry.isFile()`
                if (!config) {
                    config = configArrayFactory.getConfigArrayForFile(
                        filePath,

                        /*
                         * We must ignore `ConfigurationNotFoundError` at this
                         * point because we don't know if target files exist in
                         * this directory.
                         */
                        { ignoreNotFoundError: true }
                    );
                }
                const matched = options.selector

                    // Started with a glob pattern; choose by the pattern.
                    ? options.selector.match(filePath)

                    // Started with a directory path; choose by file extensions.
                    : this.isTargetPath(filePath, config);

                if (matched) {
                    const ignored = this._isIgnoredFile(filePath, { ...options, config });
                    const flag = ignored ? IGNORED_SILENTLY : NONE;

                    debug(`Yield: ${entry.name}${ignored ? " but ignored" : ""}`);
                    yield {
                        config: configArrayFactory.getConfigArrayForFile(filePath),
                        filePath,
                        flag
                    };
                } else {
                    debug(`Didn't match: ${entry.name}`);
                }

            // Dive into the sub directory.
            } else if (options.recursive && isDirectory) {  // -- CHANGED FROM `entry.isDirectory()`
                if (!config) {
                    config = configArrayFactory.getConfigArrayForFile(
                        filePath,
                        { ignoreNotFoundError: true }
                    );
                }
                const ignored = this._isIgnoredFile(
                    filePath + path.sep,
                    { ...options, config }
                );

                if (!ignored) {
                    yield* this._iterateFilesRecursive(filePath, options);
                }
            }
        }

        debug(`Leave the directory: ${directoryPath}`);
    }