module d.ir.expression;

import d.ir.symbol;
import d.ir.type;

import d.ast.expression;

import source.context;
import source.location;
import source.name;

abstract class Expression : AstExpression {
	Type type;

	this(Location location, Type type) {
		super(location);

		this.type = type;
	}

	@property
	bool isLvalue() const {
		return false;
	}
}

Expression build(E, T...)(T args)
		if (is(E : Expression) && is(typeof(new E(T.init)))) {
	import d.ir.error;
	if (auto ce = errorize(args)) {
		return ce.expression;
	}

	return new E(args);
}

alias TernaryExpression = d.ast.expression.TernaryExpression!Expression;
alias ArrayLiteral = d.ast.expression.ArrayLiteral!Expression;
alias StaticTypeidExpression =
	d.ast.expression.StaticTypeidExpression!(Type, Expression);

alias UnaryOp = d.ast.expression.UnaryOp;

/**
 * Any expression that have a value known at compile time.
 */
abstract class CompileTimeExpression : Expression {
	this(Location location, Type type) {
		super(location, type);
	}
}

final:
class UnaryExpression : Expression {
	Expression expr;
	UnaryOp op;

	this(Location location, Type type, UnaryOp op, Expression expr) {
		super(location, type);

		this.expr = expr;
		this.op = op;
	}

	invariant() {
		assert(expr);
	}

	override string toString(const Context c) const {
		return unarizeString(expr.toString(c), op);
	}

	@property
	override bool isLvalue() const {
		return op == UnaryOp.Dereference;
	}
}

enum BinaryOp {
	Comma,
	Assign,
	Add,
	Sub,
	Mul,
	Pow,
	UDiv,
	SDiv,
	URem,
	SRem,
	Or,
	And,
	Xor,
	LeftShift,
	UnsignedRightShift,
	SignedRightShift,
	LogicalOr,
	LogicalAnd,
}

class BinaryExpression : Expression {
	BinaryOp op;

	Expression lhs;
	Expression rhs;

	this(Location location, Type type, BinaryOp op, Expression lhs,
	     Expression rhs) {
		super(location, type);

		this.op = op;
		this.lhs = lhs;
		this.rhs = rhs;
	}

	override string toString(const Context c) const {
		import std.conv;
		return lhs.toString(c) ~ " " ~ to!string(op) ~ " " ~ rhs.toString(c);
	}
}

enum ICmpOp {
	Equal,
	NotEqual,
	Greater,
	GreaterEqual,
	Less,
	LessEqual,
}

/**
 * Integral comparisons (integers, pointers, ...)
 */
class ICmpExpression : Expression {
	ICmpOp op;

	Expression lhs;
	Expression rhs;

	this(Location location, ICmpOp op, Expression lhs, Expression rhs) {
		super(location, Type.get(BuiltinType.Bool));

		this.op = op;
		this.lhs = lhs;
		this.rhs = rhs;
	}

	override string toString(const Context c) const {
		import std.conv;
		return lhs.toString(c) ~ " " ~ to!string(op) ~ " " ~ rhs.toString(c);
	}
}

enum FPCmpOp {
	Equal,
	NotEqual,
	Greater,
	GreaterEqual,
	Less,
	LessEqual,

	// Weird float operators
	LessGreater,
	LessEqualGreater,
	UnorderedLess,
	UnorderedLessEqual,
	UnorderedGreater,
	UnorderedGreaterEqual,
	Unordered,
	UnorderedEqual,
}

class FPCmpExpression : Expression {
	FPCmpOp op;

	Expression lhs;
	Expression rhs;

	this(Location location, FPCmpOp op, Expression lhs, Expression rhs) {
		super(location, Type.get(BuiltinType.Bool));

		this.op = op;
		this.lhs = lhs;
		this.rhs = rhs;
	}

	override string toString(const Context c) const {
		import std.conv;
		return lhs.toString(c) ~ " " ~ to!string(op) ~ " " ~ rhs.toString(c);
	}
}

enum LifetimeOp {
	Copy,
	Consume,
	Destroy,
}

class LifetimeExpression : Expression {
	import std.bitmanip;
	mixin(taggedClassRef!(
		// sdfmt off
		Expression, "value",
		LifetimeOp, "op", 2,
		// sdfmt on
	));

	this(Location location, LifetimeOp op, Expression value) {
		super(location, value.type);

		this.op = op;
		this.value = value;
	}
}

class CallExpression : Expression {
	Expression callee;
	Expression[] args;

	this(Location location, Type type, Expression callee, Expression[] args) {
		super(location, type);

		this.callee = callee;
		this.args = args;
	}

	override string toString(const Context c) const {
		import std.algorithm, std.range;
		auto aa = args.map!(a => a.toString(c)).join(", ");
		return callee.toString(c) ~ "(" ~ aa ~ ")";
	}

	@property
	override bool isLvalue() const {
		return callee.type.asFunctionType().returnType.isRef;
	}
}

enum Intrinsic {
	None,
	Expect,
	CompareAndSwap,
	CompareAndSwapWeak,
	PopCount,
	CountLeadingZeros,
	CountTrailingZeros,
	ByteSwap,
}

