All files / src/abap/5_syntax/global_definitions find_global_definitions.ts

97.57% Statements 161/165
90.16% Branches 55/61
100% Functions 5/5
97.57% Lines 161/165

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 1651x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 16240x 16240x 1x 1x 16239x 16239x 16239x 16239x 16239x 16239x 17701x 920x 17701x 16781x 16781x 16781x 16781x 16781x 1000x 1000x 17701x 16239x 16239x 16239x 16239x 16239x 16430x 16430x 16430x 16430x 1167x 1167x 1167x 1167x 394x 394x 1167x 1167x 16430x 16430x 16430x 16430x 16239x 16239x 191x 191x 16239x 1x 1x 1x 1x 1168x 1168x 268x 268x 900x 900x 1168x 288x 288x 1168x 264x 264x 1168x 108x 108x 900x 1168x 369x 271x 271x 369x 1168x 7x 7x 7x 7x 900x 900x 900x 1x 1x 2176x 185x 2176x 233x 1991x 2x 1758x 364x 364x 1003x 1003x 364x 364x 1392x 1392x 1x 1x 1167x 1167x 62x 62x 62x 1105x 1167x 1167x 92x 92x 92x 1013x 1013x 1013x 1013x 1013x 1013x 1013x 1013x 1167x 144x 144x 144x 144x 144x 144x 6x 6x 144x     1167x 869x 869x 869x 869x 869x 869x 108x 108x 869x     869x 1167x 1x
import {IRegistry} from "../../../_iregistry";
import {InterfaceDefinition} from "../../types/interface_definition";
import {ClassDefinition} from "../../types/class_definition";
import {CurrentScope} from "../_current_scope";
import * as Structures from "../../3_structures/structures";
import {Interface} from "../../../objects/interface";
import {Class} from "../../../objects/class";
import * as BasicTypes from "../../types/basic";
import {AbstractType} from "../../types/basic/_abstract_type";
import {IProgress} from "../../../progress";
import {TypedIdentifier} from "../../types/_typed_identifier";
import {AuthorizationCheckField, DataElement, LockObject, Table, TableType, View} from "../../../objects";
 
// todo: rewrite all of this to use a graph based deterministic approach instead
 
// this makes sure to cache global interface and class definitions in the corresponding object
export class FindGlobalDefinitions {
  private readonly reg: IRegistry;
 
  public constructor(reg: IRegistry) {
    this.reg = reg;
  }
 
  public run(progress?: IProgress) {
    const MAX_PASSES = 10;
    let lastPass = Number.MAX_SAFE_INTEGER;
 
    // the setDirty method in the objects clears the definitions
    let candidates: (Class | Interface)[] = [];
    for (const o of this.reg.getObjects()) {
      if ((o instanceof Interface || o instanceof Class) && o.getDefinition() === undefined) {
        candidates.push(o);
      } else if (o instanceof DataElement
          || o instanceof Table
          || o instanceof TableType
          || o instanceof View
          || o instanceof LockObject
          || o instanceof AuthorizationCheckField) {
        o.parseType(this.reg); // make sure the references are set after parsing finishes
      }
    }
    // make sure the sequence is always the same, disregarding the sequence they were added to the registry
    // this will hopefully make it easier to debug
    candidates.sort((a, b) => {return a.getName().localeCompare(b.getName());});
 
    for (let i = 1; i <= MAX_PASSES; i++) {
      progress?.set(candidates.length, "Global OO types, pass " + i);
      let thisPass = 0;
      const next: (Class | Interface)[] = [];
      for (const o of candidates) {
        progress?.tickSync("Global OO types(pass " + i + "), next pass: " + next.length);
        this.update(o);
        const untypedCount = this.countUntyped(o);
        if (untypedCount > 0) {
          next.push(o);
        }
        thisPass = thisPass + untypedCount;
      }
 
      candidates = next;
 
      if (lastPass === thisPass || thisPass === 0) {
        break;
      }
      lastPass = thisPass;
    }
  }
 
/////////////////////////////
 
  public countUntyped(obj: Interface | Class): number {
    const def = obj.getDefinition();
    if (def === undefined) {
      return 1;
    }
 
    let count = 0;
    for (const t of def.getTypeDefinitions().getAll()) {
      count = count + this.count(t.type.getType());
    }
    for (const a of def.getAttributes().getAll()) {
      count = count + this.count(a.getType());
    }
    for (const a of def.getAttributes().getConstants()) {
      count = count + this.count(a.getType());
    }
 
    for (const m of def.getMethodDefinitions().getAll()) {
      for (const p of m.getParameters().getAll()) {
        count = count + this.count(p.getType());
      }
    }
    for (const e of def.getEvents() || []) {
      for (const p of e.getParameters()) {
        count = count + this.count(p.getType());
      }
    }
 
    return count;
  }
 
  private count(type: TypedIdentifier | AbstractType): number {
    if (type instanceof BasicTypes.UnknownType || type instanceof BasicTypes.VoidType) {
      return 1;
    } else if (type instanceof BasicTypes.TableType) {
      return this.count(type.getRowType());
    } else if (type instanceof BasicTypes.DataReference) {
      return this.count(type.getType());
    } else if (type instanceof BasicTypes.StructureType) {
      let count = 0;
      for (const c of type.getComponents()) {
        count = count + this.count(c.type);
      }
      return count;
    }
    return 0;
  }
 
  private update(obj: Interface | Class) {
    const file = obj.getMainABAPFile();
    if (file === undefined) {
      obj.setDefinition(undefined);
      return;
    }
 
    const struc = file?.getStructure();
    if (struc === undefined) {
      obj.setDefinition(undefined);
      return;
    }
 
    const input = {
      filename: file.getFilename(),
      scope: CurrentScope.buildDefault(this.reg, obj),
      issues: [],
      deferred: [],
    };
 
    if (obj instanceof Interface) {
      const found = struc.findFirstStructure(Structures.Interface);
      if (found) {
        try {
          const def = new InterfaceDefinition(found, input);
          obj.setDefinition(def);
        } catch {
          obj.setDefinition(undefined);
        }
      } else {
        obj.setDefinition(undefined);
      }
    } else {
      const found = struc.findFirstStructure(Structures.ClassDefinition);
      if (found) {
        try {
          const def = new ClassDefinition(found, input);
          obj.setDefinition(def);
        } catch {
          obj.setDefinition(undefined);
        }
      } else {
        obj.setDefinition(undefined);
      }
    }
  }
}