include/comma/ast/Expr.h

Go to the documentation of this file.

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

#ifndef COMMA_AST_EXPR_HDR_GUARD
#define COMMA_AST_EXPR_HDR_GUARD

#include "comma/ast/AstBase.h"
#include "comma/ast/Decl.h"
#include "comma/ast/SubroutineCall.h"
#include "comma/ast/SubroutineRef.h"
#include "comma/ast/Type.h"

#include "llvm/ADT/APInt.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/DataTypes.h"

namespace comma {

//===----------------------------------------------------------------------===//
// Expr
//
class Expr : public Ast {

public:
    Expr(AstKind kind, Type *type, Location loc = 0)
        : Ast(kind), type(type), location(loc) {
        assert(this->denotesExpr());
    }

    Expr(AstKind kind, Location loc = 0)
        : Ast(kind), type(0), location(loc) {
        assert(this->denotesExpr());
    }

    virtual ~Expr() { }

    Location getLocation() const { return location; }

    bool hasType() const { return type != 0; }

    Type *getType() const {
        assert(hasType() && "Expr does not have an associated type!");
        return type;
    }

    void setType(Type *type) { this->type = type; }

    bool hasResolvedType() const {
        return hasType() && !getType()->isUniversalType();
    }

    bool isStaticDiscreteExpr() const;

    bool staticDiscreteValue(llvm::APInt &result) const;

    bool staticStringValue(std::string &result) const;

    bool isStaticStringExpr() const;

    bool isMutable(Expr *&immutable);

    Expr *ignoreInjPrj();

    bool denotesName() const;

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

private:
    Type *type;
    Location location;
};

//===----------------------------------------------------------------------===//
// DeclRefExpr
//
// Represents references to declarations in the source code.
class DeclRefExpr : public Expr {

public:
    DeclRefExpr(ValueDecl *decl, Location loc)
        : Expr(AST_DeclRefExpr, decl->getType(), loc),
          declaration(decl) { }

    IdentifierInfo *getIdInfo() const { return declaration->getIdInfo(); }

    const char *getString() const { return declaration->getString(); }


    const ValueDecl *getDeclaration() const { return declaration; }
    ValueDecl *getDeclaration() { return declaration; }
    void setDeclaration(ValueDecl *decl) { declaration = decl; }

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

private:
    ValueDecl *declaration;
};

//===----------------------------------------------------------------------===//
// FunctionCallExpr

class FunctionCallExpr : public Expr, public SubroutineCall {

public:
    FunctionCallExpr(SubroutineRef *connective,
                     Expr **positionalArgs, unsigned numPositional,
                     KeywordSelector **keyedArgs, unsigned numKeys);

    FunctionCallExpr(FunctionDecl *connective, Location loc,
                     Expr **positionalArgs, unsigned numPositional,
                     KeywordSelector **keyedArgs, unsigned numKeys);

    FunctionCallExpr(SubroutineRef *connective);

    FunctionCallExpr(FunctionDecl *connective, Location loc);

    Location getLocation() const { return Expr::getLocation(); }



    FunctionDecl *getConnective() {
        return llvm::cast<FunctionDecl>(SubroutineCall::getConnective());
    };

    const FunctionDecl *getConnective() const {
        return llvm::cast<FunctionDecl>(SubroutineCall::getConnective());
    }

    void resolveConnective(FunctionDecl *connective);



    const FunctionDecl *getConnective(unsigned i) const {
        return llvm::cast<FunctionDecl>(SubroutineCall::getConnective(i));
    }
    FunctionDecl *getConnective(unsigned i) {
        return llvm::cast<FunctionDecl>(SubroutineCall::getConnective(i));
    }



    typedef SubroutineRef::fun_iterator fun_iterator;
    fun_iterator begin_functions() {
        return connective->begin_functions();
    }
    fun_iterator end_functions() {
        return connective->end_functions();
    }

    typedef SubroutineRef::const_fun_iterator const_fun_iterator;
    const_fun_iterator begin_functions() const {
        return connective->begin_functions();
    }
    const_fun_iterator end_functions() const {
        return connective->end_functions();
    }

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

private:
    void setTypeForConnective();
};

//===----------------------------------------------------------------------===//
// IndexedArrayExpr
//
// Represents the indexing into an array expression.
class IndexedArrayExpr : public Expr {

public:
    IndexedArrayExpr(Expr *arrExpr, Expr **indices, unsigned numIndices);

    Expr *getPrefix() { return indexedArray; }
    const Expr *getPrefix() const { return indexedArray; }

    unsigned getNumIndices() const { return numIndices; }

    Expr *getIndex(unsigned i) {
        assert(i < numIndices && "Index out of range!");
        return indexExprs[i];
    }

    const Expr *getIndex(unsigned i) const {
        assert(i < numIndices && "Index out of range!");
        return indexExprs[i];
    }