/**
 * This is where the compiler does its magic.
 */
class IntrinsicExpression : Expression {
	Intrinsic intrinsic;
	Expression[] args;

	this(Location location, Type type, Intrinsic intrinsic, Expression[] args) {
		super(location, type);

		this.intrinsic = intrinsic;
		this.args = args;
	}

	override string toString(const Context c) const {
		import std.algorithm, std.range, std.conv;
		auto aa = args.map!(a => a.toString(c)).join(", ");
		return "sdc.intrinsics." ~ intrinsic.to!string ~ "(" ~ aa ~ ")";
	}
}

/**
 * Index expression : indexed[arguments]
 */
class IndexExpression : Expression {
	Expression indexed;
	Expression index;

	this(Location location, Type type, Expression indexed, Expression index) {
		super(location, type);

		this.indexed = indexed;
		this.index = index;
	}

	override string toString(const Context c) const {
		return indexed.toString(c) ~ "[" ~ index.toString(c) ~ "]";
	}

	@property
	override bool isLvalue() const {
		// FIXME: make this const compliant
		auto t = (cast() indexed.type).getCanonical();
		if (t.kind == TypeKind.Slice || t.kind == TypeKind.Pointer) {
			return true;
		}

		return indexed.isLvalue;
	}
}

/**
 * Slice expression : [first .. second]
 */
class SliceExpression : Expression {
	Expression sliced;

	Expression first;
	Expression second;

	this(Location location, Type type, Expression sliced, Expression first,
	     Expression second) {
		super(location, type);

		this.sliced = sliced;
		this.first = first;
		this.second = second;
	}

	override string toString(const Context c) const {
		return sliced.toString(c) ~ "[" ~ first.toString(c) ~ " .. "
			~ second.toString(c) ~ "]";
	}
}

/**
 * Expression that can in fact be several expressions.
 * A good example is IdentifierExpression that resolve as overloaded functions.
 */
class PolysemousExpression : Expression {
	Expression[] expressions;

	this(Location location, Expression[] expressions) {
		super(location, Type.get(BuiltinType.None));

		this.expressions = expressions;
	}

	invariant() {
		assert(expressions.length > 1);
	}
}

/**
 * Super
 */
class SuperExpression : Expression {
	this(Location location) {
		super(location, Type.get(BuiltinType.None));
	}

	this(Location location, Type type) {
		super(location, type);
	}

	override string toString(const Context) const {
		return "super";
	}

	@property
	override bool isLvalue() const {
		return true;
	}
}

/**
 * Context
 */
class ContextExpression : Expression {
	this(Location location, Function f) {
		super(location, Type.getContextType(f));
	}

	override string toString(const Context) const {
		return "__ctx";
	}

	@property
	override bool isLvalue() const {
		return true;
	}
}

/**
 * Virtual table
 * XXX: This is highly dubious. Explore the alternatives and get rid of that.
 */
class VtblExpression : Expression {
	Class dclass;

	this(Location location, Class dclass) {
		super(location, Type.get(BuiltinType.Void).getPointer());

		this.dclass = dclass;
	}

	override string toString(const Context c) const {
		return dclass.toString(c) ~ ".__vtbl";
	}
}

/**
 * Boolean literal
 */
class BooleanLiteral : CompileTimeExpression {
	bool value;

	this(Location location, bool value) {
		super(location, Type.get(BuiltinType.Bool));

		this.value = value;
	}

	override string toString(const Context) const {
		return value ? "true" : "false";
	}
}

/**
 * Integer literal
 */
class IntegerLiteral : CompileTimeExpression {
	ulong value;

	this(Location location, ulong value, BuiltinType t) in {
		assert(isIntegral(t));
	} do {
		super(location, Type.get(t));

		this.value = value;
	}

	override string toString(const Context) const {
		import std.conv;
		return isSigned(type.builtin)
			? to!string(cast(long) value)
			: to!string(value);
	}
}

/**
 * Float literal
 */
class FloatLiteral : CompileTimeExpression {
	double value;

	this(Location location, double value, BuiltinType t) in {
		assert(isFloat(t));
	} do {
		super(location, Type.get(t));

		this.value = value;
	}

	override string toString(const Context) const {
		import std.conv;
		return to!string(value);
	}
}

/**
 * Character literal
 */
class CharacterLiteral : CompileTimeExpression {
	dchar value;

	this(Location location, dchar value, BuiltinType t) in {
		assert(isChar(t));
	} do {
		super(location, Type.get(t));

		this.value = value;
	}

	override string toString(const Context) const {
		import std.conv;
		return "'" ~ to!string(value) ~ "'";
	}
}

/**
 * String literal
 */
class StringLiteral : CompileTimeExpression {
	string value;

	this(Location location, string value) {
		super(location,
		      Type.get(BuiltinType.Char).getSlice(TypeQualifier.Immutable));

		this.value = value;
	}

	override string toString(const Context) const {
		return "\"" ~ value ~ "\"";
	}
}

/**
 * Null literal
 */
