Just taking one of my occasional drive-by peeks to see where D is up to and came across the following tidbit linked from the changelog. From http://www.digitalmars.com/d/declaration.html :

"An implicit type inference for a class reference is not an auto declaration, even if the auto storage class is used:"

Huh? Documented or no, this appears to violate the Principle Of Least Astonishment with a wire brush, and looks like a straightforward bug to the casual observer. Can anyone remember the rationale for this?

cheers
Mike

Mike Capp wrote:
> Just taking one of my occasional drive-by peeks to see where D is up to and came
> across the following tidbit linked from the changelog. From
> http://www.digitalmars.com/d/declaration.html :
> 
> "An implicit type inference for a class reference is not an auto declaration,
> even if the auto storage class is used:"
> 
> Huh? Documented or no, this appears to violate the Principle Of Least
> Astonishment with a wire brush, and looks like a straightforward bug to the
> casual observer. Can anyone remember the rationale for this?
> 
> cheers
> Mike
> 
> 

Have you seen the new context of "auto" recently added to the language?  It's completely about making the compiler do type inference and has a very different meaning/application from the original.  The old meaning of "auto" as "automatically destruct at end of scope" doesn't apply in those situations.

The above is actually difficult and confusing to read if you are still thinking of auto its the original form (such as might be the case if you just popped in to see how things are going after being away for awhile).  It's just saying that "new context" auto will never have a "old context" auto meaning if declared in the style shown in the first example (auto c = new C();)  If you declare it like (auto C d = new C();), then the "old context" auto applies.

Confusing? Yes, but I think the old context is going to be deprecated sometime.  Not sure, though.

-JJR

/* how about... */
{
    auto auto c = new C();
}
/* is c.~this() called? */

Garett

Well, knowing is half the battle.  The difference between auto Foo foo and auto foo could be hard to spot.  An 'implicit' keyword would do the trick nicely, and prevent the auto/auto confusion.

-------------------------

private import std.stdio;

class Foo {
    char[] s;
    this(char[] s) {
        // Runtime Error: std.format
        //writefln("%s.this();", s);
        writef(s); writefln(".this();");
        this.s = s;
    }
    ~this() {
        // Runtime Error: std.format
        //writefln("%s.~this();", s);
        writef(s); writefln(".~this();");
    }
}

int main(char[][] args) {

    {
        auto Foo foo = new Foo("auto Foo foo");
    }

    writefln("auto Foo foo should have destructed by now.\n");

    {
        // compiler error: redundant storage class 'auto'
        //auto auto foo = new Foo("auto auto foo");
    }

    {
        auto foo = new Foo("auto foo");
    }

    writefln("auto foo has not destructed yet.");

    return 0;
}

/*
    auto Foo foo.this();
    auto Foo foo.~this();
    auto Foo foo should have destructed by now.

    auto foo.this();
    auto foo has not destructed yet.
    auto foo.~this();
*/


"Garett Bass" <garettbass@studiotekne.com> wrote in message news:dmpdno$10uj$1@digitaldaemon.com...
> /* how about... */
> {
>    auto auto c = new C();
> }
> /* is c.~this() called? */
>
> Garett
>