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

99.32% Statements 148/149
94.02% Branches 63/67
100% Functions 5/5
99.32% Lines 148/149

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 1491x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 6651x 6651x 1x 1x 6650x 6650x 6650x 6650x 6650x 6650x 6947x 416x 6947x 6531x 6531x 6531x 6531x 6531x 205x 205x 6947x 6650x 6650x 6650x 6650x 6650x 6754x 6754x 6754x 6754x 541x 541x 541x 541x 204x 204x 541x 541x 6754x 6754x 6754x 6754x 6650x 6650x 104x 104x 6650x 1x 1x 1x 1x 542x 542x 149x 149x 393x 393x 542x 53x 53x 542x 74x 74x 542x 88x 88x 393x 542x 120x 63x 63x 120x 542x 3x 1x 1x 3x 393x 393x 393x 1x 1x 384x 92x 384x 17x 292x   275x 46x 46x 88x 88x 46x 46x 229x 229x 1x 1x 541x 541x 541x 541x 98x 98x 80x 80x 80x 80x 4x 4x 98x 18x 18x 541x 443x 443x 369x 369x 369x 369x 53x 53x 443x 74x 74x 443x 541x 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 View
          || o instanceof TableType
          || o instanceof LockObject
          || o instanceof AuthorizationCheckField
          || 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;
    }
  }
 
/////////////////////////////
 
  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();
    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 {
      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);
      }
    }
  }
}