com.github._1c_syntax.bsl.languageserver.diagnostics.FieldsFromJoinsWithoutIsNullDiagnostic Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of bsl-language-server Show documentation
Language Server Protocol implementation for 1C (BSL) - 1C:Enterprise 8 and OneScript languages.
The newest version!
/*
 * This file is a part of BSL Language Server.
 *
 * Copyright (c) 2018-2024
 * Alexey Sosnoviy , Nikita Fedkin  and contributors
 *
 * SPDX-License-Identifier: LGPL-3.0-or-later
 *
 * BSL Language Server is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 3.0 of the License, or (at your option) any later version.
 *
 * BSL Language Server is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with BSL Language Server.
 */
package com.github._1c_syntax.bsl.languageserver.diagnostics;

import com.github._1c_syntax.bsl.languageserver.diagnostics.metadata.DiagnosticMetadata;
import com.github._1c_syntax.bsl.languageserver.diagnostics.metadata.DiagnosticSeverity;
import com.github._1c_syntax.bsl.languageserver.diagnostics.metadata.DiagnosticTag;
import com.github._1c_syntax.bsl.languageserver.diagnostics.metadata.DiagnosticType;
import com.github._1c_syntax.bsl.languageserver.utils.Ranges;
import com.github._1c_syntax.bsl.languageserver.utils.RelatedInformation;
import com.github._1c_syntax.bsl.languageserver.utils.Trees;
import com.github._1c_syntax.bsl.parser.BSLParserRuleContext;
import com.github._1c_syntax.bsl.parser.SDBLParser;
import edu.umd.cs.findbugs.annotations.Nullable;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.TerminalNode;
import org.eclipse.lsp4j.DiagnosticRelatedInformation;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

@DiagnosticMetadata(
  type = DiagnosticType.ERROR,
  severity = DiagnosticSeverity.CRITICAL,
  minutesToFix = 2,
  activatedByDefault = false,
  tags = {
    DiagnosticTag.SQL,
    DiagnosticTag.SUSPICIOUS,
    DiagnosticTag.UNPREDICTABLE
  }
)
public class FieldsFromJoinsWithoutIsNullDiagnostic extends AbstractSDBLVisitorDiagnostic {

  // схема расчета - находится поле из соединения,
  // далее идет поиск вверх по родительским узлам для проверки вхождения в разных вариациях ЕСТЬNULL или ЕСТЬ NULL
  // для оптимизации ищем вверх не до начального узла всего дерева, а до узла, в котором искать уже нет смысла

  private static final Integer EXCLUDED_TOP_RULE_FOR_SELECT = SDBLParser.RULE_selectedField;
  private static final Collection SELECT_STATEMENTS = Set.of(EXCLUDED_TOP_RULE_FOR_SELECT,
    SDBLParser.RULE_builtInFunctions, SDBLParser.RULE_isNullPredicate);

  private static final Integer EXCLUDED_TOP_RULE_FOR_WHERE = SDBLParser.RULE_query;
  private static final Collection WHERE_STATEMENTS = Set.of(EXCLUDED_TOP_RULE_FOR_WHERE,
    SDBLParser.RULE_builtInFunctions, SDBLParser.RULE_isNullPredicate);

  private static final Integer EXCLUDED_TOP_RULE_FOR_JOIN = SDBLParser.RULE_joinPart;
  private static final Collection JOIN_STATEMENTS = Set.of(EXCLUDED_TOP_RULE_FOR_JOIN,
    SDBLParser.RULE_builtInFunctions);

  public static final Collection RULES_OF_PARENT_FOR_SEARCH_CONDITION = Set.of(SDBLParser.RULE_predicate,
    SDBLParser.RULE_query);

  public static final int NOT_WITH_PARENS_EXPR_MEMBERS_COUNT = 4;
  public static final int NOT_IS_NULL_EXPR_MEMBER_COUNT = 2;

  private final List nodesForIssues = new ArrayList<>();

