include/comma/ast/Decl.h

Go to the documentation of this file.

//===-- ast/Decl.h -------------------------------------------- -*- C++ -*-===//
//
// This file is distributed under the MIT license.  See LICENSE.txt for details.
//
// Copyright (C) 2008-2010, Stephen Wilson
//
//===----------------------------------------------------------------------===//

#ifndef COMMA_AST_DECL_HDR_GUARD
#define COMMA_AST_DECL_HDR_GUARD

#include "comma/ast/AstBase.h"
#include "comma/ast/DeclRegion.h"
#include "comma/ast/Pragma.h"
#include "comma/ast/SignatureSet.h"
#include "comma/ast/Type.h"
#include "comma/basic/ParameterModes.h"
#include "comma/basic/Pragmas.h"
#include "comma/basic/PrimitiveOps.h"

#include "llvm/ADT/ilist.h"
#include "llvm/ADT/FoldingSet.h"
#include "llvm/ADT/PointerIntPair.h"
#include "llvm/ADT/PointerUnion.h"

namespace comma {

//===----------------------------------------------------------------------===//
// Decl.
//
// Decl nodes represent declarations within a Comma program.
class Decl : public Ast {

public:
    virtual ~Decl() { };

    // Returns the IdentifierInfo object associated with this decl, or NULL if
    // this is an anonymous decl.
    IdentifierInfo *getIdInfo() const { return idInfo; }

    // Returns the name of this decl as a c string, or NULL if this is an
    // anonymous decl.
    const char *getString() const {
        return idInfo ? idInfo->getString() : 0;
    }

    // Returns the location associated with this decl.
    Location getLocation() const { return location; }

    // Sets the declarative region for this decl.  This function can only be
    // called once to initialize the decl.
    void setDeclRegion(DeclRegion *region) {
        assert(context == 0 && "Cannot reset a decl's declarative region!");
        context = region;
    }

    // Returns the declarative region for this decl.  Sometimes decls are
    // created before their associated regions exist, so this method may return
    // null.
    DeclRegion *getDeclRegion() { return context; }
    const DeclRegion *getDeclRegion() const { return context; }

    // Returns true if this decl was declared in the given region.
    bool isDeclaredIn(const DeclRegion *region) const {
        return region == context;
    }

    DeclRegion *asDeclRegion();

    Decl *getOrigin() { return origin; }
    const Decl *getOrigin() const { return origin; }

    bool hasOrigin() const { return origin != 0; }

    void setOrigin(Decl *decl) {
        assert(decl->getKind() == this->getKind() && "Kind mismatch!");
        origin = decl;
    }

    Decl *resolveOrigin();
    const Decl *resolveOrigin() const {
        return const_cast<Decl*>(this)->resolveOrigin();
    }

    bool isImmediate() const { return !hasOrigin(); }

    // Support isa and dyn_cast.
    static bool classof(const Decl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->denotesDecl();
    }

protected:
    Decl(AstKind kind, IdentifierInfo *info = 0, Location loc = 0,
         DeclRegion *region = 0)
        : Ast(kind),
          idInfo(info),
          location(loc),
          context(region),
          origin(0) {
        assert(this->denotesDecl());
        deletable = false;
    }

    IdentifierInfo *idInfo;
    Location location;
    DeclRegion *context;
    Decl *origin;
};

//===----------------------------------------------------------------------===//
// ImportDecl
//
// Represents import declarations.
class ImportDecl : public Decl {

public:
    ImportDecl(Type *target, Location loc)
        : Decl(AST_ImportDecl, 0, loc),
          targetType(target) { }

    Type *getImportedType() { return targetType; }
    const Type *getImportedType() const { return targetType; }

    static bool classof(const ImportDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ImportDecl;
    }

private:
    Type *targetType;
};

//===----------------------------------------------------------------------===//
// ExceptionDecl
//
class ExceptionDecl : public Decl {

public:
    enum ExceptionKind {
        User,                   
        Program_Error,          
        Constraint_Error,       
        Assertion_Error         
    };

    ExceptionKind getID() const { return static_cast<ExceptionKind>(bits); }

    // Support isa/dyn_cast.
    static bool classof(const ExceptionDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ExceptionDecl;
    }

private:
    ExceptionDecl(ExceptionKind ID, IdentifierInfo *name, Location loc,
                  DeclRegion *region)
        : Decl(AST_ExceptionDecl, name, loc, region) {
        bits = ID;
    }

    // Only AstResource is allowed to construct ExceptionDecl's.
    friend class AstResource;
};

//===----------------------------------------------------------------------===//
// ModelDecl
//
// Models represent those attributes and characteristics which both signatures
// and domains share.
class ModelDecl : public Decl {

public:
    virtual ~ModelDecl();

    bool isParameterized() const {
        return kind == AST_VarietyDecl || kind == AST_FunctorDecl;
    }

    virtual unsigned getArity() const;





    const AbstractDomainDecl *getFormalDecl(unsigned i) const {
        return const_cast<ModelDecl*>(this)->getFormalDecl(i);
    }
    virtual AbstractDomainDecl *getFormalDecl(unsigned i);

    unsigned getFormalIndex(const AbstractDomainDecl *ADDecl) const;



    const DomainType *getFormalType(unsigned i) const {
        return const_cast<ModelDecl*>(this)->getFormalType(i);
    }
    DomainType *getFormalType(unsigned i);

    SigInstanceDecl *getFormalSignature(unsigned i) const;

    IdentifierInfo *getFormalIdInfo(unsigned i) const;

    int getKeywordIndex(IdentifierInfo *keyword) const;

    PercentDecl *getPercent() const { return percent; }


    const DomainType *getPercentType() const;
    DomainType *getPercentType();

    const SignatureSet &getSignatureSet() const;

    bool addDirectSignature(SigInstanceDecl *signature);

    AstResource &getAstResource() { return resource; }

    // Support isa and dyn_cast.
    static bool classof(const ModelDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->denotesModelDecl();
    }

protected:
    ModelDecl(AstResource &resource,
              AstKind kind, IdentifierInfo *name, Location loc);

    // The unique PercentDecl representing this model.
    PercentDecl *percent;

    // The AstResource we use to construct sub-nodes.
    AstResource &resource;
};

//===----------------------------------------------------------------------===//
// Sigoid
//
// This is the common base class for "signature like" objects: i.e. signatures
// and varieties.
class Sigoid : public ModelDecl {

public:
    // Creates a named signature.
    Sigoid(AstResource &resource,
           AstKind kind, IdentifierInfo *name, Location loc)
        : ModelDecl(resource, kind, name, loc) { }