    typedef Expr **index_iterator;
    index_iterator begin_indices() { return &indexExprs[0]; }
    index_iterator end_indices() { return &indexExprs[numIndices]; }

    typedef Expr *const *const_index_iterator;
    const_index_iterator begin_indices() const { return &indexExprs[0]; }
    const_index_iterator end_indices() const { return &indexExprs[numIndices]; }

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

private:
    Expr *indexedArray;
    unsigned numIndices;
    Expr **indexExprs;
};

//===----------------------------------------------------------------------===//
// SelectedExpr
//
class SelectedExpr : public Expr {

public:
    SelectedExpr(Expr *prefix, Decl *component, Location loc, Type *type)
        : Expr(AST_SelectedExpr, type, prefix->getLocation()),
          prefix(prefix), component(component), componentLoc(loc) { }

    SelectedExpr(Expr *prefix, IdentifierInfo *component, Location loc)
        : Expr(AST_SelectedExpr, prefix->getLocation()),
          prefix(prefix), component(component), componentLoc(loc) { }

    bool isAmbiguous() const { return component.is<IdentifierInfo*>(); }

    void resolve(Decl *component, Type *type) {
        assert(isAmbiguous() && "SelectedExpr already resolved!");
        this->component = component;
        setType(type);
    }


    const Expr *getPrefix() const { return prefix; }
    Expr *getPrefix() { return prefix; }



    const Decl *getSelectorDecl() const { return component.get<Decl*>(); }
    Decl *getSelectorDecl() { return component.get<Decl*>(); }

    IdentifierInfo *getSelectorIdInfo() const {
        if (component.is<IdentifierInfo*>())
            return component.get<IdentifierInfo*>();
        else
            return component.get<Decl*>()->getIdInfo();
    }

    Location getSelectorLoc() const { return componentLoc; }

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

private:
    typedef llvm::PointerUnion<Decl*, IdentifierInfo*> ComponentUnion;

    Expr *prefix;
    ComponentUnion component;
    Location componentLoc;
};

//===----------------------------------------------------------------------===//
// InjExpr
//
// Represents "inj" expressions, mapping domain types to their carrier types.
class InjExpr : public Expr {

public:
    InjExpr(Expr *argument, Type *resultType, Location loc)
        : Expr(AST_InjExpr, resultType, loc),
          operand(argument) { }

    Expr *getOperand() { return operand; }
    const Expr *getOperand() const { return operand; }

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

private:
    Expr *operand;
};

//===----------------------------------------------------------------------===//
// PrjExpr
//
// Represents "prj" expressions, mapping carrier types to their domains.
class PrjExpr : public Expr {

public:
    PrjExpr(Expr *argument, DomainType *resultType, Location loc)
        : Expr(AST_PrjExpr, resultType, loc),
          operand(argument) { }

    Expr *getOperand() { return operand; }
    const Expr *getOperand() const { return operand; }

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

private:
    Expr *operand;
};

//===----------------------------------------------------------------------===//
// IntegerLiteral
//
class IntegerLiteral : public Expr
{
public:
    IntegerLiteral(const llvm::APInt &value, Location loc)
        : Expr(AST_IntegerLiteral, UniversalType::getUniversalInteger(), loc),
          value(value) { }

    IntegerLiteral(const llvm::APInt &value, IntegerType *type, Location loc)
        : Expr(AST_IntegerLiteral, type, loc), value(value) { }

    bool isUniversalInteger() const {
        return llvm::isa<UniversalType>(getType());
    }


    const llvm::APInt &getValue() const { return value; }
    llvm::APInt &getValue() { return value; }

    void setValue(const llvm::APInt &V) { value = V; }

    // Suppport isa/dyn_cast.
    static bool classof(const IntegerLiteral *node) { return true; }
    static bool classof(const Ast *node) {
        return node->getKind() == AST_IntegerLiteral;
    }

private:
    llvm::APInt value;
};

//===----------------------------------------------------------------------===//
// StringLiteral
//
// Initially, strings are constructed without a known type, as they are
// overloaded objects.
class StringLiteral : public Expr
{
    typedef llvm::SmallPtrSet<EnumerationDecl*, 4> InterpSet;

public:
    StringLiteral(const char *string, unsigned len, Location loc)
        : Expr(AST_StringLiteral, loc) {
        init(string, len);
    }

    StringLiteral(const char *start, const char *end, Location loc)
        : Expr(AST_StringLiteral, loc) {
        init(start, end - start);
    }

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

    llvm::StringRef getString() const { return llvm::StringRef(rep, len); }

    unsigned length() const { return len; }

    bool addComponentType(EnumerationDecl *decl) {
        return interps.insert(decl);
    }

    template <class I>
    void addComponentTypes(I start, I end) { interps.insert(start, end); }