class NullLiteral : CompileTimeExpression {
	this(Location location) {
		this(location, Type.get(BuiltinType.Null));
	}

	this(Location location, Type t) {
		super(location, t);
	}

	override string toString(const Context) const {
		return "null";
	}
}

/**
 * Cast expressions
 */
enum CastKind {
	Invalid,
	IntToPtr,
	PtrToInt,
	Down,
	IntToBool,
	Trunc,
	UPad,
	SPad,
	Bit,
	Qual,
	Exact,
}

class CastExpression : Expression {
	Expression expr;

	CastKind kind;

	this(Location location, CastKind kind, Type type, Expression expr) {
		super(location, type);

		this.kind = kind;
		this.expr = expr;
	}

	override string toString(const Context c) const {
		return "cast(" ~ type.toString(c) ~ ") " ~ expr.toString(c);
	}

	@property
	override bool isLvalue() const {
		final switch (kind) with (CastKind) {
			case Invalid:
			case IntToPtr:
			case PtrToInt:
			case Down:
			case IntToBool:
			case Trunc:
			case UPad:
			case SPad:
				return false;

			case Bit:
			case Qual:
			case Exact:
				return expr.isLvalue;
		}
	}
}

/**
 * new
 */
class NewExpression : Expression {
	Expression dinit;
	Function ctor;
	Expression[] args;

	this(Location location, Type type, Expression dinit, Function ctor,
	     Expression[] args) {
		super(location, type);

		this.dinit = dinit;
		this.ctor = ctor;
		this.args = args;
	}

	override string toString(const Context c) const {
		import std.algorithm, std.range;
		auto aa = args.map!(a => a.toString(c)).join(", ");
		return "new " ~ type.toString(c) ~ "(" ~ aa ~ ")";
	}
}

/**
 * IdentifierExpression that as been resolved as a Variable.
 */
class VariableExpression : Expression {
	Variable var;

	this(Location location, Variable var) {
		super(location, var.type);

		this.var = var;
	}

	override string toString(const Context c) const {
		return var.name.toString(c);
	}

	@property
	override bool isLvalue() const {
		return var.storage != Storage.Enum;
	}
}

/**
 * Field access.
 */
class FieldExpression : Expression {
	Expression expr;
	Field field;

	this(Location location, Expression expr, Field field) {
		super(location, field.type);

		this.expr = expr;
		this.field = field;
	}

	override string toString(const Context c) const {
		return expr.toString(c) ~ "." ~ field.name.toString(c);
	}

	@property
	override bool isLvalue() const {
		// FIXME: make this const compliant
		auto t = (cast() expr.type).getCanonical();
		if (t.kind == TypeKind.Class || t.kind == TypeKind.Pointer) {
			return true;
		}

		return expr.isLvalue;
	}
}

/**
 * IdentifierExpression that as been resolved as a Function.
 * XXX: Deserve to be merged with VariableExpression somehow.
 */
class FunctionExpression : Expression {
	Function fun;

	this(Location location, Function fun) {
		super(location, fun.type.getType());

		this.fun = fun;
	}

	override string toString(const Context c) const {
		return fun.name.toString(c);
	}
}

/**
 * Delegate from a function + contextes.
 */
class DelegateExpression : Expression {
	Expression[] contexts;
	Function method;

	this(Location location, Expression[] contexts, Function method) {
		super(location, method.type.getDelegate(contexts.length).getType());

		this.contexts = contexts;
		this.method = method;
	}

	override string toString(const Context c) const {
		return contexts[$ - 1].toString(c) ~ "." ~ method.name.toString(c);
	}
}

/**
 * For classes, typeid is computed at runtime.
 */
class DynamicTypeidExpression : Expression {
	Expression argument;

	this(Location location, Type type, Expression argument) {
		super(location, type);

		this.argument = argument;
	}

	override string toString(const Context c) const {
		return "typeid(" ~ argument.toString(c) ~ ")";
	}
}

/**
 * Used for type identifier = void;
 */
class VoidInitializer : CompileTimeExpression {
	this(Location location, Type type) {
		super(location, type);
	}

	override string toString(const Context) const {
		return "void";
	}
}

/**
 * tuples. Also used for struct initialization.
 */
template TupleExpressionImpl(bool isCompileTime = false) {
	static if (isCompileTime) {
		alias E = CompileTimeExpression;
	} else {
		alias E = Expression;
	}

	class TupleExpressionImpl : E {
		E[] values;

		this(Location location, Type t, E[] values) {
			// Implement type tuples.
			super(location, t);

			this.values = values;
		}

		override string toString(const Context c) const {
			import std.algorithm, std.range;
			auto members = values.map!(v => v.toString(c)).join(", ");

			// TODO: make this look nice for structs, classes, arrays...
			static if (isCompileTime) {
				return "ctTuple!(" ~ members ~ ")";
			} else {
				return "tuple(" ~ members ~ ")";
			}
		}
	}
}

// XXX: required as long as 0 argument instanciation is not possible.
alias TupleExpression = TupleExpressionImpl!false;
alias CompileTimeTupleExpression = TupleExpressionImpl!true;