MSVC-works, C++ (vc++)

Language: Layout:

#include <iostream>
#include <cstddef>

using size_t = std::size_t;

namespace llvm {
  namespace trailing_objects_internal {
    /// The base class for TrailingObjects* classes.
    class TrailingObjectsBase {
    protected:
      /// OverloadToken's purpose is to allow specifying function overloads
      /// for different types, without actually taking the types as
      /// parameters. (Necessary because member function templates cannot
      /// be specialized, so overloads must be used instead of
      /// specialization.)
      template <typename T> struct OverloadToken {};
    };

// Just a little helper for transforming a type pack into the same
    // number of a different type. e.g.:
    //   ExtractSecondType<Foo..., int>::type
    template <typename Ty1, typename Ty2> struct ExtractSecondType {
      typedef Ty2 type;
    };

// TrailingObjectsImpl is somewhat complicated, because it is a
    // recursively inheriting template, in order to handle the template
    // varargs. Each level of inheritance picks off a single trailing type
    // then recurses on the rest. The "Align", "BaseTy", and
    // "TopTrailingObj" arguments are passed through unchanged through the
    // recursion. "PrevTy" is, at each level, the type handled by the
    // level right above it.

template <typename BaseTy, typename TopTrailingObj, typename PrevTy,
      typename... MoreTys>
      class TrailingObjectsImpl {
      // The main template definition is never used -- the two
      // specializations cover all possibilities.
    };

template <typename BaseTy, typename TopTrailingObj, typename PrevTy,
      typename NextTy, typename... MoreTys>
      class TrailingObjectsImpl<BaseTy, TopTrailingObj, PrevTy, NextTy,
      MoreTys...>
      : public TrailingObjectsImpl< BaseTy, TopTrailingObj, NextTy,
      MoreTys...> {

typedef TrailingObjectsImpl<BaseTy, TopTrailingObj, NextTy, MoreTys...>
        ParentType;

protected:
        // Ensure the inherited getTrailingObjectsImpl is not hidden.
        using ParentType::getTrailingObjectsImpl;

// These two functions are helper functions for
        // TrailingObjects::getTrailingObjects. They recurse to the left --
        // the result for each type in the list of trailing types depends on
        // the result of calling the function on the type to the
        // left. However, the function for the type to the left is
        // implemented by a *subclass* of this class, so we invoke it via
        // the TopTrailingObj, which is, via the
        // curiously-recurring-template-pattern, the most-derived type in
        // this recursion, and thus, contains all the overloads.
        static const NextTy *
          getTrailingObjectsImpl(const BaseTy *Obj,
            TrailingObjectsBase::OverloadToken<NextTy>) {
          auto *Ptr = TopTrailingObj::getTrailingObjectsImpl(
            Obj, TrailingObjectsBase::OverloadToken<PrevTy>()) +
            TopTrailingObj::callNumTrailingObjects(
              Obj, TrailingObjectsBase::OverloadToken<PrevTy>());

return reinterpret_cast<const NextTy *>(Ptr);
        }

static NextTy *
          getTrailingObjectsImpl(BaseTy *Obj,
            TrailingObjectsBase::OverloadToken<NextTy>) {
          auto *Ptr = TopTrailingObj::getTrailingObjectsImpl(
            Obj, TrailingObjectsBase::OverloadToken<PrevTy>()) +
            TopTrailingObj::callNumTrailingObjects(
              Obj, TrailingObjectsBase::OverloadToken<PrevTy>());

return reinterpret_cast<NextTy *>(Ptr);
        }

// Helper function for TrailingObjects::additionalSizeToAlloc: this
        // function recurses to superclasses, each of which requires one
        // fewer size_t argument, and adds its own size.
        static constexpr size_t additionalSizeToAllocImpl(
          size_t SizeSoFar, size_t Count1,
          typename ExtractSecondType<MoreTys, size_t>::type... MoreCounts) {
          return ParentType::additionalSizeToAllocImpl(
            (SizeSoFar) +
            sizeof(NextTy) * Count1,
            MoreCounts...);
        }

// additionalSizeToAllocImpl for contexts where a constant expression is
        // required.
        // FIXME: remove when constexpr becomes really constexpr
        template <size_t SizeSoFar, size_t Count1, size_t... MoreCounts>
        struct AdditionalSizeToAllocImpl {
          static_assert(sizeof...(MoreTys) == sizeof...(MoreCounts),
            "Number of counts do not match number of types");
          static const size_t value = ParentType::template AdditionalSizeToAllocImpl<
            (SizeSoFar) +
            sizeof(NextTy) * Count1,
            MoreCounts...>::value;
        };
    };

// The base case of the TrailingObjectsImpl inheritance recursion,
    // when there's no more trailing types.
    template <typename BaseTy, typename TopTrailingObj, typename PrevTy>
    class TrailingObjectsImpl<BaseTy, TopTrailingObj, PrevTy> {
    protected:
      // This is a dummy method, only here so the "using" doesn't fail --
      // it will never be called, because this function recurses backwards
      // up the inheritance chain to subclasses.
      static void getTrailingObjectsImpl();

static constexpr size_t additionalSizeToAllocImpl(size_t SizeSoFar) {
        return SizeSoFar;
      }

// additionalSizeToAllocImpl for contexts where a constant expression is
      // required.
      // FIXME: remove when constexpr becomes really constexpr
      template <size_t SizeSoFar> struct AdditionalSizeToAllocImpl {
        static const size_t value = SizeSoFar;
      };

template <bool CheckAlignment> static void verifyTrailingObjectsAlignment() {}
    };

} // end namespace trailing_objects_internal

template <typename BaseTy, typename... TrailingTys>
  class TrailingObjects : private trailing_objects_internal::TrailingObjectsImpl<
    BaseTy, TrailingObjects<BaseTy, TrailingTys...>,
    BaseTy, TrailingTys...> {

template <typename B, typename T, typename P, typename... M>
    friend class trailing_objects_internal::TrailingObjectsImpl;

template <typename... Tys> class Foo {};

typedef trailing_objects_internal::TrailingObjectsImpl<
      BaseTy, TrailingObjects<BaseTy, TrailingTys...>, BaseTy, TrailingTys...>
      ParentType;
    using TrailingObjectsBase = trailing_objects_internal::TrailingObjectsBase;

using ParentType::getTrailingObjectsImpl;

public:
    // Make this (privately inherited) member public.
    template<typename T> using OverloadToken = typename ParentType::template OverloadToken<T>;

};
}

class Identifier {};
class SourceLoc {};

template<typename Derived>
class TrailingCallArguments
  : private llvm::TrailingObjects<Derived, Identifier, SourceLoc> {
  using TrailingObjects = typename llvm::TrailingObjects<Derived, Identifier, SourceLoc>;
  friend TrailingObjects;

Derived &asDerived() {
    return *static_cast<Derived *>(this);
  }

const Derived &asDerived() const {
    return *static_cast<const Derived *>(this);
  }

size_t numTrailingObjects(
    typename TrailingObjects::template OverloadToken<Identifier>) const {
    return asDerived().getNumArguments();
  }

size_t numTrailingObjects(
    typename TrailingObjects::template OverloadToken<SourceLoc>) const {
    return asDerived().hasArgumentLabelLocs()
      ? asDerived().getNumArguments()
      : 0;
  }
};

int main()
{
  std::cout << "Hello, World";
  return 0;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 1,64 sec, absolute running time: 0,78 sec, absolute service time: 2,43 sec