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 242x 242x 242x 242x 242x 236x 236x 242x 242x 830x 830x 824x 325x 325x 325x 325x 824x 15x 15x 4x 15x 11x 11x 15x 830x 6x 6x 6x 6x 6x 830x 242x 242x 4x 242x 238x 238x 238x 242x 56x 56x 238x 238x 238x 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 {CurrentScope} from "../_current_scope";
import {IncludeType} from "../statements/include_type";
import {Type} from "../statements/type";
import * as Basic from "../../types/basic";
import {ScopeType} from "../_scope_type";
 
export class Types {
  public runSyntax(node: StructureNode, scope: CurrentScope, filename: string, 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, scope, filename, 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, scope, filename);
          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, scope, filename, qualifiedNamePrefix + name.getStr() + "-");
        if (found) {
          components.push({name: found.getName(), type: found.getType()});
        }
      }
    }
 
    if (voidd) {
      return new TypedIdentifier(name, filename, voidd);
    } else if (components.length === 0) { // todo, remove this check
      return undefined;
    }
 
    let qualifiedName = qualifiedNamePrefix + name.getStr();
    if (scope.getType() === ScopeType.ClassDefinition
        || scope.getType() === ScopeType.Interface) {
      qualifiedName = scope.getName() + "=>" + qualifiedName;
    }
 
    return new TypedIdentifier(name, filename, new Basic.StructureType(components, qualifiedName));
  }
}