All files / src/abap/nodes structure_node.ts

93.99% Statements 219/233
92.77% Branches 77/83
100% Functions 20/20
93.99% Lines 219/233

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 2331x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 22346x 22346x 22346x 1x 1x 184834x 184834x 1x 1x 1x 326x 676x 65x 676x 350x 611x 261x 261x 228x 228x 261x 676x 33x 33x 1x 1x 52x 52x 70x 70x 52x 52x 1x 1x 80x 80x 80x 80x 80x     1x 1x 2207x 2207x 3279x 400x 400x 3279x 2207x 2207x 1x 1x 5374x 5374x 7523x 450x 450x 7523x 5374x 5374x 1x 1x 4244x 4457x 4044x 4457x 248x 413x 165x 165x 45x 45x 165x 4457x 155x 155x 1x 1x 6016x 10890x 10890x 1705x 1705x 10890x 4311x 4311x 1x 1x 74x 74x 72x 72x 2x 2x     1x 1x 245x 245x 245x 245x 245x       1x 1x 873x 873x 873x 873x 873x       1x 1x 11819x 11819x 23012x 23012x 11819x 11819x 1x 1x 2244x 2244x 4324x 4324x 2244x 2244x 1x 1x 25993x 25993x 50090x 17043x 50090x 1376x 1376x 50090x 25993x 25993x 1x 1x 1489x 1489x 2920x 1805x 2920x 1115x 1115x 2920x 1489x 1489x 1x 1x 5574x 5574x 5574x 10823x 6400x 10823x 75x 75x 4423x 4423x 5574x 5574x 1x 1x 67129x 67129x     67129x 111155x 62426x 111155x 2367x 48729x 46362x 46362x 111155x 67129x 67129x 1x 1x 7117x 1740x 1740x 7117x 13325x 1245x 1245x 13325x 4132x 4132x 1x 1x 24981x 923x 923x 24981x 50143x 35057x 50143x 3762x 15086x 11324x 11324x     11324x 50143x 20296x 20296x 1x 1x
import {AbstractNode} from "./_abstract_node";
import {Token} from "../1_lexer/tokens/_token";
import {IStatement} from "../2_statements/statements/_statement";
import {IStructure} from "../3_structures/structures/_structure";
import {IStatementRunnable} from "../2_statements/statement_runnable";
import {StatementNode} from "./statement_node";
import {ExpressionNode} from "./expression_node";
 
export class StructureNode extends AbstractNode<StructureNode | StatementNode> {
  private readonly structure: IStructure;
 
  public constructor(structure: IStructure) {
    super();
    this.structure = structure;
  }
 
  public get() {
    return this.structure;
  }
 
  // todo, remove this method, the logic should never go up in the tree
  public findParent(node: StatementNode): StructureNode | undefined {
    for (const child of this.getChildren()) {
      if (child === node) {
        return this;
      } else if (child instanceof StatementNode) {
        continue;
      } else {
        const res = child.findParent(node);
        if (res) {
          return res;
        }
      }
    }
    return undefined;
  }
 
  public concatTokens(): string {
    let concat = "";
    for (const child of this.getChildren()) {
      concat = concat + child.concatTokens();
    }
    return concat;
  }
 
  public findDirectStatement(type: new () => IStatement): StatementNode | undefined {
    for (const child of this.getChildren()) {
      if (child instanceof StatementNode && child.get() instanceof type) {
        return child;
      }
    }
    return undefined;
  }
 
  public findDirectStatements(type: new () => IStatement): StatementNode[] {
    const ret: StatementNode[] = [];
    for (const child of this.getChildren()) {
      if (child instanceof StatementNode && child.get() instanceof type) {
        ret.push(child);
      }
    }
    return ret;
  }
 
  public findDirectStructures(type: new () => IStructure): StructureNode[] {
    const ret: StructureNode[] = [];
    for (const child of this.getChildren()) {
      if (child instanceof StructureNode && child.get() instanceof type) {
        ret.push(child);
      }
    }
    return ret;
  }
 