  @Override
  public ParseTree visitJoinPart(SDBLParser.JoinPartContext joinPartCtx) {

    joinedTables(joinPartCtx)
      .forEach(tableName -> checkQuery(tableName, joinPartCtx));

    if (!nodesForIssues.isEmpty()) {
      diagnosticStorage.addDiagnostic(joinPartCtx, getRelatedInformation(joinPartCtx));
      nodesForIssues.clear();
    }

    return super.visitJoinPart(joinPartCtx);
  }

  private static Stream joinedTables(SDBLParser.JoinPartContext joinPartCtx) {
    return Optional.of(joinPartCtx)
      .stream().flatMap(joinPartContext -> joinedDataSourceContext(joinPartContext).stream())
      .filter(Objects::nonNull)
      .map(SDBLParser.DataSourceContext::alias)
      .filter(Objects::nonNull)
      .map(SDBLParser.AliasContext::identifier)
      .map(BSLParserRuleContext::getText);
  }

  private static List joinedDataSourceContext(SDBLParser.JoinPartContext joinPartCtx) {
    final List result;
    if (joinPartCtx.LEFT() != null) {
      result = Collections.singletonList(joinPartCtx.dataSource());
    } else if (joinPartCtx.RIGHT() != null) {
      result = Collections.singletonList(((SDBLParser.DataSourceContext) joinPartCtx.getParent()));
    } else if (joinPartCtx.FULL() != null) {
      result = Arrays.asList(((SDBLParser.DataSourceContext) joinPartCtx.getParent()),
        joinPartCtx.dataSource());
    } else {
      result = Collections.emptyList();
    }
    return result;
  }

  private void checkQuery(String joinedTableName, SDBLParser.JoinPartContext joinPartCtx) {
    Optional.ofNullable(Trees.getRootParent(joinPartCtx, SDBLParser.RULE_query))
      .map(SDBLParser.QueryContext.class::cast)
      .filter(ctx -> !haveExprNotIsNullInsideWhere(ctx.where))
      .ifPresent((SDBLParser.QueryContext queryCtx) -> {
        checkSelect(joinedTableName, queryCtx.columns);
        checkWhere(joinedTableName, queryCtx.where);

        checkAllJoins(joinedTableName, joinPartCtx);
      });
  }

  private static boolean haveExprNotIsNullInsideWhere(@Nullable SDBLParser.LogicalExpressionContext whereCtx) {
    return Optional.ofNullable(whereCtx)
      .stream().flatMap(ctx -> Trees.findAllRuleNodes(ctx, SDBLParser.RULE_isNullPredicate).stream())
      .map(SDBLParser.IsNullPredicateContext.class::cast)
      .anyMatch(isNullPredicateCtx ->
        haveFirstIsThenNotThenNull(isNullPredicateCtx)
          || haveExprNotIsNullInsideWhere(isNullPredicateCtx));
  }

  private static boolean haveFirstIsThenNotThenNull(SDBLParser.IsNullPredicateContext isNullPredicateContext) {
    return isNullPredicateContext.NOT() != null;
  }

  private static boolean haveExprNotIsNullInsideWhere(SDBLParser.IsNullPredicateContext isNullPredicateCtx) {
    final var parent = (SDBLParser.PredicateContext) isNullPredicateCtx.getParent();
    if (parent.getChildCount() == NOT_IS_NULL_EXPR_MEMBER_COUNT && parent.NOT() != null) {
      return true;
    }
    return haveExprNotWithParens(parent);
  }

  private static boolean isTerminalNodeNOT(ParseTree node) {
    return node instanceof TerminalNode && ((TerminalNode) node).getSymbol().getType() == SDBLParser.NOT;
  }

  private static boolean haveExprNotWithParens(SDBLParser.PredicateContext ctx) {
    final var rootCtx = Trees.getRootParent(ctx, RULES_OF_PARENT_FOR_SEARCH_CONDITION);
    if (rootCtx == null || rootCtx.getRuleIndex() == SDBLParser.RULE_query) {
      return false;
    }
    return rootCtx.getChildCount() == NOT_WITH_PARENS_EXPR_MEMBERS_COUNT && isTerminalNodeNOT(rootCtx.getChild(0));
  }

