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 66x 66x 66x 66x 66x 66x 66x 66x 66x 66x 66x 66x 66x 66x 66x 66x 41x 41x 64x 66x 19x 19x 63x 66x 6x 6x 6x 6x 6x 63x 66x 13x 13x 63x 66x 2x 2x 63x 66x 18x 18x 63x 66x 4x 4x 63x 63x 63x 1x
import * as Expressions from "../../2_statements/expressions";
import {ExpressionNode, StatementNode} from "../../nodes";
import {CurrentScope} from "../_current_scope";
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";
 
export class For {
  public runSyntax(node: ExpressionNode | StatementNode, scope: CurrentScope, filename: string): 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
      scope.push(ScopeType.For, "FOR", node.getFirstToken().getStart(), filename);
      scoped = true;
    }
 
    for (const s of inlineLoop) {
      new InlineLoopDefinition().runSyntax(s, scope, filename);
    }
 
    for (const f of inlineField) {
      new InlineFieldDefinition().runSyntax(f, scope, filename);
    }
 
    if (groupsToken !== undefined) {
      const type = new VoidType("todoGroupBy");
      const identifier = new TypedIdentifier(groupsToken, filename, type, [IdentifierMeta.InlineDefinition]);
      scope.addIdentifier(identifier);
      scope.addReference(groupsToken, identifier, ReferenceType.DataWriteReference, filename);
    }
 
    for (const s of node.findDirectExpressions(Expressions.Source)) {
      new Source().runSyntax(s, scope, filename);
    }
 
    for (const s of node.findDirectExpressions(Expressions.ComponentCond)) {
      new ComponentCond().runSyntax(s, scope, filename);
    }
 
    for (const s of node.findDirectExpressions(Expressions.Cond)) {
      new Cond().runSyntax(s, scope, filename);
    }
 
    if (lett) {
      new Let().runSyntax(lett, scope, filename, true);
    }
 
    return scoped;
  }
}