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

100% Statements 65/65
100% Branches 20/20
100% Functions 1/1
100% Lines 65/65

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 651x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 76x 76x 76x 76x 76x 76x 76x 76x 76x 76x 76x 76x 76x 76x 76x 76x 45x 45x 75x 76x 24x 24x 75x 76x 7x 7x 7x 7x 7x 75x 76x 14x 14x 75x 76x 2x 2x 75x 76x 24x 24x 75x 76x 4x 4x 75x 75x 75x 1x
import * as Expressions from "../../2_statements/expressions";
import {ExpressionNode, StatementNode} from "../../nodes";
import {InlineFieldDefinition} from "./inline_field_definition";
import {Source} from "./source";
import {InlineLoopDefinition} from "./inline_loop_definition";
import {ScopeType} from "../_scope_type";
import {ComponentCond} from "./component_cond";
import {Cond} from "./cond";
import {VoidType} from "../../types/basic";
import {IdentifierMeta, TypedIdentifier} from "../../types/_typed_identifier";
import {ReferenceType} from "../_reference";
import {Let} from "./let";
import {SyntaxInput} from "../_syntax_input";
 
export class For {
  public runSyntax(node: ExpressionNode | StatementNode, input: SyntaxInput): boolean {
    let scoped = false;
    const inlineLoop = node.findDirectExpressions(Expressions.InlineLoopDefinition);
    const inlineField = node.findDirectExpressions(Expressions.InlineFieldDefinition);
    const groupsToken = node.findExpressionAfterToken("GROUPS")?.getFirstToken();
    const lett = node.findDirectExpression(Expressions.Let);
    const addScope = inlineLoop.length > 0
      || inlineField.length > 0
      || lett !== undefined
      || groupsToken !== undefined;
    if (addScope) {
      // this scope is popped in parent expressions
      input.scope.push(ScopeType.For, "FOR", node.getFirstToken().getStart(), input.filename);
      scoped = true;
    }
 
    for (const s of inlineLoop) {
      new InlineLoopDefinition().runSyntax(s, input);
    }
 
    for (const f of inlineField) {
      new InlineFieldDefinition().runSyntax(f, input);
    }
 
    if (groupsToken !== undefined) {
      const type = new VoidType("todoGroupBy");
      const identifier = new TypedIdentifier(groupsToken, input.filename, type, [IdentifierMeta.InlineDefinition]);
      input.scope.addIdentifier(identifier);
      input.scope.addReference(groupsToken, identifier, ReferenceType.DataWriteReference, input.filename);
    }
 
    for (const s of node.findDirectExpressions(Expressions.Source)) {
      new Source().runSyntax(s, input);
    }
 
    for (const s of node.findDirectExpressions(Expressions.ComponentCond)) {
      new ComponentCond().runSyntax(s, input);
    }
 
    for (const s of node.findDirectExpressions(Expressions.Cond)) {
      new Cond().runSyntax(s, input);
    }
 
    if (lett) {
      new Let().runSyntax(lett, input, true);
    }
 
    return scoped;
  }
}