staticAssert.h

/*
 * Copyright 2022 VMware, Inc.
 * SPDX-FileCopyrightText: 2022 VMware, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_STATICASSERT_H_
#define FRONTENDS_P4_STATICASSERT_H_
 
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/methodInstance.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "ir/ir.h"
 
namespace P4 {
 
using namespace literals;
 
const cstring staticAssertMethodName = "static_assert"_cs;

class DoStaticAssert : public Transform, public ResolutionContext {
    TypeMap *typeMap;
    bool removeStatement = false;
    bool isFinal = true;
 
 public:
    explicit DoStaticAssert(TypeMap *typeMap, bool isFinal) : typeMap(typeMap), isFinal(isFinal) {
        CHECK_NULL(typeMap);
        setName("DoStaticAssert");
    }
    const IR::Node *postorder(IR::MethodCallExpression *method) override {
        MethodInstance *mi = MethodInstance::resolve(method, this, typeMap);
        if (auto ef = mi->to<ExternFunction>()) {
            if (ef->method->name == staticAssertMethodName) {
                auto subst = ef->substitution;
                auto params = subst.getParametersInOrder();
                if (!params->moveNext()) {
                    ::P4::warning(ErrorType::WARN_INVALID, "static_assert with no arguments: %1%",
                                  method);
                    return method;
                }
                auto param = params->getCurrent();
                CHECK_NULL(param);
                auto arg = subst.lookup(param);
                CHECK_NULL(arg);
                if (auto bl = arg->expression->to<IR::BoolLiteral>()) {
                    if (!bl->value) {
                        std::string_view message = "static_assert failed";
                        if (params->moveNext()) {
                            param = params->getCurrent();
                            CHECK_NULL(param);
                            auto msg = subst.lookup(param);
                            CHECK_NULL(msg);
                            if (const auto *sl = msg->expression->to<IR::StringLiteral>()) {
                                message = sl->value;
                            }
                        }
                        ::P4::error(ErrorType::ERR_EXPECTED, "%1%: %2%", method, message);
                        return method;
                    }
                    if (getContext()->node->is<IR::MethodCallStatement>()) {
                        removeStatement = true;
                        return method;
                    }
                    return new IR::BoolLiteral(method->srcInfo, true);
                } else if (!isFinal) {
                    return method;
                } else {
                    ::P4::error(ErrorType::ERR_UNEXPECTED,
                                "Could not evaluate static_assert to a constant: %1%", arg);
                    return method;
                }
            }
        }
        return method;
    }
 
    const IR::Node *postorder(IR::MethodCallStatement *statement) override {
        if (removeStatement) {
            removeStatement = false;
            return nullptr;
        }
        return statement;
    }
};
 
class StaticAssert : public PassManager {
 public:
    explicit StaticAssert(TypeMap *typeMap, bool isFinal = true) {
        passes.push_back(new ReadOnlyTypeInference(typeMap));
        passes.push_back(new DoStaticAssert(typeMap, isFinal));
        setName("StaticAssert");
    }
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_STATICASSERT_H_ */