January 04, 2018
https://issues.dlang.org/show_bug.cgi?id=17927

--- Comment #10 from Martin Nowak <code@dawg.eu> ---
Thanks for investigating, so now it's reduced to the old problem that the scope
system does not allow to define entry points.
Of course in real life this is using malloc instead of GC'ed dup, but it's not
possible to contain the former.

--
August 16, 2018
https://issues.dlang.org/show_bug.cgi?id=17927

Atila Neves <atila.neves@gmail.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |atila.neves@gmail.com

--- Comment #11 from Atila Neves <atila.neves@gmail.com> ---
I don't understand how it's possible that making it `inout` is correct inference. This allows for code that looks @safe but isn't. This really shouldn't compile:

@safe:

const(int)* gInt;

void main() {
    auto s = Struct();
    gInt = s.ptr;  // ARGH!
}

struct Struct {

    int* ints;

    this(int size) {
        import core.stdc.stdlib;
        ints = () @trusted { return cast(int*) malloc(size); }();
    }

    ~this() {
        import core.stdc.stdlib;
        () @trusted { free(ints); }();
    }

    scope inout(int)* ptr() inout {
        return ints;
    }
}



And yet it does. I guess I'll have to define 3 methods for mutable, const and immutable if I want to not crash.

--
August 20, 2018
https://issues.dlang.org/show_bug.cgi?id=17927

Steven Schveighoffer <schveiguy@yahoo.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|RESOLVED                    |REOPENED
                 CC|                            |schveiguy@yahoo.com
         Resolution|FIXED                       |---

--- Comment #12 from Steven Schveighoffer <schveiguy@yahoo.com> ---
(In reply to Walter Bright from comment #4)
> It turns out that:
> 
>   struct String {
>     inout(char)* mem2() inout scope @safe { return ptr; }
>     char* ptr;
>   }
> 
> not issuing an error is actually correct, because a parameter that is `ref inout` is inferred to be `return`, and the `this` parameter for `mem2` is `ref inout`.


What? ref inout should NOT be inferred as return. inout is a pattern match on the mutability of the parameters, it does not necessarily imply that it is part of the return type.

This can be handy when trying avoid code duplication when the const/immutable is nested under several indirections (including ref).

Reopening, the original problem is not fixed. The error case added tests for compiling the functions, but doesn't test that the result of the inout function is scope (it should be).

--
August 22, 2019
https://issues.dlang.org/show_bug.cgi?id=17927

Les De Ridder <dlang@lesderid.net> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |dlang@lesderid.net

--
September 04, 2019
https://issues.dlang.org/show_bug.cgi?id=17927

Mike Franklin <slavo5150@yahoo.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           See Also|                            |https://issues.dlang.org/sh
                   |                            |ow_bug.cgi?id=20149

--
September 04, 2019
https://issues.dlang.org/show_bug.cgi?id=17927

Mike Franklin <slavo5150@yahoo.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |slavo5150@yahoo.com

--- Comment #13 from Mike Franklin <slavo5150@yahoo.com> ---
Inferring `return` on `this` for anything marked with `inout` appears to be the cause of issue 20149.

--
September 21, 2019
https://issues.dlang.org/show_bug.cgi?id=17927

Mike Franklin <slavo5150@yahoo.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           See Also|                            |https://issues.dlang.org/sh
                   |                            |ow_bug.cgi?id=20156

--
March 04, 2020
https://issues.dlang.org/show_bug.cgi?id=17927

Walter Bright <bugzilla@digitalmars.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|REOPENED                    |RESOLVED
         Resolution|---                         |INVALID

--- Comment #14 from Walter Bright <bugzilla@digitalmars.com> ---
(In reply to Steven Schveighoffer from comment #12)
> ref inout should NOT be inferred as return. inout is a pattern match
> on the mutability of the parameters, it does not necessarily imply that it
> is part of the return type.

inout is deliberately inferred as return. It's the way the language currently works. To change it please make an enhancement request, as such should be discussed on its own merits.

--
March 04, 2020
https://issues.dlang.org/show_bug.cgi?id=17927

Steven Schveighoffer <schveiguy@yahoo.com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
         Resolution|INVALID                     |FIXED

--- Comment #15 from Steven Schveighoffer <schveiguy@yahoo.com> ---
Fixing the resolution, as the original bug was not invalid. If I have time, I'll try to remember what this was about and open another enhancement request.

--
June 15, 2021
https://issues.dlang.org/show_bug.cgi?id=17927

Dennis <dkorpel@live.nl> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           See Also|                            |https://issues.dlang.org/sh
                   |                            |ow_bug.cgi?id=22027

--
1 2
Next ›   Last »