lib/typecheck/IdentifierResolver.h

Go to the documentation of this file.

//===-- typecheck/IdentifierResolver.h ------------------------ -*- C++ -*-===//
//
// This file is distributed under the MIT license. See LICENSE.txt for details.
//
// Copyright (C) 2009, Stephen Wilson
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_TYPECHECK_IDENTIFIERRESOLVER_HDR_GUARD
#define COMMA_TYPECHECK_IDENTIFIERRESOLVER_HDR_GUARD

#include "comma/ast/Homonym.h"
#include "llvm/ADT/SmallVector.h"

namespace comma {

class IdentifierResolver {

    typedef llvm::SmallVector<Decl*, 4>      DeclVector;
    typedef llvm::SmallVector<ValueDecl*, 4> ValueVector;

    // Do not implement.
    IdentifierResolver(const IdentifierResolver &);
    IdentifierResolver &operator=(const IdentifierResolver &);

public:
    IdentifierResolver() : directValue(0) { }

    bool resolve(IdentifierInfo *idInfo);

    void clear();

    bool filterOverloadsWRTArity(unsigned arity);

    bool filterProcedures();

    bool filterFunctionals();

    bool filterNullaryOverloads();

    unsigned numDirectOverloads() const { return directOverloads.size(); }

    unsigned numIndirectValues() const { return indirectValues.size(); }

    unsigned numIndirectOverloads() const { return indirectOverloads.size(); }

    unsigned numResolvedDecls() const;

    unsigned numOverloads() const {
        return numDirectOverloads() + numIndirectOverloads();
    }

    bool hasDirectValue() const { return directValue != 0; }

    bool hasDirectOverloads() const { return numDirectOverloads() != 0; }

    bool hasIndirectValues() const { return numIndirectValues() != 0; }

    bool hasIndirectOverloads() const { return numIndirectOverloads() != 0; }

    ValueDecl *getDirectValue() const { return directValue; }

    Decl *getDirectOverload(unsigned i) const {
        assert(i < numDirectOverloads() && "Index out of range!");
        return directOverloads[i];
    }

    ValueDecl *getIndirectValue(unsigned i) const {
        assert(i < numIndirectValues() && "Index out of range!");
        return indirectValues[i];
    }

    Decl *getIndirectOverload(unsigned i) const {
        assert(i < numIndirectOverloads() && "Index out of range!");
        return indirectOverloads[i];
    }

    typedef DeclVector::iterator  DirectOverloadIter;
    typedef DeclVector::iterator  IndirectOverloadIter;
    typedef ValueVector::iterator IndirectValueIter;

    DirectOverloadIter beginDirectOverloads() {
        return directOverloads.begin();
    }
    DirectOverloadIter endDirectOverloads()   {
        return directOverloads.end();
    }

    IndirectOverloadIter beginIndirectOverloads() {
        return indirectOverloads.begin();
    }
    IndirectOverloadIter endIndirectOverloads() {
        return indirectOverloads.end();
    }

    IndirectValueIter beginIndirectValues() {
        return indirectValues.begin();
    }

    IndirectValueIter endIndirectValues() {
        return indirectValues.end();
    }

private:
    ValueDecl  *directValue;
    DeclVector  directOverloads;
    ValueVector indirectValues;
    DeclVector  indirectOverloads;

    struct ArityPred {
        unsigned arity;
        ArityPred(unsigned arity) : arity(arity) { }
        bool operator()(const Decl* decl) const;
    };

    struct NullaryPred {
        bool operator()(const Decl* decl) const;
    };

    template <typename T>
    struct TypePred {
        bool operator()(const Decl* decl) const {
            return llvm::isa<T>(decl);
        }
    };

    template <typename Pred>
    bool filterOverloads(const Pred &pred);
};

template <typename Pred>
bool IdentifierResolver::filterOverloads(const Pred &pred)
{
    DirectOverloadIter directEnd =
        std::remove_if(beginDirectOverloads(), endDirectOverloads(), pred);

    IndirectOverloadIter indirectEnd =
        std::remove_if(beginIndirectOverloads(), endIndirectOverloads(), pred);

    bool result = ((directEnd != endDirectOverloads()) ||
                   (indirectEnd != endIndirectOverloads()));

    directOverloads.erase(directEnd, endDirectOverloads());
    indirectOverloads.erase(indirectEnd, endIndirectOverloads());

    return result;
}

} // End comma namespace.

#endif

---