Virtual inheritance & covariant return types

Is it possible to return covariant types for virtual methods inherited
from a base class using virtual inheritance?

I've constructed an example below, which has the following structure:

Shape = base class
Triangle, Square = classes derived from Shape
Prism = class derived from Shape
TriangularPrism, SquarePrism = classes derived from Triangle and
Prism, or Square and Prism respectively

Prism provides some functionality based on virtual methods specified
in the Shape base class instantiated in specific Shapes Triangle and
Square. Since TriangularPrism and SquarePrism inherit Shape via Prism
AND Triangle/Square, it is necessary for Prism, Triangle and Square to
inherit Shape virtually.

I added a virtual Shape* clone() function to Shape, and wanted to
return Triangle* for Triangle::clone(), SquarePrism* for
SquarePrism::clone() etc. but this did not compile. I had to return
Shape* for every version of clone(). This means that if I clone a
SquarePrism, I have to use a dynamic cast to get at the methods
specific to that class.

Is this right!? Is it simply impossible to use covariant return types
for methods inherited virtually from a base class?!

----------------- Code example:

#include "iostream"

class Shape {
public:
  virtual double area() = 0;
  virtual Shape* clone() = 0;
  virtual char* type() { return "Shape"; }
};

// Shape must be inherited virtually in order to resolve multiple
inheritance in SquarePrism
class Square : virtual public Shape {
  double length;
  
public:
  Square(double l) : length(l) {}
  virtual double area() { return length * length; }
  // Use of the covariant return type Square* causes a compilation
error because Shape is inherited virtually
  // The error reads: "sorry, unimplemented: adjusting pointers
for covariant returns"
  // virtual Square *clone() { return new Square(*this); }
  virtual Shape *clone() { return new Square(*this); }
  virtual char* type() { return "Square"; }
};

// Shape must be inherited virtually in order to resolve multiple
inheritance in TriangularPrism
class Triangle : virtual public Shape {
  double base, height;
  
public:
  Triangle(double b, double h) : base(b), height(h) {}
  virtual double area() { return 0.5 * base * height; }
  // Use of the covariant return type Triangle* causes a compilation
error because Shape is inherited virtually
  // The error reads: "sorry, unimplemented: adjusting pointers
for covariant returns"
  // virtual Triangle *clone() { return new Triangle(*this); }
  virtual Shape *clone() { return new Triangle(*this); }
  virtual char* type() { return "Triangle"; }
};

// Shape must be inherited virtually to resolve multiple inheritance
in SquarePrism and TriangularPrism
class Prism : virtual public Shape {
  double depth;
public:
  
  Prism(double d) : depth(d) {}
  double volume() { return depth * area(); }
  virtual char* type() { return "Prism"; }
};

class SquarePrism : public Square, public Prism {
public:
  SquarePrism(double d, double l) : Square(l), Prism(d) { }
  virtual char* type() { return "SquarePrism"; }
  // clone cannot return a covariant return type SquarePrism* for the
same reason as Square and Triangle
  virtual Shape *clone() { return new SquarePrism(*this); }
};

class TriangularPrism : public Triangle, public Prism {
public:
  TriangularPrism(double d, double b, double h) : Triangle(b,h),
Prism(d) { }
  virtual char* type() { return "TriangularPrism"; }
  // clone cannot return a covariant return type TriangularPrism* for
the same reason as Square and Triangle
  virtual Shape *clone() { return new TriangularPrism(*this); }
};

using namespace std;

int main() {
  Square s(1);
  Triangle t(1,1);
  SquarePrism sp(10, 1);
  TriangularPrism tp(10, 1, 1);
  
  cout << "Square area = " << s.area() <<
endl;
  cout << "Triangle area = " << t.area()
<< endl;
  cout << "Cloned square area = " <<
s.clone()->area() << endl;
  cout << "Cloned triangle area = " <<
t.clone()->area() << endl;

  cout << "Square prism volume = " <<
sp.volume() << endl;
  cout << "Triangular prism volume = " <<
tp.volume() << endl;
  // Causes error because volume is not a function of Shape
  // cout << "Cloned square prism volume = " <<
sp.clone()->volume() << endl;
  // Use dynamic cast to allow access to the Prism functions:
  cout << "Cloned square prism volume = " <<
(dynamic_cast<Prism*>(sp.clone()))->volume() << endl;
  
  return 0;
}