typeSubstitution.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef FRONTENDS_P4_TYPECHECKING_TYPESUBSTITUTION_H_
#define FRONTENDS_P4_TYPECHECKING_TYPESUBSTITUTION_H_
 
#include <map>
#include <sstream>
 
#include "ir/ir.h"
#include "lib/exceptions.h"
 
namespace P4 {
 
/* Maps objects of type T to types. */
template <class T>
class TypeSubstitution : public IHasDbPrint {
 protected:
    ordered_map<T, const IR::Type *> binding;
 
 public:
    TypeSubstitution() = default;
    TypeSubstitution(const TypeSubstitution &other) = default;
    TypeSubstitution &operator=(const TypeSubstitution &other) = default;

    bool isIdentity() const { return binding.size() == 0; }
    const IR::Type *lookup(T t) const { return ::P4::get(binding, t); }
    const IR::Type *get(T t) const { return ::P4::get(binding, t); }
 
    bool containsKey(T key) const { return binding.find(key) != binding.end(); }
 
    /* This can fail if id is already bound.
     * @return true on success. */
    virtual bool setBinding(T id, const IR::Type *type) {
        CHECK_NULL(id);
        CHECK_NULL(type);
        auto it = binding.find(id);
        if (it != binding.end()) {
            if (it->second != type) return false;
            return true;
        }
        binding.emplace(id, type);
        return true;
    }
 
    void dbprint(std::ostream &out) const override {
        if (isIdentity()) out << "Empty substitution";
        bool first = true;
        for (auto it : binding) {
            if (!first) out << std::endl;
            out << dbp(it.first) << " -> " << dbp(it.second);
            first = false;
        }
    }
 
    void clear() { binding.clear(); }
};
 
class TypeVariableSubstitution final : public TypeSubstitution<const IR::ITypeVar *> {
 public:
    TypeVariableSubstitution() = default;
    TypeVariableSubstitution(const TypeVariableSubstitution &other) = default;
    bool setBindings(const IR::Node *errorLocation, const IR::TypeParameters *params,
                     const IR::Vector<IR::Type> *args);
    cstring compose(const IR::ITypeVar *var, const IR::Type *substitution);
    // In this variant of compose all variables in 'other' that are
    // assigned to are disjoint from all variables already in 'this'.
    void simpleCompose(const TypeVariableSubstitution *other);
    void debugValidate();
    bool setBinding(const IR::ITypeVar *id, const IR::Type *type) override {
        auto result = TypeSubstitution::setBinding(id, type);
        debugValidate();
        return result;
    }
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_TYPECHECKING_TYPESUBSTITUTION_H_ */