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

83.33% Statements 30/36
25% Branches 1/4
100% Functions 1/1
83.33% Lines 30/36

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 361x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 9x 9x 9x 9x     9x 9x 9x 9x 9x 9x 9x     9x     9x 9x 9x 9x 9x 1x
import {ExpressionNode, StatementNode} from "../../nodes";
import {CurrentScope} from "../_current_scope";
import {TypedIdentifier, IdentifierMeta} from "../../types/_typed_identifier";
import {Source} from "./source";
import * as Expressions from "../../2_statements/expressions";
import {AbstractType} from "../../types/basic/_abstract_type";
import {BasicTypes} from "../basic_types";
import {UnknownType} from "../../types/basic/unknown_type";
import {ReferenceType} from "../_reference";
 
export class InlineFieldDefinition {
  public runSyntax(node: ExpressionNode | StatementNode, scope: CurrentScope, filename: string): void {
    let type: AbstractType | TypedIdentifier | undefined = undefined;
 
    const field = node.findDirectExpression(Expressions.Field);
    if (field === undefined) {
      return;
    }
 
    const source = node.findDirectExpression(Expressions.Source);
    if (source) {
      type = new Source().runSyntax(source, scope, filename);
    }
    const typeName = node.findDirectExpression(Expressions.TypeName);
    if (typeName) {
      type = new BasicTypes(filename, scope).parseType(typeName);
    }
    if (type === undefined) {
      type = new UnknownType("InlineFieldDefinition, fallback");
    }
 
    const identifier = new TypedIdentifier(field.getFirstToken(), filename, type, [IdentifierMeta.InlineDefinition]);
    scope.addReference(field.getFirstToken(), identifier, ReferenceType.DataWriteReference, filename);
    scope.addIdentifier(identifier);
  }
}