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

99.29% Statements 139/140
94.92% Branches 56/59
100% Functions 5/5
99.29% Lines 139/140

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 1401x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 5276x 5276x 1x 1x 5276x 5276x 5276x 5276x 5276x 5276x 5489x 364x 5489x 5125x 5125x 5125x 107x 107x 5489x 5276x 5276x 5276x 5276x 5276x 5370x 5370x 5370x 5370x 477x 477x 477x 477x 184x 184x 477x 477x 5370x 5370x 5370x 5370x 5276x 5276x 94x 94x 5276x 1x 1x 1x 1x 477x 477x 142x 142x 335x 335x 335x 477x 45x 45x 477x 64x 64x 335x 477x 102x 53x 53x 102x 335x 335x 335x 1x 1x 253x 74x 253x 17x 179x   162x 35x 35x 74x 74x 35x 35x 127x 127x 1x 1x 477x 477x 477x 477x 77x 77x 61x 61x 61x 61x 2x 2x 77x 16x 16x 477x 400x 400x 326x 326x 326x 326x 50x 50x 400x 74x 74x 400x 477x 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 {DataElement, 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 View
          || o instanceof TableType
          || o instanceof Table) {
        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;
    }
  }
 
/////////////////////////////
 
  private countUntyped(obj: Interface | Class): number {
    const def = obj.getDefinition();
    if (def === undefined) {
      return 1;
    }
 
    // todo, count constants
    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 m of def.getMethodDefinitions().getAll()) {
      for (const p of m.getParameters().getAll()) {
        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();
    const struc = file?.getStructure();
 
    if (obj instanceof Interface) {
      const found = struc?.findFirstStructure(Structures.Interface);
      if (struc && file && found) {
        try {
          const def = new InterfaceDefinition(found, file.getFilename(), CurrentScope.buildDefault(this.reg, obj));
          obj.setDefinition(def);
        } catch {
          obj.setDefinition(undefined);
        }
      } else {
        obj.setDefinition(undefined);
      }
    } else if (obj instanceof Class) {
      const found = struc?.findFirstStructure(Structures.ClassDefinition);
      if (struc && file && found) {
        try {
          const def = new ClassDefinition(found, file.getFilename(), CurrentScope.buildDefault(this.reg, obj));
          obj.setDefinition(def);
        } catch {
          obj.setDefinition(undefined);
        }
      } else {
        obj.setDefinition(undefined);
      }
    }
  }
}