    bool removeComponentType(EnumerationDecl *decl) {
        return interps.erase(decl);
    }


    bool containsComponentType(EnumerationDecl *decl) const {
        return interps.count(decl);
    }
    bool containsComponentType(EnumerationType *type) const {
        return findComponent(type->getRootType()) != end_component_types();
    }


    bool resolveComponentType(EnumerationType *type);

    unsigned numComponentTypes() const { return interps.size(); }

    bool zeroComponentTypes() const { return numComponentTypes() == 0; }

    const EnumerationDecl *getComponentType() const {
        if (numComponentTypes() != 1)
            return 0;
        return *begin_component_types();
    }



    typedef InterpSet::iterator component_iterator;
    component_iterator begin_component_types() { return interps.begin(); }
    component_iterator end_component_types() { return interps.end(); }

    typedef InterpSet::const_iterator const_component_iterator;
    const_component_iterator begin_component_types() const {
        return interps.begin();
    }
    const_component_iterator end_component_types() const {
        return interps.end();
    }

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

private:
    char *rep;
    unsigned len;
    InterpSet interps;

    void init(const char *string, unsigned len);

    const_component_iterator findComponent(EnumerationType *type) const;
    component_iterator findComponent(EnumerationType *type);
};

//===----------------------------------------------------------------------===//
// NullExpr
//
class NullExpr : public Expr {

public:
    NullExpr(Location loc, AccessType *target = 0)
        : Expr(AST_NullExpr, target, loc) { }


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

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

//===----------------------------------------------------------------------===//
// QualifiedExpr
//
class QualifiedExpr : public Expr {

public:
    QualifiedExpr(TypeDecl *qualifier, Expr *operand, Location loc)
        : Expr(AST_QualifiedExpr, qualifier->getType(), loc),
          prefix(qualifier), operand(operand) { }

    ~QualifiedExpr() { delete operand; }


    const TypeDecl *getPrefix() const { return prefix; }
    TypeDecl *getPrefix() { return prefix; }


    const Expr *getOperand() const { return operand; }
    Expr *getOperand() { return operand; }

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

private:
    TypeDecl *prefix;
    Expr *operand;
};

//===----------------------------------------------------------------------===//
// DereferenceExpr
//
class DereferenceExpr : public Expr {

public:
    DereferenceExpr(Expr *prefix, Location loc, bool isImplicit = false);

    ~DereferenceExpr() { delete prefix; }


    const Expr *getPrefix() const { return prefix; }
    Expr *getPrefix() { return prefix; }


    const AccessType *getPrefixType() const {
        return llvm::cast<AccessType>(prefix->getType());
    }
    AccessType *getPrefixType() {
        return llvm::cast<AccessType>(prefix->getType());
    }

    bool isImplicit() const { return bits != 0; }

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

private:
    Expr *prefix;
};

//===----------------------------------------------------------------------===//
// ConversionExpr
//
// These nodes represent type conversions.
class ConversionExpr : public Expr
{
public:
    ConversionExpr(Expr *operand, Type *target, Location loc = 0)
        : Expr(AST_ConversionExpr, target, loc),
          operand(operand) { }

    const Expr *getOperand() const { return operand; }
    Expr *getOperand() { return operand; }

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

private:
    Expr *operand;              
};

//===----------------------------------------------------------------------===//
// AllocatorExpr
//
class AllocatorExpr : public Expr {

public:
    AllocatorExpr(QualifiedExpr *operand, Location loc)
        : Expr(AST_AllocatorExpr, loc),
          operand(operand) { }

    AllocatorExpr(PrimaryType *operand, Location loc)
        : Expr(AST_AllocatorExpr, loc),
          operand(operand) { }

    bool isInitialized() const { return operand.is<Expr*>(); }

    bool isUninitialized() const { return operand.is<PrimaryType*>(); }



    const Expr *getInitializer() const { return operand.dyn_cast<Expr*>(); }
    Expr *getInitializer() { return operand.dyn_cast<Expr*>(); }


    const PrimaryType *getAllocatedType() const {
        return const_cast<AllocatorExpr*>(this)->getAllocatedType();
    }
    PrimaryType *getAllocatedType() {
        if (isInitialized())
            return llvm::cast<PrimaryType>(operand.get<Expr*>()->getType());
        else
            return operand.get<PrimaryType*>();
    }

    void setInitializer(Expr *expr) { operand = expr; }


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

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

private:
    typedef llvm::PointerUnion<PrimaryType*, Expr*> OperandUnion;
    OperandUnion operand;
};

//===----------------------------------------------------------------------===//
// DiamondExpr
//
class DiamondExpr : public Expr {

public:
    DiamondExpr(Location loc, Type *type = 0)
        : Expr(AST_DiamondExpr, type, loc) { }

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

} // End comma namespace.

#endif

---