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 294x 294x     294x 294x 294x     294x 294x 294x 12x 12x 12x     12x 294x 294x 294x 14x 294x 2x 2x 278x 278x 278x 278x 294x     294x 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 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 {
        new 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, new CGenericType(), meta);
    } else if (concat === "TYPE X" || concat.startsWith("TYPE X ")) {
      return new TypedIdentifier(name.getFirstToken(), input.filename, new XGenericType(), 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);
    }
  }
}