Method evaluateFunctionCall

src/vimscript/expression/evaluate.ts:695–1804

(call: FunctionCallExpression)

  }

  private evaluateFunctionCall(call: FunctionCallExpression): Value {
    const assertPassed = () => {
      return int(0);
    };
    const assertFailed = (msg: string) => {
      // TODO: Include file & line
      this.errors.push(msg);
      return int(1);
    };

    const getpos = (arg: string) => {
      const pos: Position | undefined = (() => {
        if (arg === '.') {
          return this.vimState!.cursorStopPosition;
        } else if (arg === '$') {
          return new Position(this.vimState!.document.lineCount, 0);
        } else if (arg.startsWith("'") && arg.length === 2) {
          const mark = this.vimState!.historyTracker.getMark(arg[1]);
          return mark?.position;
        } else if (arg === 'w0') {
          return new Position(this.vimState!.editor.visibleRanges[0].start.line, 0);
        } else if (arg === 'w$') {
          return new Position(this.vimState!.editor.visibleRanges[0].end.line, 0);
        } else if (arg === 'v') {
          return this.vimState!.cursorStartPosition;
        }
        return undefined;
      })();
      return {
        bufnum: 0, // TODO
        lnum: (pos?.line ?? -1) + 1,
        col: (pos?.character ?? -1) + 1,
        off: 0,
      };
    };

    // See `:help non-zero-arg`
    const nonZeroArg = (arg: Value): boolean => {
      if (arg.type === 'number' && arg.value !== 0) {
        return true;
      } else if (arg.type === 'string' && arg.value.length !== 0) {
        return true;
      }
      return false;
    };

    const copy = (arg: Value, deep: boolean): Value => {
      switch (arg.type) {
        case 'list':
          return list(deep ? arg.items.map((item) => copy(item, true)) : arg.items);
        case 'dictionary':
          return dictionary(
            new Map(deep ? [...arg.items].map(([k, v]) => [k, copy(v, true)]) : arg.items),
          );
      }
      return arg;
    };