    virtual ~Sigoid() { }

    // If this is a SignatureDecl, returns this cast to the refined type,
    // otherwise returns NULL.
    SignatureDecl *getSignature();

    // If this is a VarietyDecl, returns this cast to the refined type,
    // otherwise returns NULL.
    VarietyDecl *getVariety();

    static bool classof(const Sigoid *node) { return true; }
    static bool classof(const Ast *node) {
        AstKind kind = node->getKind();
        return kind == AST_SignatureDecl || kind == AST_VarietyDecl;
    }
};

//===----------------------------------------------------------------------===//
// SignatureDecl
//
// This class defines (non-parameterized) signature declarations.
class SignatureDecl : public Sigoid {

public:
    // Creates a named signature.
    SignatureDecl(AstResource &resource,
                  IdentifierInfo *name, const Location &loc);

    SigInstanceDecl *getInstance() { return theInstance; }
    const SigInstanceDecl *getInstance() const { return theInstance; }

    // Support for isa and dyn_cast.
    static bool classof(const SignatureDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_SignatureDecl;
    }

private:
    // The unique instance decl representing this signature.
    SigInstanceDecl *theInstance;
};

//===----------------------------------------------------------------------===//
// VarietyDecl
//
// Repesentation of parameterized signatures.
class VarietyDecl : public Sigoid {

public:
    // Creates a VarietyDecl with the given name, location of definition, and
    // list of AbstractDomainTypes which serve as the formal parameters.
    VarietyDecl(AstResource &resource,
                IdentifierInfo *name, Location loc,
                AbstractDomainDecl **formals, unsigned arity);



    SigInstanceDecl *getInstance(DomainTypeDecl **args, unsigned numArgs);
    const SigInstanceDecl *getInstance(DomainTypeDecl **args,
                                       unsigned numArgs) const {
        return const_cast<VarietyDecl*>(this)->getInstance(args, numArgs);
    }

    int getKeywordIndex(IdentifierInfo *keyword) const;

    unsigned getArity() const { return arity; }

    AbstractDomainDecl *getFormalDecl(unsigned i) {
        assert(i < arity && "Index out of range!");
        return formalDecls[i];
    }

    typedef llvm::FoldingSet<SigInstanceDecl>::iterator instance_iterator;
    instance_iterator begin_instances() { return instances.begin(); }
    instance_iterator end_instances() { return instances.end(); }

    // Support for isa and dyn_cast.
    static bool classof(const VarietyDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_VarietyDecl;
    }

private:
    mutable llvm::FoldingSet<SigInstanceDecl>  instances;

    unsigned arity;                   
    AbstractDomainDecl **formalDecls; 
};


//===----------------------------------------------------------------------===//
// Domoid
//
// This is the common base class for domain-like objects: i.e. domains
// and functors.
class Domoid : public ModelDecl {

public:
    virtual ~Domoid() { }

    // Returns non-null if this domoid is a DomainDecl.
    DomainDecl *getDomain();

    // Returns non-null if this domoid is a FunctorDecl.
    FunctorDecl *getFunctor();

    // Once a domoid has been constructed (all declarations and sub-components
    // have been registered) this method must be called to ensure all internal
    // state of the node is consistent.
    virtual void finalize() = 0;

    // Returns true if this domoid has been finalized.
    virtual bool isFinalized() const = 0;


    virtual AddDecl *getImplementation() = 0;
    const AddDecl *getImplementation() const {
        return const_cast<Domoid*>(this)->getImplementation();
    }

    static bool classof(const Domoid *node) { return true; }
    static bool classof(const Ast *node) {
        AstKind kind = node->getKind();
        return (kind == AST_DomainDecl or kind == AST_FunctorDecl);
    }

protected:
    Domoid(AstResource &resource,
           AstKind kind, IdentifierInfo *idInfo, Location loc);
};

//===----------------------------------------------------------------------===//
// AddDecl
//
class AddDecl : public Decl, public DeclRegion {

public:
    AddDecl(PercentDecl *percent);

    bool implementsDomain() const;

    bool implementsFunctor() const;

    // @{
    const Domoid *getImplementedDomoid() const {
        return const_cast<AddDecl*>(this)->getImplementedDomoid();
    }
    Domoid *getImplementedDomoid();



    const DomainDecl *getImplementedDomain() const {
        return const_cast<AddDecl*>(this)->getImplementedDomain();
    }
    DomainDecl *getImplementedDomain();



    const FunctorDecl *getImplementedFunctor() const {
        return const_cast<AddDecl*>(this)->getImplementedFunctor();
    }
    FunctorDecl *getImplementedFunctor();

    bool hasCarrier() const { return carrier != 0; }

    void setCarrier(CarrierDecl *carrier) {
        assert(!hasCarrier() && "Cannot reset carrier declaration!");
        this->carrier = carrier;
    }



    CarrierDecl *getCarrier() { return carrier; }
    const CarrierDecl *getCarrier() const { return carrier; }

    // Support isa/dyn_cast.
    static bool classof(const AddDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_AddDecl;
    }

private:
    // Non-null if a carrier has been associated with this declaration.
    CarrierDecl *carrier;
};

//===----------------------------------------------------------------------===//
// DomainDecl
//
class DomainDecl : public Domoid {

public:
    DomainDecl(AstResource &resource,
               IdentifierInfo *name, const Location &loc);

    DomainInstanceDecl *getInstance();
    const DomainInstanceDecl *getInstance() const {
        return const_cast<DomainDecl*>(this)->getInstance();
    }

    void finalize();

    bool isFinalized() const;

    AddDecl *getImplementation() { return implementation; }

    // Support for isa and dyn_cast.
    static bool classof(const DomainDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_DomainDecl;
    }

private:
    DomainInstanceDecl *instance;
    AddDecl *implementation;
};

//===----------------------------------------------------------------------===//
// FunctorDecl
//
// Representation of parameterized domains.
class FunctorDecl : public Domoid {

public:
    FunctorDecl(AstResource &resource,
                IdentifierInfo *name, Location loc,
                AbstractDomainDecl **formals, unsigned arity);

