macro.cc

// Copyright 2021 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "parser/macro.h"

#include <cstddef>
#include <cstdint>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "common/operators.h"
#include "internal/lexis.h"
#include "internal/no_destructor.h"
#include "parser/source_factory.h"

namespace cel {

namespace {

using google::api::expr::v1alpha1::Expr;
using google::api::expr::common::CelOperator;

absl::StatusOr<Macro> MakeMacro(absl::string_view name, size_t argument_count,
                                MacroExpander expander,
                                bool is_receiver_style) {
  if (!internal::LexisIsIdentifier(name)) {
    return absl::InvalidArgumentError(absl::StrCat(
        "Macro function name \"", name, "\" is not a valid identifier"));
  }
  if (!expander) {
    return absl::InvalidArgumentError(
        absl::StrCat("Macro expander for \"", name, "\" cannot be empty"));
  }
  return Macro(name, argument_count, std::move(expander), is_receiver_style);
}

absl::StatusOr<Macro> MakeMacro(absl::string_view name, MacroExpander expander,
                                bool is_receiver_style) {
  if (!internal::LexisIsIdentifier(name)) {
    return absl::InvalidArgumentError(absl::StrCat(
        "Macro function name \"", name, "\" is not a valid identifier"));
  }
  if (!expander) {
    return absl::InvalidArgumentError(
        absl::StrCat("Macro expander for \"", name, "\" cannot be empty"));
  }
  return Macro(name, std::move(expander), is_receiver_style);
}

}  // namespace

absl::StatusOr<Macro> Macro::Global(absl::string_view name,
                                    size_t argument_count,
                                    MacroExpander expander) {
  return MakeMacro(name, argument_count, std::move(expander), false);
}

absl::StatusOr<Macro> Macro::GlobalVarArg(absl::string_view name,
                                          MacroExpander expander) {
  return MakeMacro(name, std::move(expander), false);
}

absl::StatusOr<Macro> Macro::Receiver(absl::string_view name,
                                      size_t argument_count,
                                      MacroExpander expander) {
  return MakeMacro(name, argument_count, std::move(expander), true);
}

absl::StatusOr<Macro> Macro::ReceiverVarArg(absl::string_view name,
                                            MacroExpander expander) {
  return MakeMacro(name, std::move(expander), true);
}

std::vector<Macro> Macro::AllMacros() {
  return {HasMacro(),  AllMacro(),  ExistsMacro(), ExistsOneMacro(),
          Map2Macro(), Map3Macro(), FilterMacro()};
}

Macro HasMacro() {
  // The macro "has(m.f)" which tests the presence of a field, avoiding the
  // need to specify the field as a string.
  static const internal::NoDestructor<Macro> macro(
      CelOperator::HAS, 1,
      [](const std::shared_ptr<SourceFactory>& sf, int64_t macro_id,
         const Expr& target, const std::vector<Expr>& args) {
        if (!args.empty() && args[0].has_select_expr()) {
          const auto& sel_expr = args[0].select_expr();
          return sf->NewPresenceTestForMacro(macro_id, sel_expr.operand(),
                                             sel_expr.field());
        } else {
          // error
          return Expr();
        }
      });
  return macro.get();
}

Macro AllMacro() {
  // The macro "range.all(var, predicate)", which is true if for all
  // elements in range the predicate holds.
  static const internal::NoDestructor<Macro> macro(
      CelOperator::ALL, 2,
      [](const std::shared_ptr<SourceFactory>& sf, int64_t macro_id,
         const Expr& target, const std::vector<Expr>& args) {
        return sf->NewQuantifierExprForMacro(SourceFactory::QUANTIFIER_ALL,
                                             macro_id, target, args);
      },
      /* receiver style*/ true);
  return macro.get();
}

Macro ExistsMacro() {
  // The macro "range.exists(var, predicate)", which is true if for at least
  // one element in range the predicate holds.
  static const internal::NoDestructor<Macro> macro(
      CelOperator::EXISTS, 2,
      [](const std::shared_ptr<SourceFactory>& sf, int64_t macro_id,
         const Expr& target, const std::vector<Expr>& args) {
        return sf->NewQuantifierExprForMacro(SourceFactory::QUANTIFIER_EXISTS,
                                             macro_id, target, args);
      },
      /* receiver style*/ true);
  return macro.get();
}

Macro ExistsOneMacro() {
  // The macro "range.exists_one(var, predicate)", which is true if for
  // exactly one element in range the predicate holds.
  static const internal::NoDestructor<Macro> macro(
      CelOperator::EXISTS_ONE, 2,
      [](const std::shared_ptr<SourceFactory>& sf, int64_t macro_id,
         const Expr& target, const std::vector<Expr>& args) {
        return sf->NewQuantifierExprForMacro(
            SourceFactory::QUANTIFIER_EXISTS_ONE, macro_id, target, args);
      },
      /* receiver style*/ true);
  return macro.get();
}

Macro Map2Macro() {
  // The macro "range.map(var, function)", applies the function to the vars
  // in the range.
  static const internal::NoDestructor<Macro> macro(
      CelOperator::MAP, 2,
      [](const std::shared_ptr<SourceFactory>& sf, int64_t macro_id,
         const Expr& target, const std::vector<Expr>& args) {
        return sf->NewMapForMacro(macro_id, target, args);
      },
      /* receiver style*/ true);
  return macro.get();
}

Macro Map3Macro() {
  // The macro "range.map(var, predicate, function)", applies the function
  // to the vars in the range for which the predicate holds true. The other
  // variables are filtered out.
  static const internal::NoDestructor<Macro> macro(
      CelOperator::MAP, 3,
      [](const std::shared_ptr<SourceFactory>& sf, int64_t macro_id,
         const Expr& target, const std::vector<Expr>& args) {
        return sf->NewMapForMacro(macro_id, target, args);
      },
      /* receiver style*/ true);
  return macro.get();
}

Macro FilterMacro() {
  // The macro "range.filter(var, predicate)", filters out the variables for
  // which the predicate is false.
  static const internal::NoDestructor<Macro> macro(
      CelOperator::FILTER, 2,
      [](const std::shared_ptr<SourceFactory>& sf, int64_t macro_id,
         const Expr& target, const std::vector<Expr>& args) {
        return sf->NewFilterExprForMacro(macro_id, target, args);
      },
      /* receiver style*/ true);
  return macro.get();
}

Macro OptMapMacro() {
  static const internal::NoDestructor<Macro> macro(
      "optMap", 2,
      [](const std::shared_ptr<SourceFactory>& sf, int64_t macro_id,
         const Expr& target, const std::vector<Expr>& args) -> Expr {
        if (args.size() != 2) {
          return sf->ReportError(args[0].id(), "optMap() requires 2 arguments");
        }
        if (!args[0].has_ident_expr()) {
          return sf->ReportError(
              args[0].id(),
              "optMap() variable name must be a simple identifier");
        }
        const auto& var_name = args[0].ident_expr().name();
        const auto& map_expr = args[1];

        std::vector<Expr> call_args;
        call_args.resize(3);
        call_args[0] =
            sf->NewReceiverCallForMacro(macro_id, "hasValue", target, {});
        auto iter_range = sf->NewListForMacro(macro_id, {});
        auto accu_init =
            sf->NewReceiverCallForMacro(macro_id, "value", target, {});
        auto condition = sf->NewLiteralBoolForMacro(macro_id, false);
        auto step = sf->NewIdentForMacro(macro_id, var_name);
        const auto& result = map_expr;
        auto fold = sf->FoldForMacro(macro_id, "#unused", iter_range, var_name,
                                     accu_init, condition, step, result);
        call_args[1] =
            sf->NewGlobalCallForMacro(macro_id, "optional.of", {fold});
        call_args[2] = sf->NewGlobalCallForMacro(macro_id, "optional.none", {});
        return sf->NewGlobalCallForMacro(macro_id, CelOperator::CONDITIONAL,
                                         call_args);
      },
      true);
  return macro.get();
}

Macro OptFlatMapMacro() {
  static const internal::NoDestructor<Macro> macro(
      "optFlatMap", 2,
      [](const std::shared_ptr<SourceFactory>& sf, int64_t macro_id,
         const Expr& target, const std::vector<Expr>& args) -> Expr {
        if (args.size() != 2) {
          return sf->ReportError(args[0].id(),
                                 "optFlatMap() requires 2 arguments");
        }
        if (!args[0].has_ident_expr()) {
          return sf->ReportError(
              args[0].id(),
              "optFlatMap() variable name must be a simple identifier");
        }
        const auto& var_name = args[0].ident_expr().name();
        const auto& map_expr = args[1];
        std::vector<Expr> call_args;
        call_args.resize(3);
        call_args[0] =
            sf->NewReceiverCallForMacro(macro_id, "hasValue", target, {});
        auto iter_range = sf->NewListForMacro(macro_id, {});
        auto accu_init =
            sf->NewReceiverCallForMacro(macro_id, "value", target, {});
        auto condition = sf->NewLiteralBoolForMacro(macro_id, false);
        auto step = sf->NewIdentForMacro(macro_id, var_name);
        const auto& result = map_expr;
        call_args[1] =
            sf->FoldForMacro(macro_id, "#unused", iter_range, var_name,
                             accu_init, condition, step, result);
        call_args[2] = sf->NewGlobalCallForMacro(macro_id, "optional.none", {});
        return sf->NewGlobalCallForMacro(macro_id, CelOperator::CONDITIONAL,
                                         call_args);
      },
      true);
  return macro.get();
}

}  // namespace cel