Method Calculate

eval/eval/logic_step.cc:199–251

 private:
  void Calculate(ExecutionFrame* frame, absl::Span<const Value> args,
                 Value& result) const {
    bool bool_args[2];
    bool has_bool_args[2];

    for (size_t i = 0; i < args.size(); i++) {
      has_bool_args[i] = args[i]->Is<BoolValue>();
      if (has_bool_args[i]) {
        bool_args[i] = args[i].GetBool().NativeValue();
        if (bool_args[i] == shortcircuit_) {
          result = BoolValue{bool_args[i]};
          return;
        }
      }
    }

    if (has_bool_args[0] && has_bool_args[1]) {
      switch (op_type_) {
        case OpType::kAnd:
          result = BoolValue{bool_args[0] && bool_args[1]};
          return;
        case OpType::kOr:
          result = BoolValue{bool_args[0] || bool_args[1]};
          return;
      }
    }

    // As opposed to regular function, logical operation treat Unknowns with
    // higher precedence than error. This is due to the fact that after Unknown
    // is resolved to actual value, it may short-circuit and thus hide the
    // error.
    if (frame->enable_unknowns()) {
      // Check if unknown?
      absl::optional<cel::UnknownValue> unknown_set =
          frame->attribute_utility().MergeUnknowns(args);
      if (unknown_set.has_value()) {
        result = std::move(*unknown_set);
        return;
      }
    }

    if (args[0]->Is<cel::ErrorValue>()) {
      result = args[0];
      return;
    } else if (args[1]->Is<cel::ErrorValue>()) {
      result = args[1];
      return;
    }

    // Fallback.
    result = cel::ErrorValue(CreateNoMatchingOverloadError(
        (op_type_ == OpType::kOr) ? cel::builtin::kOr : cel::builtin::kAnd));
  }

  const OpType op_type_;
  bool shortcircuit_;