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

98.67% Statements 74/75
92.98% Branches 53/57
100% Functions 6/6
98.63% Lines 72/73

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  1x 1x 1x 1x 1x 1x 1x               1x       4989x       4989x 4989x     4989x 4989x 5163x 336x         4989x   4989x 5076x 5076x 5076x 5076x 442x 442x 442x 442x 172x   442x     5076x   5076x 4989x   87x             442x 442x 135x       307x 307x 41x   307x 60x     307x 94x 47x       307x       239x 69x 170x 17x 153x   153x 35x 35x 74x   35x   118x       442x 442x   442x 66x 66x 50x 50x 48x   2x     16x   376x 376x 376x 310x 310x 259x   51x     66x        
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";
 
// 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);
      }
    }
    // 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 Iif (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.setDefinition(def);
        } catch {
          obj.setDefinition(undefined);
        }
      } else {
        obj.setDefinition(undefined);
      }
    } else Eif (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.setDefinition(def);
        } catch {
          obj.setDefinition(undefined);
        }
      } else {
        obj.setDefinition(undefined);
      }
    }
  }
}