lib/typecheck/Resolver.h

Go to the documentation of this file.

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

#ifndef COMMA_TYPECHECK_RESOLVER_HDR_GUARD
#define COMMA_TYPECHECK_RESOLVER_HDR_GUARD

#include "comma/ast/Decl.h"

namespace comma {

class Homonym;
class Scope;

class Resolver {
    typedef llvm::SmallVector<Decl*, 4> DeclVector;
    typedef llvm::SmallVector<ValueDecl*, 4> ValueVector;
    typedef llvm::SmallVector<TypeDecl*, 4> TypeVector;
    typedef llvm::SmallVector<ExceptionDecl*, 4> ExceptionVector;

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

    // Private constructor for use by Scope.
    Resolver() : directDecl(0) { };

    void clear();

    friend class Scope;

public:
    bool resolve(IdentifierInfo *idInfo);

    bool filterOverloadsWRTArity(unsigned arity);

    bool filterProcedures();

    bool filterFunctionals();

    bool filterNullaryOverloads();

    IdentifierInfo *getIdInfo() const { return idInfo; }

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

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

    unsigned numIndirectTypes() const { return indirectTypes.size(); }

    unsigned numIndirectExceptions() const { return indirectExceptions.size(); }

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

    unsigned numResolvedDecls() const;

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

    bool hasDirectValue() const {
        return directDecl && llvm::isa<ValueDecl>(directDecl);
    }

    bool hasDirectType() const {
        return directDecl && llvm::isa<TypeDecl>(directDecl);
    }

    bool hasDirectCapsule() const {
        return directDecl && llvm::isa<ModelDecl>(directDecl);
    }

    bool hasDirectException() const {
        return directDecl && llvm::isa<ExceptionDecl>(directDecl);
    }

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

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

    bool hasIndirectTypes() const { return numIndirectTypes() != 0; }

    bool hasIndirectExceptions() const { return numIndirectExceptions() != 0; }

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

    bool hasVisibleIndirectValue() const {
        return (numIndirectValues() == 1 &&
                (!hasIndirectOverloads() && !hasIndirectTypes()));
    }

    bool hasVisibleIndirectType() const {
        return (numIndirectTypes() == 1 &&
                (!hasIndirectValues() && !hasIndirectOverloads()));
    }

    bool hasVisibleIndirectOverloads() const {
        return (hasIndirectOverloads() &&
                (!hasIndirectValues() && !hasIndirectTypes()));
    }

    ValueDecl *getDirectValue() const {
        return hasDirectValue() ? llvm::cast<ValueDecl>(directDecl) : 0;
    }

    TypeDecl *getDirectType() const {
        return hasDirectType() ? llvm::cast<TypeDecl>(directDecl) : 0;
    }

    ModelDecl *getDirectCapsule() const {
        return hasDirectCapsule() ? llvm::cast<ModelDecl>(directDecl) : 0;
    }

    ExceptionDecl *getDirectException() const {
        return hasDirectException() ? llvm::cast<ExceptionDecl>(directDecl) : 0;
    }

    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];
    }

    TypeDecl *getIndirectType(unsigned i) const {
        assert(i < numIndirectTypes() && "Index out of range!");
        return indirectTypes[i];
    }

    ExceptionDecl *getIndirectException(unsigned i) const {
        assert(i < numIndirectExceptions() && "Index out of range!");
        return indirectExceptions[i];
    }

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

    bool getVisibleSubroutines(
        llvm::SmallVectorImpl<SubroutineDecl*> &srDecls);

    typedef DeclVector::iterator direct_overload_iter;
    typedef DeclVector::iterator indirect_overload_iter;
    typedef ValueVector::iterator indirect_value_iter;
    typedef TypeVector::iterator indirect_type_iter;

    direct_overload_iter begin_direct_overloads() {
        return directOverloads.begin();
    }
    direct_overload_iter end_direct_overloads()   {
        return directOverloads.end();
    }

    indirect_overload_iter begin_indirect_overloads() {
        return indirectOverloads.begin();
    }
    indirect_overload_iter end_indirect_overloads() {
        return indirectOverloads.end();
    }

    indirect_value_iter begin_indirect_values() {
        return indirectValues.begin();
    }

    indirect_value_iter end_indirect_values() {
        return indirectValues.end();
    }

    indirect_type_iter begin_indirect_types() {
        return indirectTypes.begin();
    }

    indirect_type_iter end_indirect_types() {
        return indirectTypes.end();
    }

private:
    IdentifierInfo *idInfo;
    Decl *directDecl;
    DeclVector directOverloads;
    ValueVector indirectValues;
    TypeVector indirectTypes;
    DeclVector indirectOverloads;
    ExceptionVector indirectExceptions;

    bool resolveDirectDecls(Homonym *homonym);

    bool resolveIndirectDecls(Homonym *homonym);

    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) {
        direct_overload_iter directEnd = end_direct_overloads();
        direct_overload_iter directFilterEnd =
            std::remove_if(begin_direct_overloads(), directEnd, pred);

        indirect_overload_iter indirectEnd = end_indirect_overloads();
        indirect_overload_iter indirectFilterEnd =
            std::remove_if(begin_indirect_overloads(), indirectEnd, pred);

        directOverloads.erase(directFilterEnd, directEnd);
        indirectOverloads.erase(indirectFilterEnd, indirectEnd);

        return ((directEnd != directFilterEnd) ||
                (indirectEnd != indirectFilterEnd));
    }
};



} // end comma namespace.

#endif

---