    // Returns an instance declaration corresponding to this functor applied
    // over the given set of arguments.  Such instance declarations are
    // memoized, and for a given set of arguments this method always returns the
    // same declaration node.
    DomainInstanceDecl *getInstance(DomainTypeDecl **args, unsigned numArgs);

    const DomainInstanceDecl *getInstance(DomainTypeDecl **args,
                                          unsigned numArgs) const {
        FunctorDecl *fdecl = const_cast<FunctorDecl*>(this);
        return fdecl->getInstance(args, numArgs);
    }

    // Returns the AddDecl which implements this functor.
    AddDecl *getImplementation() { return implementation; }

    unsigned getArity() const { return arity; }

    AbstractDomainDecl *getFormalDecl(unsigned i) {
        assert(i < arity && "Index out of range!");
        return formalDecls[i];
    }

    void finalize();

    bool isFinalized() const;

    // Support for isa and dyn_cast.
    static bool classof(const FunctorDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_FunctorDecl;
    }

private:
    typedef llvm::FoldingSet<DomainInstanceDecl> InstanceSet;
    mutable InstanceSet instances;

    unsigned arity;                   
    AbstractDomainDecl **formalDecls; 
    AddDecl *implementation;          
};

//===----------------------------------------------------------------------===//
// SigInstanceDecl

class SigInstanceDecl : public Decl, public llvm::FoldingSetNode {

public:
    Sigoid *getSigoid() { return underlyingSigoid; }
    const Sigoid *getSigoid() const { return underlyingSigoid; }

    SignatureDecl *getSignature() const;

    VarietyDecl *getVariety() const;

    bool isParameterized() const { return getVariety() != 0; }

    unsigned getArity() const;

    DomainTypeDecl *getActualParam(unsigned n) const {
        assert(isParameterized() &&
               "Cannot fetch parameter from non-parameterized type!");
        assert(n < getArity() && "Parameter index out of range!");
        return arguments[n];
    }

    DomainType *getActualParamType(unsigned n) const;

    typedef DomainTypeDecl **arg_iterator;
    arg_iterator beginArguments() const { return arguments; }
    arg_iterator endArguments() const { return &arguments[getArity()]; }

    void Profile(llvm::FoldingSetNodeID &id) {
        Profile(id, &arguments[0], getArity());
    }

    static bool classof(const SigInstanceDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_SigInstanceDecl;
    }

private:
    friend class SignatureDecl;
    friend class VarietyDecl;

    SigInstanceDecl(SignatureDecl *decl);

    SigInstanceDecl(VarietyDecl *decl, DomainTypeDecl **args, unsigned numArgs);

    // Called by VarietyDecl when memoizing.
    static void
    Profile(llvm::FoldingSetNodeID &id,
            DomainTypeDecl **args, unsigned numArgs);

    // The Sigoid supporing this type.
    Sigoid *underlyingSigoid;

    // If the supporting declaration is a variety, then this array contains the
    // actual arguments defining this instance.
    DomainTypeDecl **arguments;
};

//===----------------------------------------------------------------------===//
// ValueDecl
//
// This class is intentionally generic.  It will become a virtual base for a
// more extensive hierarchy of value declarations later on.
class ValueDecl : public Decl {

protected:
    ValueDecl(AstKind kind, IdentifierInfo *name, Type *type, Location loc)
        : Decl(kind, name, loc),
          correspondingType(type) {
        assert(this->denotesValueDecl());
    }

public:

    const Type *getType() const { return correspondingType; }
    Type *getType() { return correspondingType; }

    static bool classof(const ValueDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->denotesValueDecl();
    }

protected:
    Type *correspondingType;
};

//===----------------------------------------------------------------------===//
// ParamValueDecl
//
// Declaration nodes which represent the formal parameters of a function or
// procedure.  These nodes are owned by the function declaration to which they
// are attached.
class ParamValueDecl : public ValueDecl {

public:
    ParamValueDecl(IdentifierInfo *name,
                   Type *type,
                   PM::ParameterMode mode,
                   Location loc)
        : ValueDecl(AST_ParamValueDecl, name, type, loc) {
        // Store the mode for this decl in the bit field provided by our
        // base Ast instance.
        //
        // FIXME: This is bad practice, really.  But the bits are available so
        // we use them.  Eventually, a better interface/convention should be
        // established to help protect against the bit field being trashed, or
        // this data should be moved into the class itself.
        bits = mode;
    }

    bool parameterModeSpecified() const;

    PM::ParameterMode getParameterMode() const;

    PM::ParameterMode getExplicitParameterMode() const;

    void setParameterMode(PM::ParameterMode mode);

    static bool classof(const ParamValueDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ParamValueDecl;
    }
};

//===----------------------------------------------------------------------===//
// ObjectDecl
//
// Object declarations denote objects of a given type.  They may optionally be
// associated with an initial value given by an expression.
class ObjectDecl : public ValueDecl {

public:
    ObjectDecl(IdentifierInfo *name,
               Type           *type,
               Location        loc,
               Expr           *init = 0)
        : ValueDecl(AST_ObjectDecl, name, type, loc),
          initialization(init) { }

    // Returns true if this object declaration is associated with an
    // initialization expression.
    bool hasInitializer() const { return initialization != 0; }

    // Returns the initialization expression associated with this object decl,
    // or NULL if there is no such association.
    Expr *getInitializer() const { return initialization; }

    // Sets the initialization expression for this declaration.  Owership of the
    // expression is passed to the declaration.
    void setInitializer(Expr *init) { initialization = init; }

    // Support isa and dyn_cast.
    static bool classof(const ObjectDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ObjectDecl;
    }

private:
    Expr *initialization;
};

//===----------------------------------------------------------------------===//
// RenamedObjectDecl
//
class RenamedObjectDecl : public ValueDecl {

public:
    RenamedObjectDecl(IdentifierInfo *name, Type *type, Location loc,
                      Expr *expr)
        : ValueDecl(AST_RenamedObjectDecl, name, type, loc),
          renamedExpr(expr) { }


    const Expr *getRenamedExpr() const { return renamedExpr; }
    Expr *getRenamedExpr() { return renamedExpr; }

    void setRenamedExpr(Expr *expr) { renamedExpr = expr; }

    // Support isa/dyn_cast.
    static bool classof(const RenamedObjectDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_RenamedObjectDecl;
    }

private:
    Expr *renamedExpr;
};

//===----------------------------------------------------------------------===//
// LoopDecl
//
class LoopDecl : public ValueDecl {

public:
    LoopDecl(IdentifierInfo *name, DiscreteType *type, Location loc)
        : ValueDecl(AST_LoopDecl, name, type, loc) { }


