module ast.Expr;

/**
  The base class for all Expressions.
  */
class Expr
{
    /// Get the type of the Expr
    Object getType() 
    {
        assert(0, "Unimplemented");
        return null;
    }

    /// Set the type of the Expr
    void setType(Object type) 
    {
        assert(0, "Unimplemented");
    }

    /// Returns true if the Expr can be compile-time evaluated.
    bool isConstantExpr() { return false; }

    NumberLiteral asNumberLiteral() { return null; }
    bool isNumberLiteral() { return false; }

    StringLiteral asStringLiteral() { return null; }
    bool isStringLiteral() { return false; }

    ArrayLiteral asArrayLiteral() { return null; }
    bool isArrayLiteral() { return false; }

    Assign asAssign() { return null; }
    bool isAssign() { return false; }

    Binary asBinary() { return null; }
    bool isBinary() { return false; }

    Negate asNegate() { return null; }
    bool isNegate() { return false; }

    Deref asDeref() { return null; }
    bool isDeref() { return false; }

    AddressOf asAddressOf() { return null; }
    bool isAddressOf() { return false; }

    Index asIndex() { return null; }
    bool isIndex() { return false; }

    Identifier asIdentifier() { return null; }
    bool isIdentifier() { return false; }

    Member asMember() { return null; }
    bool isMember() { return false; }

private:
/// FIXME: Add DType? here
}

/**
  NumberLiteral
  */
/// FIXME: Should there be an IntegerLiteral and FloatLiteral instead?
class NumberLiteral : Expr
{
    override bool isConstantExpr() { return true; }

    override NumberLiteral asNumberLiteral() { return this; }
    override bool isNumberLiteral() { return true; }
}

/**
  StringLiteral
  */
class StringLiteral : Expr
{
    override bool isConstantExpr() { return true; }

    override StringLiteral asStringLiteral() { return this; }
    override bool isStringLiteral() { return true; }
}

/**
  ArrayLiteral
  */
class ArrayLiteral : Expr
{
    /// Return the arguments for the ArrayLiteral
    Expr[] getArguments() { return arguments; }

    /// Return a given argument for the ArrayLiteral
    Expr getArgument(int index) { return arguments[index]; }

    /// Get the count of arguments for the ArrayLiteral
    int getArgumentCount() { return arguments.length; }

    override bool isConstantExpr() 
    {
        /**
          If all the arguments to the ArrayLiteral is an constant Expr, then
          this ArrayLiteral can be considered an constant Expr aswell.
          */
        // FIXME: consider if it should save the result
        foreach (arg; arguments)
            if (!arg.isConstantExpr())
                return false;
        return true; 
    }

    override ArrayLiteral asArrayLiteral() { return this; }
    override bool isArrayLiteral() { return true; }

private:
    Expr[] arguments;
}

/**
  The Assign expression contains two expression, a left and a right side, 
  left being a lvalue, right being a rvalue. 

  If the right side ain't the same type as the left type, the right side will
  try to be promoted through an implicit cast. If this failes, an error must
  be given.
  */
class Assign : Expr
{
    override Assign asAssign() { return this; }
    override bool isAssign() { return true; }

private:
    Expr left, right;
}

/**
  Binary
  */
class Binary : Expr
{
    override Binary asBinary() { return this; }
    override bool isBinary() { return true; }

private:
    Expr left, right;
}

/**
  Negate
  */
class Negate : Expr
{
    override Negate asNegate() { return this; }
    override bool isNegate() { return true; }

private:
    Expr expr;
}

/**
  Deref
  */
class Deref : Expr
{
    override Deref asDeref() { return this; }
    override bool isDeref() { return true; }
}

/**
  AddressOf
  */
class AddressOf : Expr
{
    override AddressOf asAddressOf() { return this; }
    override bool isAddressOf() { return true; }
}

/**
  Index
  */
class Index : Expr
{
    override Index asIndex() { return this; }
    override bool isIndex() { return true; }
}

/**
  Identifier
  */
class Identifier : Expr
{
    override Identifier asIdentifier() { return this; }
    override bool isIdentifier() { return true; }
}

/**
  Member
  */
class Member : Expr
{
    override Member asMember() { return this; }
    override bool isMember() { return true; }
}