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

92.4% Statements 73/79
73.33% Branches 11/15
100% Functions 1/1
92.4% Lines 73/79

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 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 791x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 39x 39x 39x 39x 39x 39x     39x 39x 39x 39x 3x 3x 39x 39x 39x 45x 36x 36x 36x 45x 45x 45x 45x 43x 43x 45x 45x 45x 39x 39x 45x 39x 39x 39x 40x 40x 39x 39x 40x 38x 39x     38x 38x 38x 38x 38x 38x 38x 38x 38x 39x 39x 39x 38x 38x 38x 39x     39x 1x
import {ExpressionNode} from "../../nodes";
import {CurrentScope} from "../_current_scope";
import * as Expressions from "../../2_statements/expressions";
import {For} from "./for";
import {Source} from "./source";
import {AbstractType} from "../../types/basic/_abstract_type";
import {InlineFieldDefinition} from "./inline_field_definition";
import {UnknownType} from "../../types/basic/unknown_type";
import {ReduceNext} from "./reduce_next";
import {Let} from "./let";
import {ScopeType} from "../_scope_type";
 
export class ReduceBody {
  public runSyntax(
    node: ExpressionNode | undefined,
    scope: CurrentScope,
    filename: string,
    targetType: AbstractType | undefined): AbstractType | undefined {
 
    if (node === undefined) {
      return;
    }
 
    let scoped = false;
    const letNode = node.findDirectExpression(Expressions.Let);
    if (letNode) {
      scoped = new Let().runSyntax(letNode, scope, filename);
    }
 
    let first: AbstractType | undefined = undefined;
    for (const i of node.findDirectExpressions(Expressions.InlineFieldDefinition)) {
      if (scoped === false) {
        scope.push(ScopeType.Let, "LET", node.getFirstToken().getStart(), filename);
        scoped = true;
      }
 
      let foundType = targetType;
      const source = i.findDirectExpression(Expressions.Source);
      if (source) {
        foundType = new Source().runSyntax(source, scope, filename, targetType);
      }
 
      const found = new InlineFieldDefinition().runSyntax(i, scope, filename, foundType);
      if (found && first === undefined) {
        first = found;
      }
    }
 
    let forScopes = 0;
    for (const forNode of node.findDirectExpressions(Expressions.For) || []) {
      const scoped = new For().runSyntax(forNode, scope, filename);
      if (scoped === true) {
        forScopes++;
      }
    }
 
    for (const s of node.findDirectExpressions(Expressions.Source)) {
      new Source().runSyntax(s, scope, filename);
    }
 
    for (const s of node.findDirectExpressions(Expressions.ReduceNext)) {
      new ReduceNext().runSyntax(s, scope, filename);
    }
 
    if (scoped === true) {
      scope.pop(node.getLastToken().getEnd());
    }
 
    for (let i = 0; i < forScopes; i++) {
      scope.pop(node.getLastToken().getEnd());
    }
 
    if (first) {
      return first;
    } else {
      return new UnknownType("todo, ReduceBody");
    }
  }
}