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

82.6% Statements 38/46
66.66% Branches 8/12
100% Functions 1/1
82.6% Lines 38/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 1x 301x 301x     301x 301x 301x     301x 301x 301x 12x 12x 12x     12x 301x 301x 301x 14x 301x 2x 2x 285x 285x 285x 285x 301x     301x 1x
import {ExpressionNode} from "../../nodes";
import {TypedIdentifier, IdentifierMeta} from "../../types/_typed_identifier";
import {UnknownType, XGenericType} from "../../types/basic";
import {BasicTypes} from "../basic_types";
import * as Expressions from "../../2_statements/expressions";
import {Default} from "./default";
import {CGenericType} from "../../types/basic/cgeneric_type";
import {SyntaxInput} from "../_syntax_input";
import {AssertError} from "../assert_error";
 
export class MethodParam {
  public static runSyntax(node: ExpressionNode, input: SyntaxInput, meta: IdentifierMeta[]): TypedIdentifier {
    const name = node.findDirectExpression(Expressions.MethodParamName);
    if (name === undefined) {
      throw new AssertError("MethodParam, todo, handle pass by value and reference");
    }
 
    const type = node.findDirectExpression(Expressions.TypeParam);
    if (type === undefined) {
      throw new AssertError("MethodParam, unexpected structure");
    }
 
    const def = type.findDirectExpression(Expressions.Default);
    if (def) {
      try {
        Default.runSyntax(def, input);
      } catch (e) {
        return new TypedIdentifier(name.getFirstToken(), input.filename, new UnknownType(e.toString()), meta);
      }
    }
 
    const concat = type.concatTokens().toUpperCase();
    if (concat === "TYPE C" || concat.startsWith("TYPE C ")) {
      return new TypedIdentifier(name.getFirstToken(), input.filename, CGenericType.get(), meta);
    } else if (concat === "TYPE X" || concat.startsWith("TYPE X ")) {
      return new TypedIdentifier(name.getFirstToken(), input.filename, XGenericType.get(), meta);
    }
 
    const found = new BasicTypes(input).parseType(type);
    if (found) {
      return new TypedIdentifier(name.getFirstToken(), input.filename, found, meta);
    } else {
      return new TypedIdentifier(name.getFirstToken(), input.filename, new UnknownType("method param, todo"), meta);
    }
  }
}