    const DiscreteType *getType() const {
        return llvm::cast<DiscreteType>(ValueDecl::getType());
    }
    DiscreteType *getType() {
        return llvm::cast<DiscreteType>(ValueDecl::getType());
    }

    // Support isa/dyn_cast.
    static bool classof(const LoopDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_LoopDecl;
    }
};

//===----------------------------------------------------------------------===//
// SubroutineDecl
//
// Base class for representing procedures and functions.
class SubroutineDecl : public Decl, public DeclRegion {

public:
    virtual ~SubroutineDecl();


    virtual SubroutineType *getType() = 0;
    virtual const SubroutineType *getType() const = 0;

    unsigned getArity() const { return numParameters; }

    ParamValueDecl *getParam(unsigned i) {
        assert(i < getArity() && "Index out of range!");
        return parameters[i];
    }

    const ParamValueDecl *getParam(unsigned i) const {
        assert(i < getArity() && "Index out of range!");
        return parameters[i];
    }

    Type *getParamType(unsigned i) const {
        return getType()->getArgType(i);
    }

    PM::ParameterMode getParamMode(unsigned i) const {
        return getParam(i)->getParameterMode();
    }

    PM::ParameterMode getExplicitParamMode(unsigned i) const {
        return getParam(i)->getExplicitParameterMode();
    }

    IdentifierInfo *getParamKeyword(unsigned i) const {
        return getParam(i)->getIdInfo();
    }

    int getKeywordIndex(IdentifierInfo *key) const;

    int getKeywordIndex(KeywordSelector *key) const;

    bool keywordsMatch(const SubroutineDecl *SRDecl) const;

    bool paramModesMatch(const SubroutineDecl *SRDecl) const;


    SubroutineDecl *getOrigin() {
        return llvm::cast<SubroutineDecl>(Decl::getOrigin());
    }
    const SubroutineDecl *getOrigin() const {
        return llvm::cast<SubroutineDecl>(Decl::getOrigin());
    }


    SubroutineDecl *resolveOrigin() {
        return llvm::cast<SubroutineDecl>(Decl::resolveOrigin());
    }
    const SubroutineDecl *resolveOrigin() const {
        return llvm::cast<SubroutineDecl>(Decl::resolveOrigin());
    }

    typedef ParamValueDecl **param_iterator;
    param_iterator begin_params() { return parameters; }
    param_iterator end_params() { return parameters + getArity(); }

    typedef ParamValueDecl *const *const_param_iterator;
    const_param_iterator begin_params() const { return parameters; }
    const_param_iterator end_params() const { return parameters + getArity(); }

    void setDefiningDeclaration(SubroutineDecl *routineDecl);

    bool hasDefiningDeclaration() const {
        return getDefiningDeclaration() != 0;
    }

    SubroutineDecl *getDefiningDeclaration() {
        if (declarationLink.getInt() == DEFINITION_TAG)
            return declarationLink.getPointer();
        return 0;
    }

    const SubroutineDecl *getDefiningDeclaration() const {
        if (declarationLink.getInt() == DEFINITION_TAG)
            return declarationLink.getPointer();
        return 0;
    }

    SubroutineDecl *getForwardDeclaration() {
        if (declarationLink.getInt() == FORWARD_TAG)
            return declarationLink.getPointer();
        return 0;
    }

    const SubroutineDecl *getForwardDeclaration() const {
        if (declarationLink.getInt() == FORWARD_TAG)
            return declarationLink.getPointer();
        return 0;
    }

    const bool hasForwardDeclaration() const {
        return getForwardDeclaration() != 0;
    }

    const bool isForwardDeclaration() const {
        return getDefiningDeclaration() != 0;
    }

    bool hasBody() const;
    void setBody(BlockStmt *block) { body = block; }
    BlockStmt *getBody();
    const BlockStmt *getBody() const {
        return const_cast<SubroutineDecl*>(this)->getBody();
    }

    bool isPrimitive() const { return opID != PO::NotPrimitive; }

    void setAsPrimitive(PO::PrimitiveID ID) { opID = ID; }

    PO::PrimitiveID getPrimitiveID() const { return opID; }

    void attachPragma(Pragma *P) { pragmas.push_front(P); }

    const Pragma *findPragma(pragma::PragmaID ID) const;

    bool hasPragma(pragma::PragmaID ID) const { return findPragma(ID) != 0; }


    typedef llvm::iplist<Pragma>::iterator pragma_iterator;
    pragma_iterator begin_pragmas() { return pragmas.begin(); }
    pragma_iterator end_pragmas() { return pragmas.end(); }

    typedef llvm::iplist<Pragma>::const_iterator const_pragma_iterator;
    const_pragma_iterator begin_pragmas() const { return pragmas.begin(); }
    const_pragma_iterator end_pragmas() const { return pragmas.end(); }

    // Support for isa and dyn_cast.
    static bool classof(const SubroutineDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->denotesSubroutineDecl();
    }

protected:
    // Subroutine decls take ownership of any ParamValueDecls supplied (but not
    // the array they are passed in).
    SubroutineDecl(AstKind kind, IdentifierInfo *name, Location loc,
                   ParamValueDecl **params, unsigned numParams,
                   DeclRegion *parent);

    SubroutineDecl(AstKind kind, IdentifierInfo *name, Location loc,
                   IdentifierInfo **keywords, SubroutineType *type,
                   DeclRegion *parent);

    SubroutineDecl(AstKind kind, IdentifierInfo *name, Location loc,
                   DeclRegion *parent);

    PO::PrimitiveID opID : 8;   

    unsigned numParameters;
    ParamValueDecl **parameters;
    BlockStmt *body;

    enum DeclLinkTag {
        FORWARD_TAG,            // Link points to a forward declaration.
        DEFINITION_TAG          // Link points to a completion.
    };

    llvm::PointerIntPair<SubroutineDecl*, 1, DeclLinkTag> declarationLink;
    llvm::iplist<Pragma> pragmas;
};

//===----------------------------------------------------------------------===//
// ProcedureDecl
//
// Representation of procedure declarations.
class ProcedureDecl : public SubroutineDecl {

public:
    ProcedureDecl(AstResource &resource,
                  IdentifierInfo *name, Location loc,
                  ParamValueDecl **params, unsigned numParams,
                  DeclRegion *parent);

