structures types.ts

96.72% Statements 59/61

93.75% Branches 15/16

100% Functions 1/1

96.72% Lines 59/61

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

1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 374x 374x 374x 374x 374x 366x 366x 374x 374x 1461x 1461x 1453x 690x 690x 690x 690x 1453x 15x 15x 4x 15x 11x 11x 15x 1461x 8x 8x 8x 8x 8x 1461x 374x 374x 4x 374x 370x 370x 370x 374x 86x 86x 370x 370x 370x 1x

import * as Expressions from "../../2_statements/expressions";
import * as Statements from "../../2_statements/statements";
import * as Structures from "../../3_structures/structures";
import {StructureNode, StatementNode} from "../../nodes";
import {TypedIdentifier} from "../../types/_typed_identifier";
import {IStructureComponent, VoidType} from "../../types/basic";
import {IncludeType} from "../statements/include_type";
import {Type} from "../statements/type";
import * as Basic from "../../types/basic";
import {ScopeType} from "../_scope_type";
import {SyntaxInput} from "../_syntax_input";
 
export class Types {
  public runSyntax(node: StructureNode, input: SyntaxInput, qualifiedNamePrefix?: string): TypedIdentifier | undefined {
    const name = node.findFirstExpression(Expressions.NamespaceSimpleName)!.getFirstToken();
    const components: IStructureComponent[] = [];
    let voidd: VoidType | undefined = undefined;
 
    if (qualifiedNamePrefix === undefined) {
      qualifiedNamePrefix = "";
    }
 
    for (const c of node.getChildren()) {
      const ctyp = c.get();
      if (c instanceof StatementNode) {
        if (ctyp instanceof Statements.Type) {
          const found = new Type().runSyntax(c, input, qualifiedNamePrefix + name.getStr() + "-");
          if (found) {
            components.push({name: found.getName(), type: found.getType()});
          }
        } else if (ctyp instanceof Statements.IncludeType) {
          const found = new IncludeType().runSyntax(c, input);
          if (found instanceof VoidType) {
            voidd = found;
          } else {
            components.push(...found);
          }
        }
      } else if (c instanceof StructureNode && ctyp instanceof Structures.Types) {
        const found = new Types().runSyntax(c, input, qualifiedNamePrefix + name.getStr() + "-");
        if (found) {
          components.push({name: found.getName(), type: found.getType()});
        }
      }
    }
 
    if (voidd) {
      return new TypedIdentifier(name, input.filename, voidd);
    } else if (components.length === 0) { // todo, remove this check
      return undefined;
    }
 
    let qualifiedName = qualifiedNamePrefix + name.getStr();
    if (input.scope.getType() === ScopeType.ClassDefinition
        || input.scope.getType() === ScopeType.Interface) {
      qualifiedName = input.scope.getName() + "=>" + qualifiedName;
    }
 
    return new TypedIdentifier(name, input.filename, new Basic.StructureType(components, qualifiedName));
  }
}