All files / src/abap/5_syntax/expressions type_table.ts

91.3% Statements 42/46
83.33% Branches 10/12
100% Functions 1/1
91.3% Lines 42/46

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 461x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 506x 506x 506x 506x 137x 137x 506x     506x 506x 506x 506x 137x 137x 137x 41x 41x 137x 506x 506x 506x     504x 506x 382x 382x 2x 2x 382x 504x 504x 504x 1x
import {ExpressionNode, StatementNode} from "../../nodes";
import {CurrentScope} from "../_current_scope";
import {TypedIdentifier} from "../../types/_typed_identifier";
import {BasicTypes} from "../basic_types";
import * as Expressions from "../../2_statements/expressions";
import {UnknownType} from "../../types/basic";
import {ScopeType} from "../_scope_type";
import {TypeTableKey} from "./type_table_key";
 
export class TypeTable {
  public runSyntax(node: ExpressionNode | StatementNode, scope: CurrentScope,
                   filename: string, qualifiedNamePrefix?: string): TypedIdentifier | undefined {
    // todo, input is currently the statement, but should be the expression?
    let nameExpr = node.findFirstExpression(Expressions.DefinitionName);
    if (nameExpr === undefined) {
      nameExpr = node.findFirstExpression(Expressions.NamespaceSimpleName);
    }
    if (nameExpr === undefined) {
      return undefined;
    }
    const name = nameExpr.getFirstToken();
 
    let qualifiedName = qualifiedNamePrefix || "";
    if (node.getFirstToken().getStr().toUpperCase() === "TYPES") {
      qualifiedName = qualifiedName + name.getStr();
      if (scope.getType() === ScopeType.ClassDefinition
          || scope.getType() === ScopeType.Interface) {
        qualifiedName = scope.getName() + "=>" + qualifiedName;
      }
    }
 
    let type = new BasicTypes(filename, scope).parseTable(node, qualifiedName);
    if (type === undefined) {
      return new TypedIdentifier(name, filename, new UnknownType("TableType, fallback"));
    }
 
    for (const tt of node.findAllExpressions(Expressions.TypeTableKey)) {
      const error = new TypeTableKey().runSyntax(tt, type);
      if (error) {
        type = error;
      }
    }
 
    return new TypedIdentifier(name, filename, type);
  }
}