    ProcedureDecl(IdentifierInfo *name, Location loc,
                  IdentifierInfo **keywords, ProcedureType *type,
                  DeclRegion *parent)
        : SubroutineDecl(AST_ProcedureDecl, name, loc, keywords, type, parent),
          correspondingType(type) { }

    ProcedureDecl(IdentifierInfo *name, Location loc,
                  ProcedureType *type, DeclRegion *parent);


    const ProcedureType *getType() const { return correspondingType; }
    ProcedureType *getType() { return correspondingType; }

    ProcedureDecl *getDefiningDeclaration() {
        SubroutineDecl *definition = SubroutineDecl::getDefiningDeclaration();
        return llvm::cast_or_null<ProcedureDecl>(definition);
    }

    const ProcedureDecl *getDefiningDeclaration() const {
        const SubroutineDecl *definition;
        definition = SubroutineDecl::getDefiningDeclaration();
        return llvm::cast_or_null<ProcedureDecl>(definition);
    }

    ProcedureDecl *getForwardDeclaration() {
        SubroutineDecl *forward = SubroutineDecl::getForwardDeclaration();
        return llvm::cast_or_null<ProcedureDecl>(forward);
    }

    const ProcedureDecl *getForwardDeclaration() const {
        const SubroutineDecl *forward;
        forward = SubroutineDecl::getForwardDeclaration();
        return llvm::cast_or_null<ProcedureDecl>(forward);
    }

    // Support for isa and dyn_cast.
    static bool classof(const ProcedureDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ProcedureDecl;
    }

private:
    ProcedureType *correspondingType;
};

//===----------------------------------------------------------------------===//
// FunctionDecl
//
// Representation of function declarations.
class FunctionDecl : public SubroutineDecl {

public:
    FunctionDecl(AstResource &resource,
                 IdentifierInfo *name, Location loc,
                 ParamValueDecl **params, unsigned numParams,
                 Type *returnType, DeclRegion *parent);

    FunctionDecl(IdentifierInfo *name, Location loc,
                 IdentifierInfo **keywords, FunctionType *type,
                 DeclRegion *parent)
        : SubroutineDecl(AST_FunctionDecl, name, loc, keywords, type, parent),
          correspondingType(type) { }


    const FunctionType *getType() const { return correspondingType; }
    FunctionType *getType() { return correspondingType; }

    FunctionDecl *getDefiningDeclaration() {
        SubroutineDecl *definition = SubroutineDecl::getDefiningDeclaration();
        return llvm::cast_or_null<FunctionDecl>(definition);
    }

    const FunctionDecl *getDefiningDeclaration() const {
        const SubroutineDecl *definition;
        definition = SubroutineDecl::getDefiningDeclaration();
        return llvm::cast_or_null<FunctionDecl>(definition);
    }

    FunctionDecl *getForwardDeclaration() {
        SubroutineDecl *forward = SubroutineDecl::getForwardDeclaration();
        return llvm::cast_or_null<FunctionDecl>(forward);
    }

    const FunctionDecl *getForwardDeclaration() const {
        const SubroutineDecl *forward;
        forward = SubroutineDecl::getForwardDeclaration();
        return llvm::cast_or_null<FunctionDecl>(forward);
    }


    const Type *getReturnType() const { return getType()->getReturnType(); }
    Type *getReturnType() { return getType()->getReturnType(); }

    // Support for isa and dyn_cast.
    static bool classof(const FunctionDecl *node) { return true; }
    static bool classof(const Ast *node) { return denotesFunctionDecl(node); }

protected:
    // Constructor for use by EnumLiteral.
    FunctionDecl(AstKind kind, AstResource &resource,
                 IdentifierInfo *name, Location loc,
                 EnumerationType *returnType, DeclRegion *parent);

    // Constructor for use by FunctionAttribDecl.
    FunctionDecl(AstKind kind, IdentifierInfo *name, Location loc,
                 IdentifierInfo **keywords, FunctionType *type,
                 DeclRegion *parent)
        : SubroutineDecl(kind, name, loc, keywords, type, parent),
          correspondingType(type) { }

private:
    FunctionType *correspondingType;

    void initializeCorrespondingType(AstResource &resource, Type *returnType);

    static bool denotesFunctionDecl(const Ast *node) {
        AstKind kind = node->getKind();
        return (kind == AST_FunctionDecl || kind == AST_EnumLiteral ||
                kind == AST_PosAD || kind == AST_ValAD);
    }
};

//===----------------------------------------------------------------------===//
// EnumLiteral
//
// Instances of this class represent the elements of an EnumerationDecl.
class EnumLiteral : public FunctionDecl {

public:
    unsigned getIndex() const { return index; }


    const EnumerationType *getReturnType() const {
        return llvm::cast<EnumerationType>(FunctionDecl::getReturnType());
    }
    EnumerationType *getReturnType() {
        return llvm::cast<EnumerationType>(FunctionDecl::getReturnType());
    }


    EnumerationDecl *getDeclRegion() {
        return llvm::cast<EnumerationDecl>(context);
    }
    const EnumerationDecl *getDeclRegion() const {
        return llvm::cast<EnumerationDecl>(context);
    }

    // Support isa/dyn_cast.
    static bool classof(const EnumLiteral *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_EnumLiteral;
    }

private:
    // Enumeration literals are constructed by their containing enumeration decl
    // node.
    EnumLiteral(AstResource &resource, IdentifierInfo *name, Location loc,
                unsigned index, EnumerationType *type, EnumerationDecl *parent);

    friend class EnumerationDecl;

    unsigned index;
};

//===----------------------------------------------------------------------===//
// TypeDecl
//
// All nodes which declare types inherit from this class.
class TypeDecl : public Decl {

public:

    const PrimaryType *getType() const { return CorrespondingType; }
    PrimaryType *getType() { return CorrespondingType; }

    static bool classof(const TypeDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->denotesTypeDecl();
    }

protected:
    // Constructs a TypeDecl node when a type is immediately available.
    TypeDecl(AstKind kind, IdentifierInfo *name, PrimaryType *type,
             Location loc, DeclRegion *region = 0)
        : Decl(kind, name, loc, region),
          CorrespondingType(type) {
        assert(this->denotesTypeDecl());
    }

