module dmd.DeleteDeclaration;

import dmd.common;
import dmd.FuncDeclaration;
import dmd.ArrayTypes;
import dmd.Loc;
import dmd.Dsymbol;
import dmd.Scope;
import dmd.OutBuffer;
import dmd.HdrGenState;
import dmd.STC;
import dmd.Id;
import dmd.Argument;
import dmd.ClassDeclaration;
import dmd.TypeFunction;
import dmd.Type;
import dmd.LINK;
import dmd.TY;

class DeleteDeclaration : FuncDeclaration
{
	Arguments arguments;

    this(Loc loc, Loc endloc, Arguments arguments)
	{
		super(loc, endloc, Id.classDelete, STCstatic, null);
		this.arguments = arguments;
	}
	
    override Dsymbol syntaxCopy(Dsymbol)
	{
		DeleteDeclaration f;

		f = new DeleteDeclaration(loc, endloc, null);

		FuncDeclaration.syntaxCopy(f);

		f.arguments = Argument.arraySyntaxCopy(arguments);

		return f;
	}
	
    override void semantic(Scope sc)
	{
		ClassDeclaration cd;

		//printf("DeleteDeclaration.semantic()\n");

		parent = sc.parent;
		Dsymbol parent = toParent();
		cd = parent.isClassDeclaration();
		if (!cd && !parent.isStructDeclaration())
		{
			error("new allocators only are for class or struct definitions");
		}
		type = new TypeFunction(arguments, Type.tvoid, 0, LINKd);

		type = type.semantic(loc, sc);
		assert(type.ty == Tfunction);

		// Check that there is only one argument of type void*
		TypeFunction tf = cast(TypeFunction)type;
		if (Argument.dim(tf.parameters) != 1)
		{
			error("one argument of type void* expected");
		}
		else
		{
			Argument a = Argument.getNth(tf.parameters, 0);
			if (!a.type.equals(Type.tvoid.pointerTo()))
				error("one argument of type void* expected, not %s", a.type.toChars());
		}

		FuncDeclaration.semantic(sc);
	}
	
    override void toCBuffer(OutBuffer buf, HdrGenState* hgs)
	{
		buf.writestring("delete");
		Argument.argsToCBuffer(buf, hgs, arguments, 0);
		bodyToCBuffer(buf, hgs);
	}
	
    override string kind()
	{
		return "deallocator";
	}

    override bool isDelete()
	{
		return true;
	}
	
    override bool isVirtual()
	{
		return false;
	}
	
    override bool addPreInvariant()
	{
		return false;
	}
	
    override bool addPostInvariant()
	{
		return false;
	}
	
version (_DH) {
    DeleteDeclaration isDeleteDeclaration() { return this; }
}
}