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

95.91% Statements 47/49
90.9% Branches 10/11
100% Functions 1/1
95.91% Lines 47/49

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 44 45 46 47 48 49 501x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 46x 46x 46x 46x 46x     46x 46x 46x 46x 10x 10x 46x 46x 5x 5x 46x 46x 48x 48x 46x 46x 46x 75x 44x 75x 31x 31x 75x 46x 46x 10x 10x 46x 46x 46x 1x  
import {ExpressionNode} from "../../nodes";
import * as Expressions from "../../2_statements/expressions";
import {Source} from "./source";
import {Let} from "./let";
import {Cond} from "./cond";
import {AbstractType} from "../../types/basic/_abstract_type";
import {RaiseMessage} from "../_raise_message";
import {SyntaxInput} from "../_syntax_input";
 
export class CondBody {
  public static runSyntax(
    node: ExpressionNode | undefined,
    input: SyntaxInput,
    targetType: AbstractType | undefined): AbstractType | undefined {
 
    if (node === undefined) {
      return undefined;
    }
 
    let scoped = false;
    const l = node.findDirectExpression(Expressions.Let);
    if (l) {
      scoped = Let.runSyntax(l, input);
    }
 
    for (const t of node.findDirectExpressions(Expressions.Throw)) {
      RaiseMessage.checkThrow(t, input);
    }
 
    for (const s of node.findDirectExpressions(Expressions.Cond)) {
      Cond.runSyntax(s, input);
    }
 
    let type: AbstractType | undefined = undefined;
    for (const s of node.findDirectExpressions(Expressions.Source)) {
      if (type === undefined) {
        type = Source.runSyntax(s, input, targetType);
      } else {
        Source.runSyntax(s, input, targetType ?? type);
      }
    }
 
    if (scoped === true) {
      input.scope.pop(node.getLastToken().getEnd());
    }
 
    return type;
  }
}