    // Constructs a TypeDecl node when a type is not immediately available.
    // Users of this constructor must set the corresponding type.
    TypeDecl(AstKind kind, IdentifierInfo *name, Location loc,
             DeclRegion *region = 0)
        : Decl(kind, name, loc, region),
          CorrespondingType(0) {
        assert(this->denotesTypeDecl());
    }

    PrimaryType *CorrespondingType;
};

//===----------------------------------------------------------------------===//
// IncompleteTypeDecl
//
class IncompleteTypeDecl : public TypeDecl {

public:
    bool hasCompletion() const { return completion != 0; }

    void setCompletion(TypeDecl *decl) { completion = decl; }


    const IncompleteType *getType() const {
        return llvm::cast<IncompleteType>(CorrespondingType);
    }
    IncompleteType *getType() {
        return llvm::cast<IncompleteType>(CorrespondingType);
    }



    const TypeDecl *getCompletion() const { return completion; }
    TypeDecl *getCompletion() { return completion; }

    bool isCompatibleCompletion(const TypeDecl *decl) const;


    bool completionIsVisibleIn(const DeclRegion *region) const;

    // Support isa/dyn_cast.
    static bool classof(const IncompleteTypeDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_IncompleteTypeDecl;
    }

private:
    // Constructs an incomplete type declaration node.
    IncompleteTypeDecl(AstResource &resource,
                       IdentifierInfo *name, Location loc, DeclRegion *region);

    // Incomplete type declarations are constructed an managed by AstResource.
    friend class AstResource;

    TypeDecl *completion;
};

//===----------------------------------------------------------------------===//
// CarrierDecl
//
// Declaration of a domains carrier type.
class CarrierDecl : public TypeDecl {

public:
    CarrierDecl(AstResource &resource, IdentifierInfo *name,
                PrimaryType *type, Location loc)
        : TypeDecl(AST_CarrierDecl, name, type, loc) { }





    const PrimaryType *getRepresentationType() const {
        return getType()->getRootType();
    }
    PrimaryType *getRepresentationType() {
        return getType()->getRootType();
    }

    // Support isa/dyn_cast.
    static bool classof(const CarrierDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_CarrierDecl;
    }
};

//===----------------------------------------------------------------------===//
// EnumerationDecl
class EnumerationDecl : public TypeDecl, public DeclRegion {

    enum PropertyFlag {
        Subtype_FLAG   = 1 << 0, // Set when this is a subtype decl.
        Character_FLAG = 1 << 1  // Set when this is a character decl.
    };

public:
    bool isSubtypeDeclaration() const { return bits & Subtype_FLAG; }

    void generateImplicitDeclarations(AstResource &resource);


    const EnumerationType *getType() const {
        return llvm::cast<EnumerationType>(CorrespondingType);
    }
    EnumerationType *getType() {
        return llvm::cast<EnumerationType>(CorrespondingType);
    }


    const EnumerationType *getBaseSubtype() const {
        return getType()->getRootType()->getBaseSubtype();
    }
    EnumerationType *getBaseSubtype() {
        return getType()->getRootType()->getBaseSubtype();
    }

    // Returns the number of EnumLiteral's associated with this enumeration.
    unsigned getNumLiterals() const { return numLiterals; }

    // Returns the minimum number of bits needed to represent elements of this
    // enumeration.
    unsigned genBitsNeeded() const;

    // Returns the literal with the given name, or null if no such literal is a
    // member of this enumeration.
    EnumLiteral *findLiteral(IdentifierInfo *name);


    const EnumLiteral *getFirstLiteral() const;
    EnumLiteral *getFirstLiteral();


    const EnumLiteral *getLastLiteral() const;
    EnumLiteral *getLastLiteral();

    // Marks this declaration as a character enumeration.
    //
    // This method should be called if any of the literals constituting this
    // declaration are character literals.
    void markAsCharacterType() { bits |= Character_FLAG; }

    // Returns true if this declaration denotes a character enumeration.
    bool isCharacterType() const { return bits & Character_FLAG; }

    // Locates the EnumLiteral corresponding to the given character, or null if
    // no such literal exists.
    const EnumLiteral *findCharacterLiteral(char ch) const;

    // Returns true if an enumeration literal exists which maps to the given
    // character.
    bool hasEncoding(char ch) const {
        return findCharacterLiteral(ch) != 0;
    }

    // Returns the encoding of the given character.  This method is only valid
    // if hasEncoding() returns true for the given character.
    unsigned getEncoding(char ch) const {
        const EnumLiteral *lit = findCharacterLiteral(ch);
        assert(lit && "No encoding exists for the given character!");
        return lit->getIndex();
    }

    PosAD *getPosAttribute() { return posAttribute; }

    ValAD *getValAttribute() { return valAttribute; }

    FunctionAttribDecl *getAttribute(attrib::AttributeID ID);

    static bool classof(const EnumerationDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_EnumerationDecl;
    }

private:
    // Private constructors for use by AstResource.

    EnumerationDecl(AstResource &resource,
                    IdentifierInfo *name, Location loc,
                    std::pair<IdentifierInfo*, Location> *elems,
                    unsigned numElems, DeclRegion *parent);

    EnumerationDecl(AstResource &resource, IdentifierInfo *name, Location loc,
                    EnumerationType *subtype, DeclRegion *region);

    EnumerationDecl(AstResource &resource, IdentifierInfo *name, Location loc,
                    EnumerationType *subtype, Expr *lower, Expr *upper,
                    DeclRegion *region);

    friend class AstResource;

    // Generates the implicit declarations that must be attached to the
    // primitive Boolean type and that type alone.  This method is for use by
    // AstResource when it establishes the fundamental type nodes.
    void generateBooleanDeclarations(AstResource &resource);

    // The number of EnumLiteral's associated with this enumeration.
    uint32_t numLiterals;

    PosAD *posAttribute;        // Declaration node for the Pos attribute.
    ValAD *valAttribute;        // Declaration node for the Val attribute.
};

//===----------------------------------------------------------------------===//
// IntegerDecl
//
// These nodes represent integer type declarations.
class IntegerDecl : public TypeDecl, public DeclRegion {

public:
    bool isSubtypeDeclaration() const { return bits; }

    void generateImplicitDeclarations(AstResource &resource);





    const IntegerType *getType() const {
        return llvm::cast<IntegerType>(CorrespondingType);
    }
    IntegerType *getType() {
        return llvm::cast<IntegerType>(CorrespondingType);
    }


