blob: a1164dc4beb945cb7f11b41c5c1f75ca166b2be9 [file] [log] [blame]
// REQUIRED_ARGS:
/*
TEST_OUTPUT:
---
foo1 ulong function(return ref int* delegate() return p) ref return
foo2 int function(return ref int delegate() p) ref
foo3 int function(ref inout(int*) p) ref
foo4 int function(return ref inout(int*) p) ref
---
*/
import core.stdc.stdio;
/********************************************/
struct SS
{
ref ulong foo1(return ref int* delegate() return p) return;
ref int foo2(return ref int delegate() p);
ref int foo3(inout ref int* p);
ref int foo4(return inout ref int* p);
}
pragma(msg, "foo1 ", typeof(&SS.foo1));
pragma(msg, "foo2 ", typeof(&SS.foo2));
pragma(msg, "foo3 ", typeof(&SS.foo3));
pragma(msg, "foo4 ", typeof(&SS.foo4));
void test3()
{
version (none)
{
import std.stdio;
writeln(SS.foo1.mangleof);
writeln(SS.foo2.mangleof);
writeln(SS.foo3.mangleof);
writeln(SS.foo4.mangleof);
writeln(typeof(SS.foo1).stringof);
writeln(typeof(SS.foo2).stringof);
writeln(typeof(SS.foo3).stringof);
writeln(typeof(SS.foo4).stringof);
}
version (all)
{
// Test scope mangling
assert(SS.foo1.mangleof == "_D10testscope22SS4foo1MFNcNjNkKDFNjZPiZm");
assert(SS.foo2.mangleof == "_D10testscope22SS4foo2MFNcNkKDFZiZi");
assert(SS.foo3.mangleof == "_D10testscope22SS4foo3MFNcKNgPiZi");
assert(SS.foo4.mangleof == "_D10testscope22SS4foo4MFNcNkKNgPiZi");
// Test scope pretty-printing
assert(typeof(SS.foo1).stringof == "ref ulong(return ref int* delegate() return p) return");
assert(typeof(SS.foo2).stringof == "ref int(return ref int delegate() p)");
assert(typeof(SS.foo3).stringof == "ref int(ref inout(int*) p)");
assert(typeof(SS.foo4).stringof == "ref int(return ref inout(int*) p)");
}
}
/********************************************/
ref int foo(return ref int x)
{
return x;
}
struct S
{
int x;
ref S bar() return
{
return this;
}
}
ref T foo2(T)(ref T x)
{
return x;
}
void test4()
{
int x;
foo2(x);
}
/********************************************/
ref int foo(return ref int x, ref int y)
{
return x;
}
ref int bar()
{
int x;
static int y = 7;
return foo(y, x);
}
void test5()
{
int x = bar();
assert(x == 7);
}
/********************************************/
struct S6
{
int x = 8;
ref int bar() return
{
return x;
}
}
void test6()
{
S6 s;
int b = s.bar();
assert(b == 8);
}
/********************************************/
class C
{
int x;
ref int foo(return ref int x) { return x; }
ref int bar() return { return x; }
}
class D : C
{
override ref int foo(ref int x) { static int y; return y; }
override ref int bar() { static int y; return y; }
}
void test7()
{
}
/********************************************/
struct S8(T)
{
int x;
ref int bar() // infer 'return'
{
return x;
}
}
ref int test8a(return ref S8!int s)
{
return s.bar();
}
void test8()
{
}
/********************************************/
char[] foo9(return out char[4] buf)
{
return buf[0 .. 1];
}
/********************************************/
struct S10
{
int x;
ref inout(int) foo() inout return
{
return x;
}
}
/********************************************/
struct RC
{
this(this) { }
}
struct S11
{
@disable this(this);
void remove()
{
_ptr[0] = _ptr[1];
}
RC* _ptr;
}
void test11()
{
S11 ary;
}
/********************************************/
int[10] a12;
int* foo12()
{
foreach (ref x; a12)
return &x;
return null;
}
/********************************************/
struct FullCaseEntry
{
dchar[3] seq;
ubyte n, size;// n number in batch, size - size of batch
ubyte entry_len;
@property auto value() const @trusted pure nothrow @nogc return
{
return seq[0..entry_len];
}
}
/********************************************/
class C12
{
void member() scope { }
}
/********************************************/
void main()
{
test3();
test4();
test5();
test6();
test7();
test8();
test11();
printf("Success\n");
}