Ichthyostega
47f5390b18
This is an advanced diagnostics added (presumably) with GCC-13 and attempts to protect against an insidious side-effect of ''overload resolution'' Basically C++ (like its ancestor C) is oriented towards direct linkage and adds the OO-style dynamic dispatch (through virtual functions and a VTable) only as an extension, which must be requested explicitly. Thus the resolution of ''overloads'' (as opposed to ''overridden'' virtual functions) always takes precedence and happens within the directly visible scope, which can cause the compiler to perform an implicit conversion instead of invoking a different virtual function, which is defined in a base class. However, this diagnostics seems to be implemented in an overly zealous way: The compiler warns at the time of the type instantiation, and even in cases where it is effectively impossible to encounter this dangerous shadowing situation. See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109740 This leads to several ill-guided warnings in the Lumiera code base, which unfortunately can only be addressed by disabling this diagnostics for all usages of some header. The reason is, we often generate chains of template instantiations driven by type lists, and in such usage pattern, it is not even possible to bring all the other inherited overloads into scope (with a using `BASE::func` clause), because such a specification would be ambiguous and result in a real compile error, because even the interface is generated from a chain of mix-in templates
147 lines
4.3 KiB
C++
147 lines
4.3 KiB
C++
/*
|
||
Generator(Test) - build an interface + implementation directed by a typelis
|
||
|
||
Copyright (C)
|
||
2008, Hermann Vosseler <Ichthyostega@web.de>
|
||
|
||
**Lumiera** is free software; you can redistribute it and/or modify it
|
||
under the terms of the GNU General Public License as published by the
|
||
Free Software Foundation; either version 2 of the License, or (at your
|
||
option) any later version. See the file COPYING for further details.
|
||
|
||
* *****************************************************************/
|
||
|
||
|
||
/** @file generator-test.cpp
|
||
** \par what are we doing here??
|
||
**
|
||
** the following test composes both an interface and the corresponding implementation
|
||
** by instantiating "building block" templates over a collection of types. The resulting
|
||
** class ends up inheriting a \e virtual function instantiated for each of the types
|
||
** in the list. (remember: normally the number and signature of all virtual functions
|
||
** need to be absolutely fixed in the class definition)
|
||
**
|
||
** @see typelist-test.cpp
|
||
** @see generator.hpp
|
||
** @see lumiera::query::ConfigRules a real world usage example
|
||
**
|
||
*/
|
||
|
||
|
||
#include "lib/test/run.hpp"
|
||
#include "lib/format-string.hpp"
|
||
#include "lib/meta/generator.hpp"
|
||
|
||
#include <iostream>
|
||
#include <string>
|
||
|
||
using util::_Fmt;
|
||
using std::string;
|
||
using std::cout;
|
||
|
||
// GCC > 13 warns at class definition when a new overload shadows an inherited virtual function.
|
||
// While theoretically correct, this warning is besides the point when an interface is assembled
|
||
// by metaprogramming from a chain of template instantiations, driven by a type list
|
||
// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109740
|
||
_Pragma("GCC diagnostic push") \
|
||
_Pragma("GCC diagnostic ignored \"-Woverloaded-virtual\"")
|
||
|
||
|
||
namespace lib {
|
||
namespace meta {
|
||
namespace test {
|
||
|
||
/** template for generating lots of different test types */
|
||
template<int I>
|
||
struct Block
|
||
{
|
||
static string name;
|
||
string talk() { return "__"+name+"__"; }
|
||
};
|
||
|
||
|
||
|
||
template<int I>
|
||
string Block<I>::name = _Fmt("Block<%2i>") % I;
|
||
|
||
|
||
|
||
/** Use this building block for assembling an abstract interface */
|
||
template<class X>
|
||
class TakeIt
|
||
{
|
||
public:
|
||
virtual void eat (X& x) = 0;
|
||
virtual ~TakeIt() { }
|
||
};
|
||
|
||
/** Use this building block for chaining corresponding implementation classes. */
|
||
template<class X, class BASE>
|
||
class DoIt
|
||
: public BASE
|
||
{
|
||
protected:
|
||
DoIt () { cout << "ctor DoIt<"<< X::name << " >\n";}
|
||
virtual ~DoIt() { cout << "dtor DoIt<"<< X::name << " >\n";}
|
||
public:
|
||
void eat (X& x) { cout << "devouring" << x.talk() << "\n";}
|
||
using BASE::eat; // prevent shadowing
|
||
};
|
||
|
||
typedef Types< Block<1>
|
||
, Block<2>
|
||
, Block<3>
|
||
, Block<5>
|
||
, Block<8>
|
||
, Block<13>
|
||
>::List TheTypes;
|
||
|
||
typedef InstantiateForEach<TheTypes,TakeIt> TheInterface;
|
||
|
||
|
||
struct BaseImpl : public TheInterface
|
||
{
|
||
void eat() { cout << "gulp!\n"; }
|
||
};
|
||
|
||
typedef InstantiateChained<TheTypes,DoIt, BaseImpl> NumberBabbler;
|
||
|
||
|
||
/*********************************************************************//**
|
||
* @test check the helpers for dealing with lists-of-types.
|
||
* Build an interface and an implementation class
|
||
* by inheriting template instantiations
|
||
* for a collection of classes</li>
|
||
*/
|
||
class TypeListGenerator_test : public Test
|
||
{
|
||
virtual void
|
||
run (Arg)
|
||
{
|
||
NumberBabbler me_can_has_more_numberz;
|
||
|
||
CHECK (INSTANCEOF (TheInterface, &me_can_has_more_numberz));
|
||
|
||
TheTypes::Tail::Head b2; // Block<2>
|
||
TheTypes::Tail::Tail::Tail::Head b5; // Block<5>
|
||
TheTypes::Tail::Tail::Tail::Tail::Tail::Head b13; // Block<13>
|
||
|
||
me_can_has_more_numberz.eat (b2);
|
||
me_can_has_more_numberz.eat (b5);
|
||
|
||
TakeIt<Block<13>>& subInterface = me_can_has_more_numberz;
|
||
|
||
subInterface.eat (b13);
|
||
me_can_has_more_numberz.eat();
|
||
|
||
INFO (test, "SizeOf = %zu", sizeof(me_can_has_more_numberz));
|
||
}
|
||
};
|
||
|
||
|
||
/** Register this test class... */
|
||
LAUNCHER (TypeListGenerator_test, "unit common");
|
||
|
||
|
||
|
||
}}} // namespace lib::meta::test
|