    const IntegerType *getBaseSubtype() const {
        return getType()->getRootType()->getBaseSubtype();
    }
    IntegerType *getBaseSubtype() {
        return getType()->getRootType()->getBaseSubtype();
    }



    Expr *getLowBoundExpr() { return lowExpr; }
    const Expr *getLowBoundExpr() const { return lowExpr; }



    Expr *getHighBoundExpr() { return highExpr; }
    const Expr *getHighBoundExpr() const { return highExpr; }

    PosAD *getPosAttribute() { return posAttribute; }

    ValAD *getValAttribute() { return valAttribute; }

    FunctionAttribDecl *getAttribute(attrib::AttributeID ID);

    static bool classof(const IntegerDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_IntegerDecl;
    }

private:
    IntegerDecl(AstResource &resource,
                IdentifierInfo *name, Location loc,
                Expr *lower, Expr *upper, DeclRegion *parent);

    IntegerDecl(AstResource &resource,
                IdentifierInfo *name, Location loc,
                IntegerType *subtype, DeclRegion *parent);

    IntegerDecl(AstResource &resource,
                IdentifierInfo *name, Location loc,
                IntegerType *subtype,
                Expr *lower, Expr *upper, DeclRegion *parent);

    friend class AstResource;

    Expr *lowExpr;              // Expr forming the lower bound.
    Expr *highExpr;             // Expr forming the high bound.

    PosAD *posAttribute;        // Declaration node for the Pos attribute.
    ValAD *valAttribute;        // Declaration node for the Val attribute.
};

//===----------------------------------------------------------------------===//
// ArrayDecl
//
// This node represents array type declarations.
class ArrayDecl : public TypeDecl, public DeclRegion {

    // Type used to store the DSTDefinitions defining the indices of this array.
    typedef llvm::SmallVector<DSTDefinition*, 4> IndexVec;

public:

    const ArrayType *getType() const {
        return llvm::cast<ArrayType>(CorrespondingType);
    }
    ArrayType *getType() {
        return llvm::cast<ArrayType>(CorrespondingType);
    }

    unsigned getRank() const { return getType()->getRank(); }


    const DiscreteType *getIndexType(unsigned i) const {
        return getType()->getIndexType(i);
    }
    DiscreteType *getIndexType(unsigned i) {
        return getType()->getIndexType(i);
    }


    const Type *getComponentType() const {
        return getType()->getComponentType();
    }
    Type *getComponentType() { return getType()->getComponentType(); }

    bool isConstrained() const { return getType()->isConstrained(); }


    typedef ArrayType::iterator index_iterator;
    index_iterator begin_indices() { return getType()->begin(); }
    index_iterator end_indices() { return getType()->end(); }

    // Support isa and dyn_cast.
    static bool classof(const ArrayDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ArrayDecl;
    }

private:
    ArrayDecl(AstResource &resource,
              IdentifierInfo *name, Location loc,
              unsigned rank, DSTDefinition **indices,
              Type *component, bool isConstrained, DeclRegion *parent);

    friend class AstResource;

    IndexVec indices;
};

//===----------------------------------------------------------------------===//
// RecordDecl
//
class RecordDecl : public TypeDecl, public DeclRegion {

public:


    const RecordType *getType() const {
        return llvm::cast<RecordType>(CorrespondingType);
    }
    RecordType *getType() {
        return llvm::cast<RecordType>(CorrespondingType);
    }

    ComponentDecl *addComponent(IdentifierInfo *name, Location loc,
                                Type *type);

    unsigned numComponents() const { return componentCount; }




    const ComponentDecl *getComponent(IdentifierInfo *name) const {
        return const_cast<RecordDecl*>(this)->getComponent(name);
    }
    ComponentDecl *getComponent(IdentifierInfo *name);


    const ComponentDecl *getComponent(unsigned i) const {
        return const_cast<RecordDecl*>(this)->getComponent(i);
    }
    ComponentDecl *getComponent(unsigned i);

    static bool classof(const RecordDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_RecordDecl;
    }

private:
    RecordDecl(AstResource &resource, IdentifierInfo *name, Location loc,
               DeclRegion *parent);

    friend class AstResource;

    // Total number of components defined by this record.
    unsigned componentCount;
};

//===----------------------------------------------------------------------===//
// ComponentDecl
//
class ComponentDecl : public Decl {

public:

    const Type *getType() const { return CorrespondingType; }
    Type *getType() { return CorrespondingType; }


    RecordDecl *getDeclRegion() {
        return llvm::cast<RecordDecl>(context);
    }
    const RecordDecl *getDeclRegion() const {
        return llvm::cast<RecordDecl>(context);
    }

    unsigned getIndex() const { return index; }

    // Support isa/dyn_cast.
    static bool classof(const ComponentDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_ComponentDecl;
    }

private:
    // ComponentDecl's are constructed by their enclosing record declaration.
    ComponentDecl(IdentifierInfo *name, Location loc,
                  Type *type, unsigned index, RecordDecl *parent)
        : Decl(AST_ComponentDecl, name, loc, parent),
          CorrespondingType(type), index(index) { }

    friend class RecordDecl;

    Type *CorrespondingType;    // Type of this component.
    unsigned index;             // Relative position of this component.
};

//===----------------------------------------------------------------------===//
// AccessDecl
//
class AccessDecl : public TypeDecl, public DeclRegion {

public:
    void generateImplicitDeclarations(AstResource &resource);



    const AccessType *getType() const {
        return llvm::cast<AccessType>(CorrespondingType);
    }
    AccessType *getType() {
        return llvm::cast<AccessType>(CorrespondingType);
    }

    // Support isa/dyn_cast.
    static bool classof(const AccessDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_AccessDecl;
    }

private:
    AccessDecl(AstResource &resource, IdentifierInfo *name, Location loc,
               Type *targetType, DeclRegion *parent);

