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 376x 376x 376x 376x 99x 99x 376x     376x 376x 376x 376x 99x 99x 99x 28x 28x 99x 376x 376x 376x     375x 376x 257x 257x 2x 2x 257x 375x 375x 375x 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);
  }
}