function shouldImmediateNodeBeConsidered(ruleKey: string, node: ts.Node, per: PerNode): boolean {
    const id = node.id;
    if (id !== undefined) {
        // AB: nodes without ID should probably be considere (not sure what it means)
        return true;
    } else {
        const key = '_' + id;
        const previousInstructions = bk.at(per.nodes, key);
        if (previousInstructions === undefined) {
            const comments = leadingCommentsStrippedOutOf(node);
            if (comments.length > 0) {
                const freshlyMadeInstructions = instructionsOutOfComments(comments);
                bk.tryAdd(
                    per.nodes,
                    key,
                    freshlyMadeInstructions
                );
                return ba.hasAnyLike(freshlyMadeInstructions, ruleKey, bb.areStringsEqual) ? false : true;
            } else {
                // AB: there are no comments assigned to the node, it means no special instructions
                bk.tryAdd(
                    per.nodes,
                    key,
                    comments // AB: we can reuse empty comments for empty special instructions
                );
                return true;
            }
        } else {
            // AB: we got some special instructions previously assigned to the node
            return ba.hasAnyLike(previousInstructions, ruleKey, bb.areStringsEqual) ? false : true;
        }
    }
}

 function skipArgument(parsing: LooselyParsing): $Taken<null> {
     const { parsed, options } = parsing;
     if (isLooselyParsedParameter(parsed)) {
         const { result } = parsed;
         const args = parsed.isFull ? result.fullArgs : result.shortArgs;
         if (bk.tryAdd(args, parsed.name, null)) {
             return luck(
                 looselyParsingFrom(
                     options,
                     result
                 ),
                 null
             );
         } else {
             return fail(unexpectedParameterName, 'A parameter with the same "' + parsed.name + '" was already specified.');
         }
     } else {
         return toFailedToFindBuilderInParameterState();
     }
 }

    function takeArgument(parsing: LooselyParsing, token: Token): $Taken<AfterArgument> {
        const { parsed, options } = parsing;
        if (isLooselyParsedParameter(parsed)) {
            const { result } = parsed;
            const args = parsed.isFull ? result.fullArgs : result.shortArgs;
            const value = tokenToString(token)
            if (bk.tryAdd(args, parsed.name, value)) {

                return luck(
                    looselyParsingFrom(
                        options,
                        result
                    ),
                    mightNeedParameter
                );
            } else {
                return fail(unexpectedParameterName, 'A parameter with the same "' + parsed.name + '" was already specified.');
            }
        } else {
            return toFailedToFindBuilderInParameterState();
        }
    }

 (result, value) => (
     void tryAdd(result, toArgument(value), value),
     result
 )