  private void checkSelect(String tableName, SDBLParser.SelectedFieldsContext columns) {
    checkStatements(tableName, columns, SELECT_STATEMENTS, EXCLUDED_TOP_RULE_FOR_SELECT, true);
  }

  private void checkStatements(String tableName, BSLParserRuleContext expression, Collection statements,
                               Integer rootForStatement, boolean checkIsNullOperator) {

    Trees.findAllRuleNodes(expression, SDBLParser.RULE_column).stream()
      .filter(Objects::nonNull)
      .filter(SDBLParser.ColumnContext.class::isInstance)
      .map(SDBLParser.ColumnContext.class::cast)
      .filter(columnContext -> checkColumn(tableName, columnContext, statements, rootForStatement, checkIsNullOperator))
      .collect(Collectors.toCollection(() -> nodesForIssues));
  }

  private static boolean checkColumn(String tableName, SDBLParser.ColumnContext columnCtx,
                                     Collection statements, Integer rootForStatement,
                                     boolean checkIsNullOperator) {
    return Optional.of(columnCtx)
      .filter(columnContext -> columnContext.mdoName != null)
      .filter(columnContext -> columnContext.mdoName.getText().equalsIgnoreCase(tableName))
      .filter(columnContext -> !haveIsNullInsideExprForColumn(columnContext, statements, rootForStatement,
        checkIsNullOperator))
      .isPresent();
  }

  private static boolean haveIsNullInsideExprForColumn(BSLParserRuleContext ctx, Collection statements,
                                                       Integer rootForStatement, boolean checkIsNullOperator) {
    var selectStatement = Trees.getRootParent(ctx, statements);
    if (selectStatement == null || selectStatement.getChildCount() == 0
      || rootForStatement == selectStatement.getRuleIndex()) {
      return false;
    }
    if (checkIsNullOperator && haveIsNullOperator(selectStatement)) {
      return true;
    }
    return haveIsNullFunction(selectStatement)
      || haveIsNullInsideExprForColumn(selectStatement, statements, rootForStatement, checkIsNullOperator);
  }

  private static boolean haveIsNullOperator(BSLParserRuleContext ctx) {
    return Optional.of(ctx)
      .filter(SDBLParser.IsNullPredicateContext.class::isInstance)
      .map(SDBLParser.IsNullPredicateContext.class::cast)
      .isPresent();
  }

  private static boolean haveIsNullFunction(BSLParserRuleContext ctx) {
    return Optional.of(ctx)
      .filter(SDBLParser.BuiltInFunctionsContext.class::isInstance)
      .map(SDBLParser.BuiltInFunctionsContext.class::cast)
      .map(SDBLParser.BuiltInFunctionsContext::ISNULL)
      .isPresent();
  }

  private void checkWhere(String tableName, @Nullable SDBLParser.LogicalExpressionContext where) {
    Optional.ofNullable(where)
      .stream().flatMap(searchConditionsContext -> searchConditionsContext.condidions.stream())
      .forEach(searchConditionContext -> checkStatements(tableName, searchConditionContext,
        WHERE_STATEMENTS, EXCLUDED_TOP_RULE_FOR_WHERE, true));
  }

  private void checkAllJoins(String tableName, SDBLParser.JoinPartContext currentJoinPart) {
    Optional.ofNullable(Trees.getRootParent(currentJoinPart, SDBLParser.RULE_dataSource))
      .filter(SDBLParser.DataSourceContext.class::isInstance)
      .stream().flatMap(ctx -> ((SDBLParser.DataSourceContext) ctx).joinPart().stream())
      .filter(joinPartContext -> joinPartContext != currentJoinPart)
      .map(SDBLParser.JoinPartContext::logicalExpression)
      .forEach(searchConditionsContext -> checkStatements(tableName, searchConditionsContext,
        JOIN_STATEMENTS, EXCLUDED_TOP_RULE_FOR_JOIN, false));
  }

  private List getRelatedInformation(SDBLParser.JoinPartContext self) {
    return nodesForIssues.stream()
      .filter(ctx -> !ctx.equals(self))
      .map(context -> RelatedInformation.create(
        documentContext.getUri(),
        Ranges.create(context),
        "+1"
      )).collect(Collectors.toList());
  }
}