  public findFirstStatement(type: new () => IStatement): StatementNode | undefined {
    for (const child of this.getChildren()) {
      if (child.get() instanceof type) {
        return child as StatementNode;
      } else if (child instanceof StatementNode) {
        continue;
      } else {
        const res = child.findFirstStatement(type);
        if (res) {
          return res;
        }
      }
    }
    return undefined;
  }
 
  public findFirstExpression(type: new () => IStatementRunnable): ExpressionNode | undefined {
    for (const child of this.getChildren()) {
      const res = child.findFirstExpression(type);
      if (res) {
        return res;
      }
    }
    return undefined;
  }
 
  public getFirstStatement(): StatementNode | undefined {
    for (const child of this.getChildren()) {
      if (child instanceof StatementNode) {
        return child;
      }
      return child.getFirstStatement();
    }
    return undefined;
  }
 
  public getFirstToken(): Token {
    const child = this.getFirstChild();
 
    if (child !== undefined) {
      return child.getFirstToken();
    }

    throw new Error("StructureNode, getFirstToken, unexpected type");
  }
 
  public getLastToken(): Token {
    const child = this.getLastChild();
 
    if (child !== undefined) {
      return child.getLastToken();
    }

    throw new Error("StructureNode, getLastToken, unexpected type");
  }
 
  public findAllExpressions(type: new () => IStatementRunnable): ExpressionNode[] {
    const ret: ExpressionNode[] = [];
    for (const child of this.getChildren()) {
      ret.push(...child.findAllExpressions(type));
    }
    return ret;
  }
 
  public findAllExpressionsMulti(type: (new () => IStatementRunnable)[]): ExpressionNode[] {
    const ret: ExpressionNode[] = [];
    for (const child of this.getChildren()) {
      ret.push(...child.findAllExpressionsMulti(type));
    }
    return ret;
  }
 
  public findAllStatements(type: new () => IStatement): StatementNode[] {
    const ret: StatementNode[] = [];
    for (const child of this.getChildren()) {
      if (child instanceof StructureNode) {
        ret.push(...child.findAllStatements(type));
      } else if (child.get() instanceof type) {
        ret.push(child);
      }
    }
    return ret;
  }
 
  public findAllStatementNodes(): StatementNode[] {
    const ret: StatementNode[] = [];
    for (const child of this.getChildren()) {
      if (child instanceof StatementNode) {
        ret.push(child);
      } else {
        ret.push(...child.findAllStatementNodes());
      }
    }
    return ret;
  }
 
  public findAllStructuresRecursive(type: new () => IStructure): StructureNode[] {
    const ret: StructureNode[] = [];
 
    for (const child of this.getChildren()) {
      if (child instanceof StatementNode) {
        continue;
      } else if (child.get() instanceof type) {
        ret.push(child);
      }
      ret.push(...child.findAllStructuresRecursive(type));
    }
    return ret;
  }
 
  public findAllStructures(type: new () => IStructure): StructureNode[] {
    const ret: StructureNode[] = [];
    if (this.get() instanceof type) {
      return [this];
    }
    for (const child of this.getChildren()) {
      if (child instanceof StatementNode) {
        continue;
      } else if (child.get() instanceof type) {
        ret.push(child);
      } else {
        ret.push(...child.findAllStructures(type));
      }
    }
    return ret;
  }
 
  public findDirectStructure(type: new () => IStructure): StructureNode | undefined {
    if (this.get() instanceof type) {
      return this;
    }
    for (const child of this.getChildren()) {
      if (child.get() instanceof type) {
        return child as StructureNode;
      }
    }
    return undefined;
  }
 
  public findFirstStructure(type: new () => IStructure): StructureNode | undefined {
    if (this.get() instanceof type) {
      return this;
    }
    for (const child of this.getChildren()) {
      if (child instanceof StatementNode) {
        continue;
      } else if (child.get() instanceof type) {
        return child;
      } else {
        const res = child.findFirstStructure(type);
        if (res) {
          return res;
        }
      }
    }
    return undefined;
  }
 
}