All files / src/abap/5_syntax/expressions compare.ts

100% Statements 43/43
84.61% Branches 11/13
100% Functions 1/1
100% Lines 43/43

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 441x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 234x 234x 234x 234x 410x 410x 234x 234x 1x 1x 234x 234x 18x 18x 234x 234x 234x 234x 3x 3x 3x 3x 3x 2x 3x 1x 1x 3x 3x 234x 1x  
import * as Expressions from "../../2_statements/expressions";
import {ExpressionNode} from "../../nodes";
import {Source} from "./source";
import {MethodCallChain} from "./method_call_chain";
import {SourceFieldSymbol} from "./source_field_symbol";
import {SyntaxInput, syntaxIssue} from "../_syntax_input";
import {AbstractType} from "../../types/basic/_abstract_type";
import {DateType, IntegerType} from "../../types/basic";
import {TypeUtils} from "../_type_utils";
 
export class Compare {
  public static runSyntax(node: ExpressionNode, input: SyntaxInput): void {
 
    const sourceTypes: (AbstractType | undefined)[] = [];
    const sources = node.findDirectExpressions(Expressions.Source);
    for (const t of sources) {
      sourceTypes.push(Source.runSyntax(t, input));
    }
 
    for (const t of node.findDirectExpressions(Expressions.SourceFieldSymbolChain)) {
      SourceFieldSymbol.runSyntax(t, input);
    }
 
    for (const t of node.findDirectExpressions(Expressions.MethodCallChain)) {
      MethodCallChain.runSyntax(t, input);
    }
 
    if (node.findDirectExpression(Expressions.CompareOperator)
        && new TypeUtils(input.scope).isCompareable(sourceTypes[0], sourceTypes[1], sources[0], sources[1]) === false
        && sourceTypes.length === 2) {
      let message = "Incompatible types for comparison";
      if ((sourceTypes[0] instanceof DateType
          && sourceTypes[1] instanceof IntegerType
          && sources[1].findFirstExpression(Expressions.ArithOperator))
          || (sourceTypes[1] instanceof DateType
          && sourceTypes[0] instanceof IntegerType
          && sources[0].findFirstExpression(Expressions.ArithOperator))) {
        message = "Date cannot be compared with arithmetic result of type Integer";
      }
      input.issues.push(syntaxIssue(input, node.getFirstToken(), message));
    }
  }
}