All files / src/abap/nodes statement_node.ts

96.65% Statements 317/328
95.04% Branches 115/121
100% Functions 26/26
96.65% Lines 317/328

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 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 3281x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 27365x 27365x 27365x 27365x 27365x 13304x 27365x 14061x 14061x 27365x 1x 1x 254402x 254402x 1x 1x 16194x 16194x 1x 1x 3502x 3502x 1x 1x 27329x     27329x 27329x 27329x 27329x 27329x 1x 1x 3087x 3087x 1x 1x 250x 250x 250x 1x 1x 23891x 23891x 23891x 133156x 133156x 23891x 23891x 23891x 1x 1x 875x 3471x 240x 240x 3471x 635x 635x 1x 1x 751x 751x 751x 2384x 2384x 751x 751x 751x 1x 1x 3747x 3747x 3747x 21009x     21009x 3747x 21009x 17262x 4835x 17262x 12427x 12427x 21009x 21009x 3747x 3747x 1x 1x 648x 648x 648x 2458x 2458x 2458x 2458x 2458x 2458x 19x 19x 2458x 648x 2458x 1791x 730x 1791x 1061x 1061x 2439x 2439x 648x 648x 1x 1x 904x 904x 1x 1x 28856x 28856x 28856x     1x 1x 19891x 19891x 19891x 19891x 19891x       1x 1x 8400x 31595x 2988x 2988x 31595x 5412x 5412x 1x 1x 689x 689x 3677x 473x 473x 3677x 689x 689x 1x 1x 108x 108x 554x 27x 27x 554x 81x 81x 1x 1x 20962x 67494x 41727x 67494x 7584x 25767x 18183x 18183x 887x 887x 18183x 67494x 12491x 12491x 1x 1x 17275x 17275x 58346x 43172x 58346x 524x 15174x 14650x 14650x 58346x 17275x 17275x 1x 1x 159x 159x 646x 336x 646x 74x 74x 310x 310x 159x 159x 1x 1x 4248x 4248x 14175x 10624x 10624x 3551x 14175x 10792x 40x 40x 10792x 14175x 3539x 3539x 14175x 4248x 4248x 1x 1x 1x 1x 1x 1x 1x 1x 13x 13x 63x 63x 63x 63x 63x 63x 8x 8x 63x 13x 63x 42x 42x 63x     1x 1x 249x 249x 249x 1456x 1456x 1456x 1456x 1456x 90x 90x 1456x 159x 159x 159x 1x 1x 1x 1x 162783x 162783x 162783x 119473x 119473x 119473x 43310x 162783x 61526x 31899x 61526x 29627x 29627x 61526x 43310x 43310x 43310x 1x 1x 3192x 3192x 3192x 1835x 1835x 1835x 1357x 3192x 1802x 994x 1802x 808x 808x 1802x 1357x 1357x 1357x 1x
import {Position} from "../../position";
import {AbstractNode} from "./_abstract_node";
import {INode} from "./_inode";
import {TokenNode} from "./token_node";
import {ExpressionNode} from "./expression_node";
import {Comment} from "../1_lexer/tokens/comment";
import {Token} from "../1_lexer/tokens/_token";
import {Pragma} from "../1_lexer/tokens/pragma";
import {String, StringTemplate, StringTemplateBegin, StringTemplateMiddle, StringTemplateEnd} from "../1_lexer/tokens/string";
import {IStatement} from "../2_statements/statements/_statement";
import {IStatementRunnable} from "../2_statements/statement_runnable";
 
export class StatementNode extends AbstractNode<ExpressionNode | TokenNode> {
  private readonly statement: IStatement;
  private readonly colon: Token | undefined;
  private readonly pragmas: readonly Token[];
 
  public constructor(statement: IStatement, colon?: Token | undefined, pragmas?: readonly Token[]) {
    super();
    this.statement = statement;
    this.colon = colon;
 
    if (pragmas) {
      this.pragmas = pragmas;
    } else {
      this.pragmas = [];
    }
  }
 
