GGD/node_modules/prettier-plugin-java/dist/printers/printer-utils.js

"use strict";
var __assign = (this && this.__assign) || function () {
    __assign = Object.assign || function(t) {
        for (var s, i = 1, n = arguments.length; i < n; i++) {
            s = arguments[i];
            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
                t[p] = s[p];
        }
        return t;
    };
    return __assign.apply(this, arguments);
};
var __spreadArray = (this && this.__spreadArray) || function (to, from) {
    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
        to[j] = from[i];
    return to;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.printArrayList = exports.isUniqueMethodInvocation = exports.sortImports = exports.isStatementEmptyStatement = exports.isShiftOperator = exports.separateTokensIntoGroups = exports.putIntoBraces = exports.getInterfaceBodyDeclarationsSeparator = exports.getClassBodyDeclarationsSeparator = exports.getBlankLinesSeparator = exports.isExplicitLambdaParameter = exports.displaySemicolon = exports.findDeepElementInPartsArray = exports.sortModifiers = exports.sortClassTypeChildren = exports.matchCategory = exports.sortNodes = exports.sortAnnotationIdentifier = exports.rejectAndConcat = exports.rejectAndJoin = exports.rejectSeparators = exports.reject = exports.rejectAndJoinSeps = exports.buildFqn = void 0;
var forEach_1 = __importDefault(require("lodash/forEach"));
var forEachRight_1 = __importDefault(require("lodash/forEachRight"));
var findLastIndex_1 = __importDefault(require("lodash/findLastIndex"));
var findIndex_1 = __importDefault(require("lodash/findIndex"));
var includes_1 = __importDefault(require("lodash/includes"));
var prettier_builder_1 = require("./prettier-builder");
var format_comments_1 = require("./comments/format-comments");
var comments_utils_1 = require("./comments/comments-utils");
var doc_1 = require("prettier/doc");
var utils_1 = require("../types/utils");
var indent = doc_1.builders.indent, hardline = doc_1.builders.hardline, line = doc_1.builders.line;
var isConcat = doc_1.utils.isConcat;
var orderedModifiers = [
    "Public",
    "Protected",
    "Private",
    "Abstract",
    "Default",
    "Static",
    "Final",
    "Transient",
    "Volatile",
    "Synchronized",
    "Native",
    "Sealed",
    "NonSealed",
    "Strictfp"
];
function buildFqn(tokens, dots) {
    return rejectAndJoinSeps(dots ? dots : [], tokens);
}
exports.buildFqn = buildFqn;
function rejectAndJoinSeps(sepTokens, elems, sep) {
    if (!Array.isArray(sepTokens)) {
        return rejectAndJoin(sepTokens, elems);
    }
    var actualElements = reject(elems);
    var res = [];
    for (var i = 0; i < sepTokens.length; i++) {
        res.push(actualElements[i], sepTokens[i]);
        if (sep) {
            res.push(sep);
        }
    }
    res.push.apply(res, actualElements.slice(sepTokens.length));
    return prettier_builder_1.concat(res);
}
exports.rejectAndJoinSeps = rejectAndJoinSeps;
function reject(elems) {
    return elems.filter(function (item) {
        if (typeof item === "string") {
            return item !== "";
        }
        // eslint-ignore next - We want the conversion to boolean!
        // @ts-ignore
        return item != false && item !== undefined;
    });
}
exports.reject = reject;
function rejectSeparators(separators, elems) {
    var realElements = reject(elems);
    var realSeparators = [];
    for (var i = 0; i < realElements.length - 1; i++) {
        if (realElements[i] !== "") {
            realSeparators.push(separators[i]);
        }
    }
    return realSeparators;
}
exports.rejectSeparators = rejectSeparators;
function rejectAndJoin(sep, elems) {
    var actualElements = reject(elems);
    return prettier_builder_1.join(sep, actualElements);
}
exports.rejectAndJoin = rejectAndJoin;
function rejectAndConcat(elems) {
    var actualElements = reject(elems);
    return prettier_builder_1.concat(actualElements);
}
exports.rejectAndConcat = rejectAndConcat;
function sortAnnotationIdentifier(annotations, identifiers) {
    var tokens = __spreadArray([], identifiers);
    if (annotations && annotations.length > 0) {
        tokens = __spreadArray(__spreadArray([], tokens), annotations);
    }
    return tokens.sort(function (a, b) {
        var startOffset1 = utils_1.isCstNode(a)
            ? a.children.At[0].startOffset
            : a.startOffset;
        var startOffset2 = utils_1.isCstNode(b)
            ? b.children.At[0].startOffset
            : b.startOffset;
        return startOffset1 - startOffset2;
    });
}
exports.sortAnnotationIdentifier = sortAnnotationIdentifier;
function sortTokens(values) {
    var tokens = [];
    forEach_1.default(values, function (argument) {
        if (argument) {
            tokens = tokens.concat(argument);
        }
    });
    return tokens.sort(function (a, b) {
        return a.startOffset - b.startOffset;
    });
}
function sortNodes(values) {
    var nodes = [];
    forEach_1.default(values, function (argument) {
        if (argument) {
            nodes = nodes.concat(argument);
        }
    });
    return nodes.sort(function (a, b) {
        var aOffset = a.location.startOffset;
        var bOffset = b.location.startOffset;
        return aOffset - bOffset;
    });
}
exports.sortNodes = sortNodes;
function matchCategory(token, categoryName) {
    var labels = (token.tokenType.CATEGORIES || []).map(function (category) {
        return category.LABEL;
    });
    return labels.indexOf(categoryName) !== -1;
}
exports.matchCategory = matchCategory;
function sortClassTypeChildren(annotations, typeArguments, identifiers, dots) {
    var tokens = __spreadArray([], identifiers);
    if (annotations && annotations.length > 0) {
        tokens = __spreadArray(__spreadArray([], tokens), annotations);
    }
    if (typeArguments && typeArguments.length > 0) {
        tokens = __spreadArray(__spreadArray([], tokens), typeArguments);
    }
    if (dots && dots.length > 0) {
        tokens = __spreadArray(__spreadArray([], tokens), dots);
    }
    return tokens.sort(function (a, b) {
        var startOffsetA = utils_1.isCstNode(a)
            ? a.children.At
                ? a.children.At[0].startOffset
                : a.children.Less[0].startOffset
            : a.startOffset;
        var startOffsetB = utils_1.isCstNode(b)
            ? b.children.At
                ? b.children.At[0].startOffset
                : b.children.Less[0].startOffset
            : b.startOffset;
        return startOffsetA - startOffsetB;
    });
}
exports.sortClassTypeChildren = sortClassTypeChildren;
function sortModifiers(modifiers) {
    var firstAnnotations = [];
    var otherModifiers = [];
    var lastAnnotations = [];
    var hasOtherModifier = false;
    /**
     * iterate in reverse order because we special-case
     * method annotations which come after all other
     * modifiers
     */
    forEachRight_1.default(modifiers, function (modifier) {
        var isAnnotation = modifier.children.annotation !== undefined;
        var isMethodAnnotation = isAnnotation &&
            (modifier.name === "methodModifier" ||
                modifier.name === "interfaceMethodModifier");
        if (isAnnotation) {
            if (isMethodAnnotation && !hasOtherModifier) {
                lastAnnotations.unshift(modifier);
            }
            else {
                firstAnnotations.unshift(modifier);
            }
        }
        else {
            otherModifiers.unshift(modifier);
            hasOtherModifier = true;
        }
    });
    /**
     * if there are only annotations, move everything from
     * lastAnnotations to firstAnnotations
     */
    if (!hasOtherModifier) {
        firstAnnotations = firstAnnotations.concat(lastAnnotations);
        lastAnnotations = [];
    }
    otherModifiers.sort(function (a, b) {
        var modifierIndexA = orderedModifiers.indexOf(Object.keys(a.children)[0]);
        var modifierIndexB = orderedModifiers.indexOf(Object.keys(b.children)[0]);
        return modifierIndexA - modifierIndexB;
    });
    return [firstAnnotations, otherModifiers.concat(lastAnnotations)];
}
exports.sortModifiers = sortModifiers;
function findDeepElementInPartsArray(item, elt) {
    if (Array.isArray(item)) {
        if (includes_1.default(item, elt)) {
            return true;
        }
        for (var i = 0; i < item.length; i++) {
            if (findDeepElementInPartsArray(item[i], elt)) {
                return true;
            }
        }
    }
    else {
        for (var key in item) {
            if (typeof item[key] === "object" &&
                findDeepElementInPartsArray(item[key], elt)) {
                return true;
            }
        }
    }
    return false;
}
exports.findDeepElementInPartsArray = findDeepElementInPartsArray;
function displaySemicolon(token, params) {
    if (params !== undefined && params.allowEmptyStatement) {
        return format_comments_1.printTokenWithComments(token);
    }
    if (!comments_utils_1.hasComments(token)) {
        return "";
    }
    token.image = "";
    return format_comments_1.printTokenWithComments(token);
}
exports.displaySemicolon = displaySemicolon;
function isExplicitLambdaParameter(ctx) {
    return (ctx &&
        ctx.lambdaParameterList &&
        ctx.lambdaParameterList[0] &&
        ctx.lambdaParameterList[0].children &&
        ctx.lambdaParameterList[0].children.explicitLambdaParameterList);
}
exports.isExplicitLambdaParameter = isExplicitLambdaParameter;
function getBlankLinesSeparator(ctx, separator) {
    if (separator === void 0) { separator = hardline; }
    if (ctx === undefined) {
        return undefined;
    }
    var separators = [];
    for (var i = 0; i < ctx.length - 1; i++) {
        var node = ctx[i];
        var previousRuleEndLineWithComment = comments_utils_1.hasTrailingComments(node)
            ? node.trailingComments[node.trailingComments.length - 1].endLine
            : node.location.endLine;
        var nextNode = ctx[i + 1];
        var nextRuleStartLineWithComment = comments_utils_1.hasLeadingComments(nextNode)
            ? nextNode.leadingComments[0].startLine
            : nextNode.location.startLine;
        if (nextRuleStartLineWithComment - previousRuleEndLineWithComment > 1) {
            separators.push(prettier_builder_1.concat([hardline, hardline]));
        }
        else {
            separators.push(separator);
        }
    }
    return separators;
}
exports.getBlankLinesSeparator = getBlankLinesSeparator;
function getDeclarationsSeparator(declarations, needLineDeclaration, isSemicolon) {
    var declarationsWithoutEmptyStatements = declarations.filter(function (declaration) { return !isSemicolon(declaration); });
    var userBlankLinesSeparators = getBlankLinesSeparator(declarationsWithoutEmptyStatements);
    var additionalBlankLines = declarationsWithoutEmptyStatements.map(needLineDeclaration);
    var separators = [];
    var indexNextNotEmptyDeclaration = 0;
    for (var i = 0; i < declarations.length - 1; i++) {
        // if the empty statement has comments
        // we want to print them on their own line
        if (isSemicolon(declarations[i])) {
            if (comments_utils_1.hasComments(declarations[i])) {
                separators.push(hardline);
            }
        }
        else if (indexNextNotEmptyDeclaration <
            declarationsWithoutEmptyStatements.length - 1) {
            var isTwoHardLines = 
            // @ts-ignore
            userBlankLinesSeparators[indexNextNotEmptyDeclaration].parts[0].type ===
                "concat";
            var additionalSep = !isTwoHardLines &&
                (additionalBlankLines[indexNextNotEmptyDeclaration + 1] ||
                    additionalBlankLines[indexNextNotEmptyDeclaration])
                ? hardline
                : "";
            separators.push(prettier_builder_1.concat([
                userBlankLinesSeparators[indexNextNotEmptyDeclaration],
                additionalSep
            ]));
            indexNextNotEmptyDeclaration += 1;
        }
    }
    return separators;
}
function needLineClassBodyDeclaration(declaration) {
    if (declaration.children.classMemberDeclaration === undefined) {
        return true;
    }
    var classMemberDeclaration = declaration.children.classMemberDeclaration[0];
    if (classMemberDeclaration.children.fieldDeclaration !== undefined) {
        var fieldDeclaration = classMemberDeclaration.children.fieldDeclaration[0];
        if (fieldDeclaration.children.fieldModifier !== undefined &&
            hasAnnotation(fieldDeclaration.children.fieldModifier)) {
            return true;
        }
        return false;
    }
    else if (classMemberDeclaration.children.Semicolon !== undefined) {
        return false;
    }
    return true;
}
function needLineInterfaceMemberDeclaration(declaration) {
    if (declaration.children.constantDeclaration !== undefined) {
        var constantDeclaration = declaration.children.constantDeclaration[0];
        if (constantDeclaration.children.constantModifier !== undefined &&
            hasAnnotation(constantDeclaration.children.constantModifier)) {
            return true;
        }
        return false;
    }
    else if (declaration.children.interfaceMethodDeclaration !== undefined) {
        var interfaceMethodDeclaration = declaration.children.interfaceMethodDeclaration[0];
        if (interfaceMethodDeclaration.children.interfaceMethodModifier !==
            undefined &&
            hasNonTrailingAnnotation(interfaceMethodDeclaration.children.interfaceMethodModifier)) {
            return true;
        }
        return false;
    }
    return true;
}
function isClassBodyDeclarationASemicolon(classBodyDeclaration) {
    if (classBodyDeclaration.children.classMemberDeclaration) {
        if (classBodyDeclaration.children.classMemberDeclaration[0].children
            .Semicolon !== undefined) {
            return true;
        }
    }
    return false;
}
function isInterfaceMemberASemicolon(interfaceMemberDeclaration) {
    return interfaceMemberDeclaration.children.Semicolon !== undefined;
}
function hasAnnotation(modifiers) {
    return modifiers.some(function (modifier) { return modifier.children.annotation !== undefined; });
}
/**
 * Return true if there is a method modifier that does not come after all other modifiers
 * It is useful to know if sortModifiers will add an annotation before other modifiers
 *
 * @param methodModifiers
 * @returns {boolean}
 */
function hasNonTrailingAnnotation(methodModifiers) {
    var firstAnnotationIndex = findIndex_1.default(methodModifiers, function (modifier) { return modifier.children.annotation !== undefined; });
    var lastNonAnnotationIndex = findLastIndex_1.default(methodModifiers, function (modifier) { return modifier.children.annotation === undefined; });
    return (firstAnnotationIndex < lastNonAnnotationIndex ||
        lastNonAnnotationIndex === -1);
}
function getClassBodyDeclarationsSeparator(classBodyDeclarationContext) {
    return getDeclarationsSeparator(classBodyDeclarationContext, needLineClassBodyDeclaration, isClassBodyDeclarationASemicolon);
}
exports.getClassBodyDeclarationsSeparator = getClassBodyDeclarationsSeparator;
function getInterfaceBodyDeclarationsSeparator(interfaceMemberDeclarationContext) {
    return getDeclarationsSeparator(interfaceMemberDeclarationContext, needLineInterfaceMemberDeclaration, isInterfaceMemberASemicolon);
}
exports.getInterfaceBodyDeclarationsSeparator = getInterfaceBodyDeclarationsSeparator;
function putIntoBraces(argument, separator, LBrace, RBrace) {
    var rightBraceLeadingComments = format_comments_1.getTokenLeadingComments(RBrace);
    var lastBreakLine = 
    // check if last element of the array is a line
    rightBraceLeadingComments.length !== 0 &&
        rightBraceLeadingComments[rightBraceLeadingComments.length - 1] === hardline
        ? rightBraceLeadingComments.pop()
        : separator;
    delete RBrace.leadingComments;
    var contentInsideBraces;
    if (argument === undefined || argument === "") {
        if (rightBraceLeadingComments.length === 0) {
            return prettier_builder_1.concat([LBrace, RBrace]);
        }
        contentInsideBraces = __spreadArray([separator], rightBraceLeadingComments);
    }
    else if (rightBraceLeadingComments.length !== 0) {
        contentInsideBraces = __spreadArray([
            separator,
            argument,
            separator
        ], rightBraceLeadingComments);
    }
    else {
        contentInsideBraces = [separator, argument];
    }
    return prettier_builder_1.group(rejectAndConcat([
        LBrace,
        indent(prettier_builder_1.concat(contentInsideBraces)),
        lastBreakLine,
        RBrace
    ]));
}
exports.putIntoBraces = putIntoBraces;
var andOrBinaryOperators = ["&&", "||", "&", "|", "^"];
function separateTokensIntoGroups(ctx) {
    /**
     * separate tokens into groups by andOrBinaryOperators ("&&", "||", "&", "|", "^")
     * in order to break those operators in priority.
     */
    var tokens = sortTokens([
        ctx.Instanceof,
        ctx.AssignmentOperator,
        ctx.Less,
        ctx.Greater,
        ctx.BinaryOperator
    ]);
    var groupsOfOperator = [];
    var sortedBinaryOperators = [];
    var tmpGroup = [];
    tokens.forEach(function (token) {
        if (matchCategory(token, "'BinaryOperator'") &&
            includes_1.default(andOrBinaryOperators, token.image)) {
            sortedBinaryOperators.push(token);
            groupsOfOperator.push(tmpGroup);
            tmpGroup = [];
        }
        else {
            tmpGroup.push(token);
        }
    });
    groupsOfOperator.push(tmpGroup);
    return {
        groupsOfOperator: groupsOfOperator,
        sortedBinaryOperators: sortedBinaryOperators
    };
}
exports.separateTokensIntoGroups = separateTokensIntoGroups;
function isShiftOperator(tokens, index) {
    if (tokens.length <= index + 1) {
        return "none";
    }
    if (tokens[index].image === "<" &&
        tokens[index + 1].image === "<" &&
        tokens[index].startOffset === tokens[index + 1].startOffset - 1) {
        return "leftShift";
    }
    if (tokens[index].image === ">" &&
        tokens[index + 1].image === ">" &&
        tokens[index].startOffset === tokens[index + 1].startOffset - 1) {
        if (tokens.length > index + 2 &&
            tokens[index + 2].image === ">" &&
            tokens[index + 1].startOffset === tokens[index + 2].startOffset - 1) {
            return "doubleRightShift";
        }
        return "rightShift";
    }
    return "none";
}
exports.isShiftOperator = isShiftOperator;
function isStatementEmptyStatement(statement) {
    return (statement === ";" ||
        // @ts-ignore
        (isConcat(statement) && statement.parts[0] === ";"));
}
exports.isStatementEmptyStatement = isStatementEmptyStatement;
function sortImports(imports) {
    var staticImports = [];
    var nonStaticImports = [];
    if (imports !== undefined) {
        for (var i = 0; i < imports.length; i++) {
            if (imports[i].children.Static !== undefined) {
                staticImports.push(imports[i]);
            }
            else if (imports[i].children.emptyStatement === undefined) {
                nonStaticImports.push(imports[i]);
            }
        }
        // TODO: Could be optimized as we could expect that the array is already almost sorted
        var comparator = function (first, second) {
            return compareFqn(first.children.packageOrTypeName[0], second.children.packageOrTypeName[0]);
        };
        staticImports.sort(comparator);
        nonStaticImports.sort(comparator);
    }
    return {
        staticImports: staticImports,
        nonStaticImports: nonStaticImports
    };
}
exports.sortImports = sortImports;
function compareFqn(packageOrTypeNameFirst, packageOrTypeNameSecond) {
    var identifiersFirst = packageOrTypeNameFirst.children.Identifier;
    var identifiersSecond = packageOrTypeNameSecond.children.Identifier;
    var minParts = Math.min(identifiersFirst.length, identifiersSecond.length);
    for (var i = 0; i < minParts; i++) {
        if (identifiersFirst[i].image < identifiersSecond[i].image) {
            return -1;
        }
        else if (identifiersFirst[i].image > identifiersSecond[i].image) {
            return 1;
        }
    }
    if (identifiersFirst.length < identifiersSecond.length) {
        return -1;
    }
    else if (identifiersFirst.length > identifiersSecond.length) {
        return 1;
    }
    return 0;
}
function isUniqueMethodInvocation(primarySuffixes) {
    if (primarySuffixes === undefined) {
        return 0;
    }
    var count = 0;
    primarySuffixes.forEach(function (primarySuffix) {
        if (primarySuffix.children.methodInvocationSuffix !== undefined) {
            count++;
            if (count > 1) {
                return 2;
            }
        }
    });
    return count;
}
exports.isUniqueMethodInvocation = isUniqueMethodInvocation;
function printArrayList(_a) {
    var list = _a.list, extraComma = _a.extraComma, LCurly = _a.LCurly, RCurly = _a.RCurly, trailingComma = _a.trailingComma;
    var optionalComma;
    if (trailingComma !== "none" && list !== "") {
        optionalComma = extraComma
            ? prettier_builder_1.ifBreak(extraComma[0], __assign(__assign({}, extraComma[0]), { image: "" }))
            : prettier_builder_1.ifBreak(",", "");
    }
    else {
        optionalComma = extraComma ? __assign(__assign({}, extraComma[0]), { image: "" }) : "";
    }
    return putIntoBraces(rejectAndConcat([list, optionalComma]), line, LCurly, RCurly);
}
exports.printArrayList = printArrayList;