OOP - blank interface - php

Question

Let's say that I have these two interfaces (PHP syntax)
interface Renderable_Item
{
}
interface Item_Renderer
{
function render(Renderable_Item $item);
}
I have a set of classes that are all same of a kind, but they just have nothing important (in Item_Renderer point of view) in common. All these classes implements Renderable_Item because they all should be renderable by Item_Renderer. So the Renderable_Item interface is just my way to group these classes.
Classes that implement Item_Renderer would have to first detect the concrete type, "downcast" it and then call methods of the concrete class anyway, so the interface has no meaning here, but in my opinion, it just "suits" there
Is there some better approach?
BTW, I am doing a PHP parser written in PHP. (I know there is some PHP parser in PERL and other, but just for fun .. ;))
First, I explode PHP code into structured chunks (classes that implement blank interface "Code_Chunk" (= Renderable_Item, in my example)). This is for example how class representing Assignment expression looks like -
class Assignment implements Expression
{
/**
* #var Variable
*/
private $variable;
/**
* #var Expression
*/
private $variableValue;
/**
* #return Expression
*/
public function getVariableValue()
{
return $this->variableValue;
}
/**
* #param Expression $variableValue
*/
public function setVariableValue($variableValue)
{
$this->variableValue = $variableValue;
}
/**
* #param Variable $variable
*/
public function setVariable(Variable $variable)
{
$this->variable = $variable;
}
/**
* #return Variable
*/
public function getVariable()
{
return $this->variable;
}
}
Interface Expression is by the way just another blank interface extending Code_Chunk, just to distinguish the code chunks that have some value (= expressions) from other.
However, there is nothing common between these classes that I can use except they are all some kind of "code chunk".
After this procedure, I want to rerender the whole parsed code tree, which is basically tons of structured instances of custom classes implementing Code_Chunk. Every Code_Chunk has its own rendering class (implementing Chunk_Renderer (= Item_Renderer)) accepting only that one certain chunk. For example, this is Assignment rendering class
class Assignment_Renderer implements Chunk_Renderer
{
public function render(Code_Chunk $chunk)
{
if(!($chunk instanceof Assignment)){
throw new Unexpected_Chunk_Exception($chunk);
}
/**
* #var $chunk Assignment
*/
$_ = '';
$_ .= $chunk->getVariable()->toString();
$_ .= '=';
$_ .= Chunk_Renderer_Factory::render($chunk->getVariableValue());
return $_;
}
}
Chunk_Renderer_Factory is a class holding all renderer classes as singletons and deciding, which renderer to use on which chunk.