All files / src/abap/5_syntax/statements move.ts

100% Statements 45/45
80% Branches 12/15
100% Functions 1/1
100% Lines 45/45

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 451x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 228x 228x 228x 228x 228x 228x 228x 133x 133x 126x 125x 125x 1x 1x 125x 220x 220x 228x 228x 228x 1x 1x 211x 228x 93x 93x 93x 211x 228x 6x 6x 228x 1x
import * as Expressions from "../../2_statements/expressions";
import {StatementNode} from "../../nodes";
import {CurrentScope} from "../_current_scope";
import {Source} from "../expressions/source";
import {Target} from "../expressions/target";
import {InlineData} from "../expressions/inline_data";
import {AbstractType} from "../../types/basic/_abstract_type";
import {StatementSyntax} from "../_statement_syntax";
import {TypeUtils} from "../_type_utils";
 
export class Move implements StatementSyntax {
  public runSyntax(node: StatementNode, scope: CurrentScope, filename: string): void {
    const targets = node.findDirectExpressions(Expressions.Target);
    const firstTarget = targets[0];
 
    const inline = firstTarget?.findDirectExpression(Expressions.InlineData);
 
    let targetType: AbstractType | undefined = undefined;
    if (inline === undefined) {
      targetType = firstTarget ? new Target().runSyntax(firstTarget, scope, filename) : undefined;
      for (const t of targets) {
        if (t === firstTarget) {
          continue;
        }
        new Target().runSyntax(t, scope, filename);
      }
    }
 
    const source = node.findDirectExpression(Expressions.Source);
    const sourceType = source ? new Source().runSyntax(source, scope, filename, targetType) : undefined;
 
    if (sourceType === undefined) {
      throw new Error("No source type determined");
    }
 
    if (inline) {
      new InlineData().runSyntax(inline, scope, filename, sourceType);
      targetType = sourceType;
    }
 
    if (TypeUtils.isAssignable(sourceType, targetType) === false) {
      throw new Error("Incompatible types");
    }
  }
}