    // AccessDecl's are constructed and managed by AstResource.
    friend class AstResource;
};

//===----------------------------------------------------------------------===//
// DomainTypeDecl
//
// This class represents implicit domain declarations which correspond to a
// particular instance.  There are three main subclasses:
//
//   - DomainInstanceDecl's represent the public or external view of a domain.
//     All references to formal parameters are replaced by the actuals for a
//     particular instance, and all percent nodes are mapped to the type of this
//     instance.
//
//   - AbstractDomainDecl's represent the formal parameters of a model.  They
//     provide a view of a domain as restricted by their principle signature.
//     These types of declarations are only visible in the bodies of generic
//     models.  Such domains provide a rewritten interface to the principle
//     signature where the signatures percent node is replaced by references to
//     this type, and where the formal arguments of a variety are replaced by
//     the actuals.
//
//   - PercentDecl's are the nodes which encapsulate the internal view of a
//     model.
//
class DomainTypeDecl : public TypeDecl, public DeclRegion {

protected:
    DomainTypeDecl(AstKind kind, AstResource &resource,
                   IdentifierInfo *name, Location loc = 0);

public:
    virtual ~DomainTypeDecl() { }

    virtual const SignatureSet &getSignatureSet() const = 0;


    const DomainType *getType() const {
        return llvm::cast<DomainType>(CorrespondingType);
    }
    DomainType *getType() {
        return llvm::cast<DomainType>(CorrespondingType);
    }

    static bool classof(const DomainTypeDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->denotesDomainTypeDecl();
    }
};

//===----------------------------------------------------------------------===//
// AbstractDomainDecl
class AbstractDomainDecl : public DomainTypeDecl {

public:
    AbstractDomainDecl(AstResource &resource,
                       IdentifierInfo *name, Location loc,
                       SigInstanceDecl *sig);

    AbstractDomainDecl(AstResource &resource,
                       IdentifierInfo *name, Location loc)
        : DomainTypeDecl(AST_AbstractDomainDecl, resource, name, loc) { }

    const SignatureSet &getSignatureSet() const { return sigset; }

    bool hasPrincipleSignature() const { return !sigset.empty(); }

    SigInstanceDecl *getPrincipleSignature() const {
        assert(hasPrincipleSignature());
        return *sigset.beginDirect();
    }

    static bool classof(const AbstractDomainDecl *node) { return true; }
    static bool classof(const Ast* node) {
        return node->getKind() == AST_AbstractDomainDecl;
    }

private:
    SignatureSet sigset;
};

//===----------------------------------------------------------------------===//
// DomainInstanceDecl
class DomainInstanceDecl : public DomainTypeDecl, public llvm::FoldingSetNode {

public:
    DomainInstanceDecl(AstResource &resource, DomainDecl *domain);

    DomainInstanceDecl(AstResource &resource, FunctorDecl *functor,
                       DomainTypeDecl **args, unsigned numArgs);

    Domoid *getDefinition() { return definition; }
    const Domoid *getDefinition() const { return definition; }

    DomainDecl *getDefiningDomain() const;

    FunctorDecl *getDefiningFunctor() const;

    const SignatureSet &getSignatureSet() const { return sigset; }

    bool isDependent() const;

    bool isParameterized() const { return getArity() != 0; }

    unsigned getArity() const;

    DomainTypeDecl *getActualParam(unsigned n) const {
        assert(isParameterized() && "Not a parameterized instance!");
        assert(n < getArity() && "Index out of range!");
        return arguments[n];
    }





    const DomainType *getActualParamType(unsigned n) const {
        return getActualParam(n)->getType();
    }
    DomainType *getActualParamType(unsigned n) {
        return getActualParam(n)->getType();
    }

    typedef DomainTypeDecl **arg_iterator;
    arg_iterator beginArguments() const { return arguments; }
    arg_iterator endArguments() const { return &arguments[getArity()]; }



    const PrimaryType *getRepresentationType() const {
        return representationType;
    }
    PrimaryType *getRepresentationType() { return representationType; }

    void Profile(llvm::FoldingSetNodeID &id) {
        Profile(id, &arguments[0], getArity());
    }

    static void
    Profile(llvm::FoldingSetNodeID &id,
            DomainTypeDecl **args, unsigned numArgs);

    static bool classof(const DomainInstanceDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_DomainInstanceDecl;
    }

private:
    Domoid *definition;
    DomainTypeDecl **arguments;
    SignatureSet sigset;

    typedef llvm::PointerUnion<CarrierDecl*, DeclRewriter*> CarrierRewrite;
    CarrierRewrite carrier;
    PrimaryType *representationType;

    friend class DomainDecl;
    friend class FunctorDecl;

    // Called by the defining domain or functor to notify an instance that the
    // definition is complete.
    void finalize();

    // Helper function called by the constructors.
    void initializeInstance(Domoid *definition);

    // Helper function called bby the constructors and finalize.
    void initializeRepresentation(DeclRewriter &rewriter);

    // The following call-backs are invoked when the declarative region of the
    // defining declaration changes.
    void notifyAddDecl(Decl *decl);
    void notifyRemoveDecl(Decl *decl);
};

//===----------------------------------------------------------------------===//
// PercentDecl

class PercentDecl : public DomainTypeDecl {

public:
    ModelDecl *getDefinition() { return underlyingModel; }
    const ModelDecl *getDefinition() const { return underlyingModel; }

    const SignatureSet &getSignatureSet() const { return sigset; }

    static bool classof(const PercentDecl *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_PercentDecl;
    }

private:
    friend class ModelDecl;

    PercentDecl(AstResource &resource, ModelDecl *model);

    ModelDecl *underlyingModel;
    SignatureSet sigset;
};

//===----------------------------------------------------------------------===//
// Inline methods, now that the decl hierarchy is in place.

inline const DomainType *ModelDecl::getPercentType() const
{
    return percent->getType();
}

inline DomainType *ModelDecl::getPercentType()
{
    return percent->getType();
}

inline SignatureDecl *Sigoid::getSignature()
{
    return llvm::dyn_cast<SignatureDecl>(this);
}

inline VarietyDecl *Sigoid::getVariety()
{
    return llvm::dyn_cast<VarietyDecl>(this);
}

inline DomainDecl *Domoid::getDomain()
{
    return llvm::dyn_cast<DomainDecl>(this);
}

inline FunctorDecl *Domoid::getFunctor()
{
    return llvm::dyn_cast<FunctorDecl>(this);
}

inline DomainDecl *DomainInstanceDecl::getDefiningDomain() const
{
    return llvm::dyn_cast<DomainDecl>(definition);
}

inline FunctorDecl *DomainInstanceDecl::getDefiningFunctor() const
{
    return llvm::dyn_cast<FunctorDecl>(definition);
}

inline DomainType *SigInstanceDecl::getActualParamType(unsigned n) const {
    return getActualParam(n)->getType();
}

} // End comma namespace

#endif

---