  public get() {
    return this.statement;
  }
 
  public getColon(): Token | undefined {
    return this.colon;
  }
 
  public getPragmas(): readonly Token[] {
    return this.pragmas;
  }
 
  public setChildren(children: (ExpressionNode | TokenNode)[]): StatementNode {
    if (children.length === 0) {
      throw new Error("statement: zero children");
    }
 
    this.children = children;
 
    return this;
  }
 
  public getStart(): Position {
    return this.getFirstToken().getStart();
  }
 
  public getEnd(): Position {
    const last = this.getLastToken();
    return last.getEnd();
  }
 
  public getTokens(): readonly Token[] {
    const tokens: Token[] = [];
 
    for (const c of this.getChildren()) {
      tokens.push(...this.toTokens(c));
    }
 
    return tokens;
  }
 
  public includesToken(search: Token): boolean {
    for (const t of this.getTokens()) {
      if (t.getStart().equals(search.getStart())) {
        return true;
      }
    }
    return false;
  }
 
  public getTokenNodes(): readonly TokenNode[] {
    const tokens: TokenNode[] = [];
 
    for (const c of this.getChildren()) {
      tokens.push(...this.toTokenNodess(c));
    }
 
    return tokens;
  }
 
  public concatTokens(): string {
    let str = "";
    let prev: Token | undefined;
    for (const token of this.getTokens()) {
      if (token instanceof Pragma) {
        continue;
      }
      if (str === "") {
        str = token.getStr();
      } else if (prev && prev.getStr().length + prev.getCol() === token.getCol()
          && prev.getRow() === token.getRow()) {
        str = str + token.getStr();
      } else {
        str = str + " " + token.getStr();
      }
      prev = token;
    }
    return str;
  }
 
  public concatTokensWithoutStringsAndComments(): string {
    let str = "";
    let prev: Token | undefined;
    for (const token of this.getTokens()) {
      if (token instanceof Comment
          || token instanceof String
          || token instanceof StringTemplate
          || token instanceof StringTemplateBegin
          || token instanceof StringTemplateMiddle
          || token instanceof StringTemplateEnd) {
        continue;
      }
      if (str === "") {
        str = token.getStr();
      } else if (prev && prev.getStr().length + prev.getCol() === token.getCol()
          && prev.getRow() === token.getRow()) {
        str = str + token.getStr();
      } else {
        str = str + " " + token.getStr();
      }
      prev = token;
    }
    return str;
  }
 
  public getTerminator(): string {
    return this.getLastToken().getStr();
  }
 
  public getFirstToken(): Token {
    for (const child of this.getChildren()) {
      return child.getFirstToken();
    }
    throw new Error("StatementNode, getFirstToken, no children, " + this.get().constructor.name);
  }
 
  public getLastToken(): Token {
    const child = this.getLastChild();
 
    if (child !== undefined) {
      return child.getLastToken();
    }

    throw new Error("StatementNode, getLastToken, no children");
  }
 
  public findDirectExpression(type: new () => IStatementRunnable): ExpressionNode | undefined {
    for (const child of this.getChildren()) {
      if (child instanceof ExpressionNode && child.get() instanceof type) {
        return child;
      }
    }
    return undefined;
  }
 
  public findDirectExpressions(type: new () => IStatementRunnable): readonly ExpressionNode[] {
    const ret: ExpressionNode[] = [];
    for (const child of this.getChildren()) {
      if (child instanceof ExpressionNode && child.get() instanceof type) {
        ret.push(child);
      }
    }
    return ret;
  }
 
  public findDirectTokenByText(text: string): Token | undefined {
    const upper = text.toUpperCase();
    for (const child of this.getChildren()) {
      if (child instanceof TokenNode && child.get().getStr().toUpperCase() === upper) {
        return child.get();
      }
    }
    return undefined;
  }
 
