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 2968x 2968x 2968x 2968x 318x 318x 2968x     2968x 2968x 2968x 2968x 318x 318x 318x 140x 140x 318x 2968x 2968x 2968x     2966x 2968x 2753x 2753x 2x 2x 2753x 2966x 2966x 2966x 1x
import {ExpressionNode, StatementNode} from "../../nodes";
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";
import {SyntaxInput} from "../_syntax_input";
 
export class TypeTable {
  public static runSyntax(node: ExpressionNode | StatementNode, input: SyntaxInput,
                          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 (input.scope.getType() === ScopeType.ClassDefinition
          || input.scope.getType() === ScopeType.Interface) {
        qualifiedName = input.scope.getName() + "=>" + qualifiedName;
      }
    }
 
    let type = new BasicTypes(input).parseTable(node, qualifiedName);
    if (type === undefined) {
      return new TypedIdentifier(name, input.filename, new UnknownType("TableType, fallback"));
    }
 
    for (const tt of node.findAllExpressions(Expressions.TypeTableKey)) {
      const error = TypeTableKey.runSyntax(tt, type);
      if (error) {
        type = error;
      }
    }
 
    return new TypedIdentifier(name, input.filename, type);
  }
}