gcc/testsuite/gdc.test/compilable/dtoh_TemplateDeclaration.d

   1 /*
   2 REQUIRED_ARGS: -HC -c -o-
   3 PERMUTE_ARGS:
   4 TEST_OUTPUT:
   5 ---
   6 // Automatically generated by Digital Mars D Compiler
   7
   8 #pragma once
   9
  10 #include <assert.h>
  11 #include <stddef.h>
  12 #include <stdint.h>
  13 #include <math.h>
  14
  15 #ifdef CUSTOM_D_ARRAY_TYPE
  16 #define _d_dynamicArray CUSTOM_D_ARRAY_TYPE
  17 #else
  18 /// Represents a D [] array
  19 template<typename T>
  20 struct _d_dynamicArray final
  21 {
  22     size_t length;
  23     T *ptr;
  24
  25     _d_dynamicArray() : length(0), ptr(NULL) { }
  26
  27     _d_dynamicArray(size_t length_in, T *ptr_in)
  28         : length(length_in), ptr(ptr_in) { }
  29
  30     T& operator[](const size_t idx) {
  31         assert(idx < length);
  32         return ptr[idx];
  33     }
  34
  35     const T& operator[](const size_t idx) const {
  36         assert(idx < length);
  37         return ptr[idx];
  38     }
  39 };
  40 #endif
  41
  42 typedef uint$?:32=32|64=64$_t size_t;
  43
  44 struct Outer final
  45 {
  46     int32_t a;
  47     struct Member final
  48     {
  49         typedef int32_t Nested;
  50         Member()
  51         {
  52         }
  53     };
  54
  55     Outer() :
  56         a()
  57     {
  58     }
  59     Outer(int32_t a) :
  60         a(a)
  61         {}
  62 };
  63
  64 enum : int32_t { SomeOtherLength = 1 };
  65
  66 struct ActualBuffer final
  67 {
  68     ActualBuffer()
  69     {
  70     }
  71 };
  72
  73 template <typename T>
  74 struct A final
  75 {
  76     // Ignoring var x alignment 0
  77     T x;
  78     // Ignoring var Enum alignment 0
  79     enum : int32_t { Enum = 42 };
  80
  81     // Ignoring var GsharedNum alignment 0
  82     static int32_t GsharedNum;
  83     // Ignoring var MemNum alignment 0
  84     const int32_t MemNum;
  85     void foo();
  86     A()
  87     {
  88     }
  89 };
  90
  91 template <typename T>
  92 struct NotInstantiated final
  93 {
  94     // Ignoring var noInit alignment 0
  95     // Ignoring var missingSem alignment 0
  96     NotInstantiated()
  97     {
  98     }
  99 };
 100
 101 struct B final
 102 {
 103     A<int32_t > x;
 104     B() :
 105         x()
 106     {
 107     }
 108     B(A<int32_t > x) :
 109         x(x)
 110         {}
 111 };
 112
 113 template <typename T>
 114 struct Foo final
 115 {
 116     // Ignoring var val alignment 0
 117     T val;
 118     Foo()
 119     {
 120     }
 121 };
 122
 123 template <typename T>
 124 struct Bar final
 125 {
 126     // Ignoring var v alignment 0
 127     Foo<T > v;
 128     Bar()
 129     {
 130     }
 131 };
 132
 133 template <typename T>
 134 struct Array final
 135 {
 136     typedef Array This;
 137     typedef typeof(1 + 2) Int;
 138     typedef typeof(T::a) IC;
 139     Array(size_t dim);
 140     ~Array();
 141     void get() const;
 142     template <typename T>
 143     bool opCast() const;
 144     // Ignoring var i alignment 0
 145     typename T::Member i;
 146     // Ignoring var j alignment 0
 147     typename Outer::Member::Nested j;
 148     void visit(typename T::Member::Nested i);
 149     Array()
 150     {
 151     }
 152 };
 153
 154 template <typename T, typename U>
 155 extern T foo(U u);
 156
 157 extern A<A<int32_t > > aaint;
 158
 159 template <typename T>
 160 class Parent
 161 {
 162     // Ignoring var parentMember alignment 0
 163 public:
 164     T parentMember;
 165     void parentFinal();
 166     virtual void parentVirtual();
 167 };
 168
 169 template <typename T>
 170 class Child final : public Parent<T >
 171 {
 172     // Ignoring var childMember alignment 0
 173 public:
 174     T childMember;
 175     void parentVirtual();
 176     T childFinal();
 177 };
 178
 179 extern void withDefTempl(A<int32_t > a = A<int32_t >(2, 13));
 180
 181 template <typename T>
 182 extern void withDefTempl2(A<T > a = static_cast<A<T >>(A<T >(2)));
 183
 184 class ChildInt : public Parent<int32_t >
 185 {
 186 };
 187
 188 struct HasMixins final
 189 {
 190     void foo(int32_t t);
 191     HasMixins()
 192     {
 193     }
 194 };
 195
 196 template <typename T>
 197 struct HasMixinsTemplate final
 198 {
 199     void foo(T t);
 200     HasMixinsTemplate()
 201     {
 202     }
 203 };
 204
 205 extern HasMixinsTemplate<bool > hmti;
 206
 207 template <typename T>
 208 struct NotAA final
 209 {
 210     // Ignoring var length alignment 0
 211     enum : int32_t { length = 12 };
 212
 213     // Ignoring var buffer alignment 0
 214     T buffer[length];
 215     // Ignoring var otherBuffer alignment 0
 216     T otherBuffer[SomeOtherLength];
 217     // Ignoring var calcBuffer alignment 0
 218     T calcBuffer[foo(1)];
 219     NotAA()
 220     {
 221     }
 222 };
 223
 224 template <typename Buffer>
 225 struct BufferTmpl final
 226 {
 227     // Ignoring var buffer alignment 0
 228     Buffer buffer;
 229     // Ignoring var buffer2 alignment 0
 230     Buffer buffer2;
 231     BufferTmpl()
 232     {
 233     }
 234 };
 235
 236 struct ImportedBuffer final
 237 {
 238     typedef ActualBuffer Buffer;
 239     ActualBuffer buffer2;
 240     ImportedBuffer()
 241     {
 242     }
 243 };
 244 ---
 245 */
 246
 247 extern (C++) struct A(T)
 248 {
 249     T x;
 250     enum Enum = 42;
 251     __gshared GsharedNum = 43;
 252     immutable MemNum = 13;
 253     void foo() {}
 254 }
 255
 256 // Invalid declarations accepted because it's not instantiated
 257 extern (C++) struct NotInstantiated(T)
 258 {
 259     enum T noInit;
 260     enum missingSem = T.init;
 261 }
 262
 263 extern (C++) struct B
 264 {
 265     A!int x;
 266 }
 267
 268 // https://issues.dlang.org/show_bug.cgi?id=20604
 269 extern(C++)
 270 {
 271     struct Foo (T)
 272     {
 273         T val;
 274     }
 275
 276     struct Bar (T)
 277     {
 278         Foo!T v;
 279     }
 280 }
 281
 282 extern (C++) struct Array(T)
 283 {
 284     alias This = typeof(this);
 285     alias Int = typeof(1 + 2);
 286     alias IC = typeof(T.a);
 287
 288     this(size_t dim) pure nothrow {}
 289     @disable this(this);
 290     ~this() {}
 291     void get() const {}
 292
 293     bool opCast(T)() const pure nothrow @nogc @safe
 294     if (is(T == bool))
 295     {
 296         return str.ptr !is null;
 297     }
 298
 299     T.Member i;
 300     Outer.Member.Nested j;
 301     void visit(T.Member.Nested i) {}
 302 }
 303
 304 struct Outer
 305 {
 306     int a;
 307     static struct Member
 308     {
 309         alias Nested = int;
 310     }
 311 }
 312
 313 // alias AO = Array!Outer;
 314
 315 extern(C++) T foo(T, U)(U u) { return T.init; }
 316
 317 extern(C++) __gshared A!(A!int) aaint;
 318
 319 extern(C++) class Parent(T)
 320 {
 321     T parentMember;
 322     final void parentFinal() {}
 323     void parentVirtual() {}
 324 }
 325
 326 extern(C++) final class Child(T) : Parent!T
 327 {
 328     T childMember;
 329     override void parentVirtual() {}
 330     T childFinal() { return T.init; }
 331 }
 332
 333 extern(C++) void withDefTempl(A!int a = A!int(2)) {}
 334
 335 extern(C++) void withDefTempl2(T)(A!T a = A!T(2)) {}
 336
 337 extern(C++) alias withDefTempl2Inst = withDefTempl2!int;
 338
 339 extern(C++) class ChildInt : Parent!int {}
 340
 341 /******************************************************
 342  * Mixins
 343  */
 344
 345 extern (C++):
 346
 347 mixin template MixinA(T)
 348 {
 349     void foo(T t) {}
 350 }
 351
 352 mixin template MixinB() {}
 353
 354 struct HasMixins
 355 {
 356     mixin MixinA!int;
 357     mixin MixinB;
 358 }
 359
 360 struct HasMixinsTemplate(T)
 361 {
 362     mixin MixinA!T;
 363     mixin MixinB;
 364 }
 365
 366 __gshared HasMixinsTemplate!bool hmti;
 367
 368 /// Declarations that look like associative arrays
 369
 370 extern(D) enum SomeOtherLength = 1;
 371
 372 struct NotAA(T)
 373 {
 374     private:
 375     enum length = 12;
 376     public:
 377     T[length] buffer;
 378     T[SomeOtherLength] otherBuffer;
 379     T[foo(1)] calcBuffer;
 380 }
 381
 382 // Same name but hidden by the template paramter
 383 extern (D) struct Buffer {}
 384 extern (D) struct ActualBuffer {}
 385
 386 struct BufferTmpl(Buffer)
 387 {
 388     Buffer buffer;
 389     mixin BufferMixin!();
 390 }
 391
 392 struct ImportedBuffer
 393 {
 394     alias Buffer = ActualBuffer;
 395     mixin BufferMixin!();
 396 }
 397
 398 mixin template BufferMixin()
 399 {
 400     Buffer buffer2;
 401 }