  public findFirstExpression(type: new () => IStatementRunnable): ExpressionNode | undefined {
    for (const child of this.getChildren()) {
      if (child instanceof TokenNode) {
        continue;
      } else if (child.get() instanceof type) {
        return child;
      } else {
        const res = child.findFirstExpression(type);
        if (res) {
          return res;
        }
      }
    }
    return undefined;
  }
 
  public findAllExpressions(type: new () => IStatementRunnable): readonly ExpressionNode[] {
    const ret: ExpressionNode[] = [];
    for (const child of this.getChildren()) {
      if (child instanceof TokenNode) {
        continue;
      } else if (child.get() instanceof type) {
        ret.push(child);
      } else {
        ret.push(...child.findAllExpressions(type));
      }
    }
    return ret;
  }
 
  public findAllExpressionsRecursive(type: new () => IStatementRunnable): readonly ExpressionNode[] {
    const ret: ExpressionNode[] = [];
    for (const child of this.getChildren()) {
      if (child instanceof TokenNode) {
        continue;
      } else if (child.get() instanceof type) {
        ret.push(child);
      }
      ret.push(...child.findAllExpressions(type));
    }
    return ret;
  }
 
  public findAllExpressionsMulti(type: (new () => IStatementRunnable)[], recursive = false): ExpressionNode[] {
    const ret: ExpressionNode[] = [];
    for (const child of this.getChildren()) {
      if (child instanceof TokenNode) {
        continue;
      }
      const before = ret.length;
      for (const t of type) {
        if (child.get() instanceof t) {
          ret.push(child);
        }
      }
      if (before === ret.length || recursive === true) {
        ret.push(...child.findAllExpressionsMulti(type));
      }
    }
    return ret;
  }
 
  /**
   * Returns the Position of the first token if the sequence is found,
   * otherwise undefined. Strings and Comments are ignored in this search.
   * @param first - Text of the first Token
   * @param second - Text of the second Token
   */
  public findTokenSequencePosition(first: string, second: string): Position | undefined {
    let prev: Token | undefined;
    for (const token of this.getTokens()) {
      if (token instanceof Comment
          || token instanceof String
          || token instanceof StringTemplate
          || token instanceof StringTemplateBegin
          || token instanceof StringTemplateMiddle
          || token instanceof StringTemplateEnd) {
        continue;
      }
      if (prev && token.getStr().toUpperCase() === second && prev?.getStr().toUpperCase() === first.toUpperCase()) {
        return prev.getStart();
      } else {
        prev = token;
      }
    }
    return undefined;
  }
 
  public findExpressionAfterToken(text: string): ExpressionNode | undefined {
    const children = this.getChildren();
 
    for (let i = 0; i < children.length - 1; i++) {
      const c = children[i];
      const next = children[i + 1];
      if (c instanceof TokenNode
          && c.get().getStr().toUpperCase() === text.toUpperCase()
          && next instanceof ExpressionNode) {
        return next;
      }
    }
 
    return undefined;
  }
 
////////////////////////////////
 
  private toTokens(b: INode): readonly Token[] {
    const tokens: Token[] = [];
 
    if (b instanceof TokenNode) {
      tokens.push(b.get());
      return tokens;
    }
 
    for (const c of b.getChildren()) {
      if (c instanceof TokenNode) {
        tokens.push(c.get());
      } else {
        tokens.push(...this.toTokens(c));
      }
    }
 
    return tokens;
  }
 
  private toTokenNodess(b: INode): readonly TokenNode[] {
    const tokens: TokenNode[] = [];
 
    if (b instanceof TokenNode) {
      tokens.push(b);
      return tokens;
    }
 
    for (const c of b.getChildren()) {
      if (c instanceof TokenNode) {
        tokens.push(c);
      } else {
        tokens.push(...this.toTokenNodess(c));
      }
    }
 
    return tokens;
  }
}