gcc/testsuite/gdc.test/runnable/testscope2.d

// 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");
}