deprecate.dd

Ddoc

$(SPEC_S Deprecated Features,

    $(P Sometimes it becomes clear that a feature is just a bad idea.
        These are called $(I deprecated features) and once they are judged
        to merit removal from the language, they follow a procedure in
        order to allow plenty of time for users to adjust to the change.
    )

    $(TABLE2 Deprecated Features,
        $(THEAD Feature,                                                          Spec,  Dep,    Error,  Gone)
        $(TROW $(DEPLINK Using the result of a comma expression),                 future,  ,  ,  )
        $(TROW $(DEPLINK delete),                                                 future,  ,  ,  )
        $(TROW $(DEPLINK scope for allocating classes on the stack),              future,  ,  ,  )
        $(TROW $(DEPLINK Imaginary and complex types),                            future,  ,  ,  )
        $(TROW $(DEPLINK Implicit catch statement),                               2.072, 2.072,  future, future )
        $(TROW $(DEPLINK .sort and .reverse properties for arrays),               ?,     2.072;,  ,  )
        $(TROW $(DEPLINK C-style array pointers),                                 ?,     2.072;,  ,  )
        $(TROW $(DEPLINK Floating point NCEG operators),                          ?,     2.066,  2.072,   )
        $(TROW $(DEPLINK clear),                                                  2.060, 2.066,   , 2.068 )
        $(TROW $(DEPLINK .min property for floating point types),                 N/A,   2.065,  2.067,  2.072 )
        $(TROW $(DEPLINK Cast T[] to integral type),                              ?,     2.060,   , 2.061 )
        $(TROW $(DEPLINK Base Class Protection),                                  2.058, 2.058,  2.067,  2.072 )
        $(TROW $(DEPLINK Windows 3.x and Windows 9x support),                     2.058, N/A,    N/A,    2.058 )
        $(TROW $(DEPLINK typedef),                                                2.057, 2.057,  2.067,  2.072 )
        $(TROW $(DEPLINK Using * to dereference arrays),                          ?,     2.057,  2.067,  (never) )
        $(TROW $(DEPLINK invariant as an alias for immutable),                    2.057, 2.057,  2.064,  2.066 )
        $(TROW $(DEPLINK Non-final switch statements without a default case),     2.054, 2.054,  2.068,  (never) )
        $(TROW $(DEPLINK Hiding base class functions),                            2.054, 2.054,  2.068,  (never) )
        $(TROW $(DEPLINK Octal literals),                                         2.054, 2.053,  2.067,  (never) )
        $(TROW $(DEPLINK C-style function pointers),                              ?,     2.050,  2.067,  (never) )
        $(TROW $(DEPLINK Using length in index expressions),                      ?,     2.041,   , 2.061 )
        $(TROW $(DEPLINK Escape string literals),                                 ?,     2.026,  2.061,  2.067 )
        $(TROW $(DEPLINK volatile),                                               2.013, 2.013,  2.067,  2.072)
        $(TROW $(DEPLINK HTML source files),                                      ?,     2.013,  N/A,    2.061 )
        $(TROW $(DEPLINK Overriding without override),                            ?,     2.004,  2.072,  (never) )
        $(TROW $(DEPLINK Lower case 'l' suffix for integer literals),             ?,     1.054,  0.174,  (never) )
        $(TROW $(DEPLINK Variable shadowing inside functions),                    ?,     0.161,   , 2.061 )
        $(TROW $(DEPLINK Upper case 'I' suffix for imaginary literals),           ?,     0.154,  2.061,  (never) )
        $(TROW $(DEPLINK if (v; e)),                                              ?,     0.149,  2.061,  2.068 )
        $(TROW $(DEPLINK Removing an item from an associative array with delete), ?,     0.127,  2.061,  2.067 )
        $(TROW $(DEPLINK .offset property),                                       ?,     0.107,  2.061,  2.067 )
        $(TROW $(DEPLINK .size property),                                         ?,     0.107,  0.107,  2.061 )
        $(TROW $(DEPLINK .typeinfo property),                                     ?,     0.093,  2.061,  2.067 )
    )

    $(DL
        $(DT Spec)
        $(DD Removal from the Specification)
        $(DT Dep)
        $(DD The compiler warns by default, issues an error with the -de switch, and can be silenced with the -d switch)
        $(DT Error)
        $(DD It is an error to use the feature)
        $(DT Gone)
        $(DD The feature is completely gone)
    )


$(H3 $(DEPNAME Using the result of a comma expression))
    $(P The comma operator (`,`) allows executing multiple expressions and
        discards the result of them except for the last which is returned.

        ---
        int a = 1;
        int b = 2;
        bool ret = a == 2, b == 2; // true
        ---

        It's also common to use the comma operator in for-loop increment
        statements to allow multiple expressions.

        ---
        for (; !a.empty && !b.empty; a.popFront, b.popFront)
        ---
    )
$(H4 Corrective Action)
    $(P If possible, split the comma operator in two statements. Otherwise use
        lambdas.

        ---
        auto result = foo(), bar();

        // split off in two statements
        foo();
        auto result = bar();

        // or use lambdas
        auto result = {foo(); return bar();}();
        ---
    )
$(H4 Rationale)
    $(P The comma operator leads to unintended behavior (see below for a selection)
        Moreover it is not commonly used and it blocks the ability to implement tuples.

        A selection of problems through the accidental use of the comma operator:
        ---
        writeln( 6, mixin("7,8"), 9 ); // 6, 8, 9

        template vec(T...)(T args) { ... }
        vec v = (0, 0, 3); // 3, because vec is variadic

        int b = 2;
        if (a == 1, b == 2) {
            // will always be reached
        }

        void foo(int x) {}
        foo((++a, b));

        synchronized (lockA, lockB) {}
        // isn't currently implemented, but still compiles "thanks" to the comma operator
        ---
    )

$(H3 $(DEPNAME delete))
    $(P Memory allocated on the GC heap can be freed with $(D delete).
        ---
        auto a = new Class();
        delete a;
        ---
    )
$(H4 Corrective Action)
    $(P Use $(LINK2 phobos/object.html#.destroy, $(D object.destroy()))
        to finalize the object instead.
        ---
        auto a = new Class();
        destroy(a);
        ---
    )
    $(P Note that $(D destroy) does not free the allocated memory. If
        necessary, call $(LINK2 phobos/core_memory.html#.GC.free, $(D core.GC.free)) also.
    )
$(H4 Rationale)
    $(P $(D delete) makes assumptions about the type of garbage collector
        available that limits which implementations can be used, and can be
        replaced by a library solution.
    )



$(H3 $(DEPNAME scope for allocating classes on the stack))
    $(P The $(D scope) keyword can be used to allocate class objects on the stack:
        ---
        class A
        {
            int x;
            this(int x) { this.x = x; }
        }

        void main()
        {
            A obj;
            {
                scope A a = new A(1);
                obj = a;
            }
            assert(obj.x == 1);  // fails, 'a' has been destroyed
        }
        ---
    )
$(H4 Corrective Action)
    $(P Use $(REF scoped, std,typecons) instead.
        ---
        class A
        {
            this(int x) { }
        }
        void main()
        {
            auto a = scoped!A(1);
        }
        ---
    )
$(H4 Rationale)
    $(P $(D scope) was an unsafe feature. A reference to a scoped class could easily
        be returned from a function without errors, which would make using such
        an object undefined behavior due to the object being destroyed after
        exiting the scope of the function it was allocated in. To discourage it
        from general-use but still allow usage when needed a library solution was
        implemented.
    )
    $(P
        Note that $(D scope) for other usages (e.g. scoped variables) is unrelated
        to this feature and will not be deprecated.
    )



$(H3 $(DEPNAME Imaginary and complex types))
    $(P D currently supports imaginary and complex versions of all floating point types.
        ---
        float a = 2;
        ifloat b = 4i;
        cfloat c = a + b;
        assert(c == 2 + 4i);
        ---
    )
$(H4 Corrective Action)
    $(P Use the library types in $(STDFILEREF complex).
    )
$(H4 Rationale)
    $(P These types are too specialized to be a part of the core language.
    )


$(H3 $(DEPNAME Implicit catch statement))
    $(P One can catch everything by using $(D catch) without specifying a type.)
        ---
        int[] arr = new int[](10);
        // This will throw a RangeError
        try { arr[42]++; }
        catch { writeln("An error was caught and ignored"); }
        ---

$(H4 Corrective Action)
    $(P Either don't catch `Throwable` or replace `catch {}` with `catch (Throwable) {}`)
        ---
        int[] arr = new int[](10);
        // This will throw a RangeError
        try { arr[42]++; }
        catch (Throwable) { writeln("An error was caught and ignored"); }
        ---

$(H4 Rationale)
    $(P Catching `Throwable` should not be encouraged by the language,
    because certain core guarantee cannot be satisfied, e.g. the stack might not get cleaned
    up and destructors might not get run.
    This change helps ensure catching `Throwable` is always a conscious and visible decision
    on the programmer's side.
    )


$(H3 $(DEPNAME .sort and .reverse properties for arrays))
    $(P D arrays can be manipulated using these built-in properties.
        ---
        int[] x = [2, 3, 1];
        assert(x.sort == [1, 2, 3]);
        ---
    )
$(H4 Corrective Action)
    $(P Use the generic functions in $(STDFILEREF algorithm).
    )
$(H4 Rationale)
    $(P These operations are better implemented in the standard library.
    )



$(H3 $(DEPNAME C-style array pointers))
    $(P C-style array pointers can be used in D.
        ---
        alias float *arrayptr[10][15];
        ---
    )
$(H4 Corrective Action)
    $(P Replace with D-style array pointers.
        ---
        alias float[15][10]* arrayptr;
        ---
    )
$(H4 Rationale)
    $(P The D syntax is much cleaner and easier to use.
    )



$(H3 $(DEPNAME Floating point NCEG operators))
    $(P D currently supports the NCEG floating point operators
        (!<>=, <>, <>=, !>, !>=, !<, !<=, !<>) for comparisons involving NaNs.
    )
$(H4 Corrective Action)
    $(P Use the normal operators and $(REF isNaN, std,math).
    )
$(H4 Rationale)
    $(P These operators are too specialized to be a part of the core language.
    )



$(H3 $(DEPNAME clear))
    $(P Call an object's destructor.
        ---
        auto a = new Class();
        clear(a);
        ---
    )
$(H4 Corrective Action)
    $(P Use $(LINK2 phobos/object.html#.destroy, $(D object.destroy())) instead.
        ---
        auto a = new Class();
        destroy(a);
        ---
    )
$(H4 Rationale)
    $(P Due to Uniform Function Call Syntax (UFCS), $(D clear) can cause
        confusion with other methods of the same name, such as a $(D clear)
        method used to remove the contents of a container.
    )



$(H3 $(DEPNAME .min property for floating point types))
    $(P Floating point types have the .min property to access the smallest value.
        ---
        enum m = real.min;
        ---
    )
$(H4 Corrective Action)
    $(P Replace with .min_normal
        ---
        enum m = real.min_normal;
        ---
    )
$(H4 Rationale)
    $(P The name min_normal is more accurate, as .min does not include
        denormalized floating point values.
    )



$(H3 $(DEPNAME Cast T[] to integral type))
    $(P At some point in time you could do:
        ---
        ulong u = cast(ulong)[1,2];
        ---
        To get the length of the array.
    )
$(H4 Corrective Action)
    $(P Use the $(LINK2 https://dlang.org/spec/arrays.html#array-properties, .length)
        property instead.
    )
$(H4 Rationale)
    $(P Using a cast to get the length of an array is just confusing.
    )



$(H3 $(DEPNAME Base Class Protection))
    $(P Base class protections are things like:
        ---
        class A : $(D protected) B
        {
            ...
        }
        ---
    )
$(H4 Corrective Action)
    $(P Delete the protection attribute keyword from in front of the base class
        and base interfaces.
    )
$(H4 Rationale)
    $(P With D's module system, it doesn't seem to serve any useful purpose, and
        has never worked correctly.
    )



$(H3 $(DEPNAME Windows 3.x and Windows 9x support))
    $(P There is some code in Phobos for Windows 3.x/9x support.
    )
$(H4 Corrective Action)
    $(P Upgrade Windows or switch to another supported OS.
    )
$(H4 Rationale)
    $(P Supporting such outdated and rarely used OS-es isn't worth the trouble.
    )



$(H3 $(DEPNAME typedef))
    $(P typedef can be used to construct a strongly-typed alias of a type.
        ---
        typedef int myint;
        static assert(!is(myint == int));
        ---
    )
$(H4 Corrective Action)
    $(P Replace use of typedef with alias or use $(REF Typedef, std,typecons).
    )
$(H4 Rationale)
    $(P typedef is not flexible enough to cover all use cases.  This is better
        done with a library solution.
    )



$(H3 $(DEPNAME Using * to dereference arrays))
    $(P D array variables can be dereferenced to get the first element, much like pointers.
        ---
        int[] arr = [1, 2, 3];
        assert(*arr == 1);
        ---
    )
$(H4 Corrective Action)
    $(P Use indexing syntax to access first member.
        ---
        int[] arr = [1, 2, 3];
        assert(arr[0] == 1);
        ---
    )
$(H4 Rationale)
    $(P D arrays are not pointers.
    )



$(H3 $(DEPNAME invariant as an alias for immutable))
    $(P The invariant storage class and type modifier is an alias for immutable.
        ---
        static assert(is(invariant(int) == immutable(int)));
        ---
    )
$(H4 Corrective Action)
    $(P Replace all uses of invariant as a storage class or type modifier with
        immutable.  The invariant() syntax for struct and class invariants is
        still supported.
    )
$(H4 Rationale)
    $(P The alias is unnecessary.
    )



$(H3 $(DEPNAME Non-final switch statements without a default case))
    $(P Switch statements can be declared without a default case, and the
        compiler automatically adds one.
        ---
        switch(a)
        {
        case 1:
            break;
        case 2:
            break;
        // the compiler adds
        // default:
        //     throw new SwitchError();
        }
        ---
    )
$(H4 Corrective Action)
    $(P Add the default case manually.
        ---
        switch(a)
        {
        case 1:
            break;
        case 2:
            break;
        default:
            assert(0);
        }
        ---
    )
$(H4 Rationale)
    $(P Missing default cases can hide bugs, and making the default case
        explicit should be mandatory.
    )



$(H3 $(DEPNAME Hiding base class functions))
    $(P Declaration functions in a derived class that can be called with the
        same arguments as a function in a base class, but do not override that
        function causes the base class function to be hidden.
        ---
        class A
        {
            void fun(int x) {}
        }
        class B : A
        {
            void fun(long x) {}
        }
        ---
    )
$(H4 Corrective Action)
    $(P Add the function to the base class, or use an alias to bring the base
        class overload into the derived class.
        ---
        class A
        {
            void fun(int x) {}
            void fun(long x) {} // this fixes it
        }
        class B : A
        {
            void fun(long x) {}
            alias A.fun fun; // so does this
        }
        ---
    )
$(H4 Rationale)
    $(P This is an error that is already detected at runtime, and is being
        extended to compile time.
    )



$(H3 $(DEPNAME Octal literals))
    $(P Octal literals can be used to enter literals in base 8.
        ---
        // deprecated code
        // auto x = 0123;
        ---
    )
$(H4 Corrective Action)
    $(P Use the $(REF octal, std,conv) template.
        ---
        auto x = octal!123;
        ---
    )
$(H4 Rationale)
    $(P The use of a leading zero is confusing, as 0123 != 123.
    )



$(H3 $(DEPNAME C-style function pointers))
    $(P C-style function pointers can be used in D.
        ---
        alias void(*fptr)(int, long);
        ---
    )
$(H4 Corrective Action)
    $(P Replace with D-style function pointers.
        ---
        alias void function(int, long) fptr;
        ---
    )
$(H4 Rationale)
    $(P The D syntax is much cleaner and easier to use.
    )



$(H3 $(DEPNAME Using length in index expressions))
    $(P When used inside an indexing or slicing expression, length is rewritten to
        be the length of the array being sliced.
        ---
        auto a = new int[5];
        a = a[0..length-1];
        ---
    )
$(H4 Corrective Action)
    $(P Replace length with the equivalent $(LINK2 spec/arrays.html#array-length, '$')
    )
$(H4 Rationale)
    $(P The implicitly defined length variable shadows existing declarations,
        and is less concise than the alternative.
    )



$(H3 $(DEPNAME Escape string literals))
    $(P Escape string literals can be used to describe characters using escape sequences.
        ---
        // deprecated code
        // string x = "hello" ~ \n;
        ---
    )
$(H4 Corrective Action)
    $(P Put escape sequences inside a regular string literal.
        ---
        string x = "hello\n";
        ---
    )
$(H4 Rationale)
    $(P Escape string literals are unintuitive and unnecessary.
    )



$(H3 $(DEPNAME volatile))
    $(P volatile can be used to mark statement, in order to prevent some
        compiler optimizations.
        ---
        volatile
        {
            ... do something involving ghared variables ...
        }
        ---
    )
$(H4 Corrective Action)
    $(P Convert the code to use synchronized statements instead.
    )
$(H4 Rationale)
    $(P volatile statements are a misfeature.
    )



$(H3 $(DEPNAME HTML source files))
    $(P The D compiler can parse html files by ignoring everything not contained
        in &lt;code&gt;&lt;/code&gt; tags.
        ---
        <html>
        <code>
            ... source ...
        </code>
        </html>
        ---
    )
$(H4 Corrective Action)
    $(P Extract code to regular source files.
    )
$(H4 Rationale)
    $(P This has been replaced for documentation by the introduction of ddoc
    )



$(H3 $(DEPNAME Overriding without override))
    $(P Virtual functions can currently override a function in a base class
        without the 'override' attribute.
        ---
        class A
        {
            void fun() {}
        }
        class B : A
        {
            // overrides but is not marked with override
            void fun() {}
        }
        ---
    )
$(H4 Corrective Action)
    $(P Mark overriding functions with $(D override)
        ---
        class A
        {
            void fun() {}
        }
        class B : A
        {
            override void fun() {}
        }
        ---
    )
$(H4 Rationale)
    $(P Making the $(D override) attribute mandatory makes it explicit, and can
        catch errors when a base class function is accidentally overridden.
    )



$(H3 $(DEPNAME Lower case 'l' suffix for integer literals))
    $(P Lower case 'l' is an alternative suffix to denote 64 bit integer literals.
        ---
        // deprecated code
        // auto x = 123l;
        ---
    )
$(H4 Corrective Action)
    $(P Use the upper case 'L' suffix.
        ---
        auto x = 123L;
        ---
    )
$(H4 Rationale)
    $(P The lower case suffix is easily confused with the digit '1'.
    )
$(H4 Note)
    $(P In lexical analysis phase, compiler can recognize lower case suffix 'l'
        to report better error message - for the use case such as C-to-D code
        translation. Thus DMD would continue to parse 'l' suffix.
    )



$(H3 $(DEPNAME Variable shadowing inside functions))
    $(P Variable shadowing is when a variable in an inner scope has the same
        name as a variable in an enclosing scope.
        ---
        void myFun()
        {
            int var;
            if (x)
            {
                int var;
                var = 3; // which var was meant?
            }
        }
        ---
    )
$(H4 Corrective Action)
    $(P Rename shadowing variables so they don't conflict.
    )
$(H4 Rationale)
    $(P Variable shadowing can introduce hard to find bugs where the wrong
        variable is modified.
    )



$(H3 $(DEPNAME Upper case 'I' suffix for imaginary literals))
    $(P The 'I' suffix can be used to denote imaginary floating point values.
        ---
        // deprecated code
        // auto x = 1.234I;
        ---
    )
$(H4 Corrective Action)
    $(P Use the lower case 'i' suffix.
        ---
        auto x = 1.234i;
        ---
    )
$(H4 Rationale)
    $(P The 'I' suffix is easily confused with the digit '1'.
    )



$(H3 $(DEPNAME if (v; e)))
    $(P This syntax can be used to declare a variable in an if statement condition.
        ---
        if (v; calculateAndReturnPointer()) { ... }
        ---
    )
$(H4 Corrective Action)
    $(P Replace with an auto declaration.
        ---
        if (auto v = calculateAndReturnPointer()) { ... }
        ---
    )
$(H4 Rationale)
    $(P The syntax is clearer with auto.
    )



$(H3 $(DEPNAME Removing an item from an associative array with delete))
    $(P delete can be used to remove an item from an associative array.
        ---
        int[int] aa = [1 : 2];
        delete aa[1];
        assert(1 !in aa);
        ---
    )
$(H4 Corrective Action)
    $(P Use .remove instead.
        ---
        int[int] aa = [1 : 2];
        aa.remove(1);
        assert(1 !in aa);
        ---
    )
$(H4 Rationale)
    $(P The delete syntax is confusing and conflicts with the normal delete syntax.
    )



$(H3 $(DEPNAME .offset property))
    $(P The .offset property can be used to get member offset information.
        ---
        struct S { int a, b; }
        static assert(S.b.offset == 4);
        ---
    )
$(H4 Corrective Action)
    $(P Use .offsetof instead
        ---
        struct S { int a, b; }
        static assert(S.b.offsetof == 4);
        ---
    )
$(H4 Rationale)
    $(P The .offset syntax has been superseded by .offsetof
    )



$(H3 $(DEPNAME .size property))
    $(P The .size property can be used to get type size information
        ---
        struct S { int a, b; }
        static assert(S.size == 8);
        ---
    )
$(H4 Corrective Action)
    $(P Use .sizeof instead
        ---
        struct S { int a, b; }
        static assert(S.sizeof == 8);
        ---
    )
$(H4 Rationale)
    $(P The .size syntax has been superseded by .sizeof
    )



$(H3 $(DEPNAME .typeinfo property))
    $(P The .typeinfo property can be used to get the associated TypeInfo class.
        ---
        T.typeinfo
        ---
    )
$(H4 Corrective Action)
    $(P Use typeid() instead
        ---
        typeid(T)
        ---
    )
$(H4 Rationale)
    $(P The .typeinfo syntax has been superseded by typeid()
    )



)

Macros:
	DEPLINK=$(RELATIVE_LINK2 $0, $0)
	DEPLINK2=$(LINK2 $1.html#$2, $2)
	DEPNAME=$(LNAME2 $0, $0)
	TITLE=Deprecated Features
	STDFILEREF = <a href="phobos/std_$1.html">$(D std.$1)</a>