In perl.git, the branch abigail/deprecation has been updated <http://perl5.git.perl.org/perl.git/commitdiff/696beaa76ccb4be5469e94d2fa26128e155efed1?hp=db45fb546500da24b032d23e4b3773b4e74dd280>
- Log ----------------------------------------------------------------- commit 696beaa76ccb4be5469e94d2fa26128e155efed1 Author: Abigail <[email protected]> Date: Sat Jan 14 22:34:30 2017 +0100 Mention $! vs $^E in pod/perlport.pod Since 5.24, it has been deprecated to check $! after a Winsock function; one such use $^E instead. However, since we do not have a deprecation warning for this, we cannot set an EOL version of this deprecation. As such, it just gets mentioned in perlport, and this will be the only deprecation without an EOL version. M pod/perlport.pod commit 0d43fbf72d612f4fb8d9b19163baf3823832e1e4 Author: Abigail <[email protected]> Date: Sat Jan 14 22:28:50 2017 +0100 Update an old email address of mine M pod/perlport.pod commit 9cca68ac9866ea40a13dae5cff9aaaf97f405fb1 Author: Abigail <[email protected]> Date: Sat Jan 14 22:13:54 2017 +0100 String bitwise operators will not accept code points > 0xFF in 5.28 M op.h M pod/perldeprecation.pod M pod/perldiag.pod M t/lib/warnings/doop M t/lib/warnings/pp commit 59711326e4a66d8f11ebfb8e19d69178cfb709da Author: Abigail <[email protected]> Date: Sat Jan 14 21:44:56 2017 +0100 Reading/writing bytes from :utf8 handles will be fatal in 5.30 M pod/perldeprecation.pod M pod/perldiag.pod M pp_sys.c M t/lib/warnings/pp_sys commit 633c5cb37e88c0b6b53fc619fb6eca4f3a123a3b Author: Abigail <[email protected]> Date: Sat Jan 14 18:25:48 2017 +0100 Deprecating the modifyable variables in constants by 5.32. It was already deprecated, but we're now adding a version number. M pad.c M pod/perldeprecation.pod M pod/perldiag.pod M t/op/const-optree.t commit ad82f59c2649732c7be283eda9ecc33ed4d245cd Author: Abigail <[email protected]> Date: Sat Jan 14 04:01:39 2017 +0100 Make it fatal to pass malformed UTF-8. Due to a bug in either Perl, or in some XS-code, it's possible for a string which is supposed to be in UTF-8 format to not be properly encoded. If you try to find out its type (digit, punctuation) perl will now croak. This behaviour was deprecated in Perl 5.18. M pod/perldeprecation.pod M pod/perldiag.pod M t/op/lex.t M t/uni/variables.t M utf8.c commit 28d879bdf2540c8f6169446d12b9a18ce05067f0 Author: Abigail <[email protected]> Date: Sat Jan 14 02:30:49 2017 +0100 my() in a false conditional will be fatal in Perl 5.30 M op.c M pod/perldeprecation.pod M pod/perldiag.pod M t/lib/warnings/op commit 7c494c3d4e52dcdfcfd19737fd0501f421f99b73 Author: Abigail <[email protected]> Date: Fri Jan 13 22:36:47 2017 +0100 Deprecation of an unqualified dump() to mean CORE::dump(). This will no longer be allowed in 5.30. M pod/perldeprecation.pod M pod/perldiag.pod M t/lib/croak/pp_ctl M t/lib/warnings/toke M t/op/dump.t M toke.c commit cb28ec054b035fd65c1af8db3a83c34d27c6d925 Author: Abigail <[email protected]> Date: Fri Jan 13 20:29:58 2017 +0100 Deprecating the use of C<< \cI<X> >> to specify a printable character. Starting in 5.14, we deprecated the use of "\cI<X>" when this results in a printable character. For instance, "\c:" is just a fancy way of writing "z". Starting in 5.28, this will be a fatal error. This also includes certain usage in regular expressions with the experimental (?[ ]) construct, or when "use re 'strict'" is in effect (also experimental). M dquote.c M pod/perldeprecation.pod M pod/perldiag.pod M regcomp.c M t/lib/warnings/regcomp M t/lib/warnings/toke M t/re/reg_mesg.t ----------------------------------------------------------------------- Summary of changes: dquote.c | 5 +- op.c | 3 +- op.h | 3 +- pad.c | 3 +- pod/perldeprecation.pod | 138 ++++++++++++++++++++++++++++++++++++++++++++++++ pod/perldiag.pod | 81 ++++++++++++++++------------ pod/perlport.pod | 25 ++++++++- pp_sys.c | 6 ++- regcomp.c | 21 +++++--- t/lib/croak/pp_ctl | 3 +- t/lib/warnings/doop | 18 +++---- t/lib/warnings/op | 14 ++--- t/lib/warnings/pp | 4 +- t/lib/warnings/pp_sys | 4 +- t/lib/warnings/regcomp | 6 +-- t/lib/warnings/toke | 25 +++++++-- t/op/const-optree.t | 3 +- t/op/dump.t | 7 +++ t/op/lex.t | 2 +- t/re/reg_mesg.t | 16 +++--- t/uni/variables.t | 7 ++- toke.c | 6 ++- utf8.c | 10 +--- 23 files changed, 313 insertions(+), 97 deletions(-) diff --git a/dquote.c b/dquote.c index e02308e7ac..e5dc84d1f2 100644 --- a/dquote.c +++ b/dquote.c @@ -46,8 +46,9 @@ Perl_grok_bslash_c(pTHX_ const char source, const bool output_warning) clearer[i++] = result; clearer[i++] = '\0'; - Perl_ck_warner(aTHX_ packWARN(WARN_SYNTAX), - "\"\\c%c\" is more clearly written simply as \"%s\"", + Perl_ck_warner(aTHX_ packWARN2(WARN_SYNTAX,WARN_DEPRECATED), + "\"\\c%c\" is more clearly written simply as \"%s\". " + "This will be a fatal error in Perl 5.28", source, clearer); } diff --git a/op.c b/op.c index 9724ff09ed..e1c3f439c5 100644 --- a/op.c +++ b/op.c @@ -6944,7 +6944,8 @@ S_new_logop(pTHX_ I32 type, I32 flags, OP** firstp, OP** otherp) && !(o2->op_private & OPpPAD_STATE)) { Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED), - "Deprecated use of my() in false conditional"); + "Deprecated use of my() in false conditional. " + "This will be a fatal error in Perl 5.30"); } *otherp = NULL; diff --git a/op.h b/op.h index c0e6386985..90f63e3227 100644 --- a/op.h +++ b/op.h @@ -1075,7 +1075,8 @@ C<sib> is non-null. For a higher-level interface, see C<L</op_sibling_splice>>. #if defined(PERL_IN_DOOP_C) || defined(PERL_IN_PP_C) static const char * const deprecated_above_ff_msg = "Use of strings with code points over 0xFF as arguments to " - "%s operator is deprecated"; + "%s operator is deprecated. This will be a fatal error in " + "Perl 5.28"; #endif diff --git a/pad.c b/pad.c index 6d2d008b0f..5bbb07a092 100644 --- a/pad.c +++ b/pad.c @@ -2159,7 +2159,8 @@ S_cv_clone_pad(pTHX_ CV *proto, CV *cv, CV *outside, HV *cloned, "Constants from lexical " "variables potentially " "modified elsewhere are " - "deprecated"); + "deprecated. This will not " + "be allowed in Perl 5.32"); /* We *copy* the lexical variable, and donate the copy to newCONSTSUB. Yes, this is ugly, and should be killed. We need to do this for the diff --git a/pod/perldeprecation.pod b/pod/perldeprecation.pod index 074ffd9cc0..31c9b57739 100644 --- a/pod/perldeprecation.pod +++ b/pod/perldeprecation.pod @@ -14,6 +14,42 @@ features are available. The deprecated features will be grouped by the version of Perl in which they will be removed. +=head2 Perl 5.32 + +=head3 Constants from lexical variables potentially modified elsewhere + +You wrote something like + + my $var; + $sub = sub () { $var }; + +but $var is referenced elsewhere and could be modified after the C<sub> +expression is evaluated. Either it is explicitly modified elsewhere +(C<$var = 3>) or it is passed to a subroutine or to an operator like +C<printf> or C<map>, which may or may not modify the variable. + +Traditionally, Perl has captured the value of the variable at that +point and turned the subroutine into a constant eligible for inlining. +In those cases where the variable can be modified elsewhere, this +breaks the behavior of closures, in which the subroutine captures +the variable itself, rather than its value, so future changes to the +variable are reflected in the subroutine's return value. + +If you intended for the subroutine to be eligible for inlining, then +make sure the variable is not referenced elsewhere, possibly by +copying it: + + my $var2 = $var; + $sub = sub () { $var2 }; + +If you do want this subroutine to be a closure that reflects future +changes to the variable that it closes over, add an explicit C<return>: + + my $var; + $sub = sub () { return $var }; + +This usage has been deprecated, and will no longer be allowed in Perl 5.32. + =head2 Perl 5.30 =head3 C<< File::Glob::glob() >> will disappear @@ -55,6 +91,67 @@ in Perl 5.26. Due to an oversight, not all cases of a use of a literal C<{> got a deprecation warning. These cases started warning in Perl 5.26, and they will be fatal by Perl 5.30. +=head3 Unqualified C<dump()> + +Use of C<dump()> instead of C<CORE::dump()> was deprecated in Perl 5.8, +and an unqualified C<dump()> will no longer be available in Perl 5.30. + +See L<perlfunc/dump>. + + +=head2 Using my() in false conditional. + +There has been a long-standing bug in Perl that causes a lexical variable +not to be cleared at scope exit when its declaration includes a false +conditional. Some people have exploited this bug to achieve a kind of +static variable. Since we intend to fix this bug, we don't want people +relying on this behavior. + +Instead, it's recommended one uses C<state> variables to achieve the +same effect: + + use 5.10.0; + sub count {state $counter; return ++ $counter} + say count (); # Prints 1 + say count (); # Prints 2 + +C<state> variables were introduced in Perl 5.10. + +Alternatively, you can achieve a similar static effect by +declaring the variable in a separate block outside the function, eg + + sub f { my $x if 0; return $x++ } + +becomes + + { my $x; sub f { return $x++ } } + +The use of C<my()> in a false conditional has been deprecated in +Perl 5.10, and it will become a fatal error in Perl 5.30. + + +=head3 Reading/writing bytes from/to :utf8 handles. + +The sysread(), recv(), syswrite() and send() operators are +deprecated on handles that have the C<:utf8> layer, either explicitly, or +implicitly, eg., with the C<:encoding(UTF-16LE)> layer. + +Both sysread() and recv() currently use only the C<:utf8> flag for the stream, +ignoring the actual layers. Since sysread() and recv() do no UTF-8 +validation they can end up creating invalidly encoded scalars. + +Similarly, syswrite() and send() use only the C<:utf8> flag, otherwise ignoring +any layers. If the flag is set, both write the value UTF-8 encoded, even if +the layer is some different encoding, such as the example above. + +Ideally, all of these operators would completely ignore the C<:utf8> state, +working only with bytes, but this would result in silently breaking existing +code. To avoid this a future version of perl will throw an exception when +any of sysread(), recv(), syswrite() or send() are called on handle with the +C<:utf8> layer. + +In Perl 5.30, it will no longer be possible to use sysread(), recv(), +syswrite() or send() to read or send bytes from/to :utf8 handles. =head2 Perl 5.28 @@ -218,6 +315,33 @@ C<use AutoLoader 'AUTOLOAD';>. This feature was deprecated in Perl 5.004, and will be fatal in Perl 5.28. +=head3 Use of C<< \cI<X> >> to specify a printable character. + +In a double quoted context, Perl has the C<< \c >> construct to write +control characters in a readable way. For instance, the tab character +can be written as C<< \cI >> (I<< control-I >>), and the escape +character can be written as C<< \c[ >>. + +Due to implementation details, the C<< \c >> construct can be used +to create regular, printable, characters as well. For instance, +C<< \c >> maps a C<< , >> to C<< l >>; that is C<< \c, >> is an +obscure way of writing C<< l >>. And not only that, it's also not +portable between ASCII and EBCDIC platforms. + +Using the C<< \c >> construct with an argument which maps to a +printable character was deprecated in Perl 5.14, and will be a fatal +error in Perl 5.28. You're recommended to just write the intended +character instead. + + +=head3 Use of code points over 0xFF in string bitwise operators + +The string bitwise operators, C<&>, C<|>, C<^>, and C<~>, treat +their operands as strings of bytes. As such, values above 0xFF +are nonsensical. Using such code points with these operators +was deprecated in Perl 5.24, and will be fatal in Perl 5.28. + + =head2 Perl 5.26 =head3 C<< --libpods >> in C<< Pod::Html >> @@ -248,6 +372,20 @@ was by documentation policy only. But this deprecation has been lifted in Perl 5.26. +=head3 Malformed UTF-8 string in "%s" + +This message indicates a bug either in the Perl core or in XS +code. Such code was trying to find out if a character, allegedly +stored internally encoded as UTF-8, was of a given type, such as +being punctuation or a digit. But the character was not encoded +in legal UTF-8. The C<%s> is replaced by a string that can be used +by knowledgeable people to determine what the type being checked +against was. + +Passing malformed strings was deprecated in Perl 5.18, and +became fatal in Perl 5.26. + + =head2 Perl 5.24 =head3 Use of C<< *glob{FILEHANDLE} >> diff --git a/pod/perldiag.pod b/pod/perldiag.pod index 4ae00e7258..3bd8d304e9 100644 --- a/pod/perldiag.pod +++ b/pod/perldiag.pod @@ -1539,7 +1539,7 @@ Perhaps you need to copy the value to a temporary, and repeat that. Note that ASCII characters that don't map to control characters are discouraged, and will generate the warning (when enabled) -L</""\c%c" is more clearly written simply as "%s"">. +L</""\c%c" is more clearly written simply as "%s". This will be a fatal error in Perl 5.28">. =item Character following \%c must be '{' or a single-character Unicode property name in regex; marked by <-- HERE in m/%s/ @@ -1646,13 +1646,15 @@ See L<charnames/CUSTOM ALIASES>. (W unopened) You tried chdir() on a filehandle that was never opened. -=item "\c%c" is more clearly written simply as "%s" +=item "\c%c" is more clearly written simply as "%s". This will be a fatal error in Perl 5.28 -(W syntax) The C<\cI<X>> construct is intended to be a way to specify -non-printable characters. You used it for a printable one, which -is better written as simply itself, perhaps preceded by a backslash -for non-word characters. Doing it the way you did is not portable -between ASCII and EBCDIC platforms. +(W deprecated, syntax) The C<\cI<X>> construct is intended to be a +way to specify non-printable characters. You used it for a printable +one, which is better written as simply itself, perhaps preceded by +a backslash for non-word characters. Doing it the way you did is +not portable between ASCII and EBCDIC platforms. + +This usage is going to result in a fatal error in Perl 5.28. =item Cloning substitution context is unimplemented @@ -1792,7 +1794,7 @@ usually indicates a syntax error in dereferencing the constant value. See L<perlsub/"Constant Functions"> and L<constant>. =item Constants from lexical variables potentially modified elsewhere are -deprecated +deprecated. This will not be allowed in Perl 5.32 (D deprecated) You wrote something like @@ -1811,8 +1813,8 @@ breaks the behavior of closures, in which the subroutine captures the variable itself, rather than its value, so future changes to the variable are reflected in the subroutine's return value. -This usage is deprecated, because the behavior is likely to change -in a future version of Perl. +This usage is deprecated, and will no longer be allowed in Perl 5.32, +making it possible to change the behavior in the future. If you intended for the subroutine to be eligible for inlining, then make sure the variable is not referenced elsewhere, possibly by @@ -1977,7 +1979,7 @@ or a hash or array slice, such as: long for Perl to handle. You have to be seriously twisted to write code that triggers this error. -=item Deprecated use of my() in false conditional +=item Deprecated use of my() in false conditional. This will be a fatal error in Perl 5.30 (D deprecated) You used a declaration similar to C<my $x if 0>. There has been a long-standing bug in Perl that causes a lexical variable @@ -1998,6 +2000,9 @@ lexicals that are initialized only once (see L<feature>): sub f { state $x; return $x++ } +This use of C<my()> in a false conditional has been deprecated since +Perl 5.10, and it will become a fatal error in Perl 5.30. + =item DESTROY created new reference to dead object '%s' (F) A DESTROY() method created a new reference to the object which is @@ -2075,10 +2080,15 @@ something that isn't defined yet, you don't actually have to define the subroutine or package before the current location. You can use an empty "sub foo;" or "package FOO;" to enter a "forward" declaration. -=item dump() better written as CORE::dump() +=item dump() better written as CORE::dump(). dump() will no longer be available in Perl 5.30 + +(D deprecated, misc) You used the obsolescent C<dump()> built-in function, +without fully qualifying it as C<CORE::dump()>. Maybe it's a typo. -(W misc) You used the obsolescent C<dump()> built-in function, without fully -qualifying it as C<CORE::dump()>. Maybe it's a typo. See L<perlfunc/dump>. +Use of a unqualified C<dump()> was deprecated in Perl 5.30, and this +will not be available in Perl 5.30. + +See L<perlfunc/dump>. =item dump is not supported @@ -3102,7 +3112,7 @@ neither as a system call nor an ioctl call (SIOCATMARK). Perl. The current valid ones are given in L<perlrebackslash/\b{}, \b, \B{}, \B>. -=item %s() is deprecated on :utf8 handles +=item %s() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 (D deprecated) The sysread(), recv(), syswrite() and send() operators are deprecated on handles that have the C<:utf8> layer, either explicitly, or @@ -3118,17 +3128,18 @@ the layer is some different encoding, such as the example above. Ideally, all of these operators would completely ignore the C<:utf8> state, working only with bytes, but this would result in silently breaking existing -code. To avoid this a future version of perl will throw an exception when -any of sysread(), recv(), syswrite() or send() are called on handle with the -C<:utf8> layer. +code. -=item "%s" is more clearly written simply as "%s" in regex; marked by S<<-- HERE> in m/%s/ +In Perl 5.30, it will no longer be possible to use sysread(), recv(), +syswrite() or send() to read or send bytes from/to :utf8 handles. -(W regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) +=item "%s" is more clearly written simply as "%s" in regex. This will be a fatal error in Perl 5.28; marked by S<<-- HERE> in m/%s/ + +(W deprecated, regexp) (only under C<S<use re 'strict'>> or within C<(?[...])>) You specified a character that has the given plainer way of writing it, and which is also portable to platforms running with different character -sets. +sets. This usage is deprecated, and will be a fatal error in Perl 5.28. =item '%s' is not a code reference @@ -3403,6 +3414,19 @@ rules and perl was unable to guess how to make more progress. (F) You tried to unpack something that didn't comply with UTF-8 encoding rules and perl was unable to guess how to make more progress. +=item Malformed UTF-8 string in "%s" + +(F) This message indicates a bug either in the Perl core or in XS +code. Such code was trying to find out if a character, allegedly +stored internally encoded as UTF-8, was of a given type, such as +being punctuation or a digit. But the character was not encoded +in legal UTF-8. The C<%s> is replaced by a string that can be used +by knowledgeable people to determine what the type being checked +against was. + +Passing malformed strings was deprecated in Perl 5.18, and +became fatal in Perl 5.26. + =item Malformed UTF-16 surrogate (F) Perl thought it was reading UTF-16 encoded character data but while @@ -4666,17 +4690,6 @@ Remember that "my", "our", "local" and "state" bind tighter than comma. (F) Parsing code supplied by an extension violated the parser's API in a detectable way. -=item Passing malformed UTF-8 to "%s" is deprecated - -(D deprecated, utf8) This message indicates a bug either in the Perl -core or in XS code. Such code was trying to find out if a character, -allegedly stored internally encoded as UTF-8, was of a given type, such -as being punctuation or a digit. But the character was not encoded in -legal UTF-8. The C<%s> is replaced by a string that can be used by -knowledgeable people to determine what the type being checked against -was. If C<utf8> warnings are enabled, a further message is raised, -giving details of the malformation. - =item Pattern subroutine nesting without pos change exceeded limit in regex (F) You used a pattern that uses too many nested subpattern calls without @@ -7041,13 +7054,15 @@ its behavior may change or even be removed in any future release of perl. See the explanation under L<perlvar/$_>. =item Use of strings with code points over 0xFF as arguments to %s -operator is deprecated +operator is deprecated. This will be a fatal error in Perl 5.28 (D deprecated) You tried to use one of the string bitwise operators (C<&> or C<|> or C<^> or C<~>) on a string containing a code point over 0xFF. The string bitwise operators treat their operands as strings of bytes, and values beyond 0xFF are nonsensical in this context. +Such usage will be a fatal error in Perl 5.28. + =item Use of tainted arguments in %s is deprecated (W taint, deprecated) You have supplied C<system()> or C<exec()> with multiple diff --git a/pod/perlport.pod b/pod/perlport.pod index cc47774fe9..c03e279be4 100644 --- a/pod/perlport.pod +++ b/pod/perlport.pod @@ -984,6 +984,29 @@ The very portable L<C<POSIX::uname()>|POSIX/C<uname>> will work too: c:\> perl -MPOSIX -we "print join '|', uname" Windows NT|moonru|5.0|Build 2195 (Service Pack 2)|x86 +Errors set by Winsock functions are now put directly into C<$^E>, +and the relevant C<WSAE*> error codes are now exported from the +L<Errno> and L<POSIX> modules for testing this against. + +The previous behavior of putting the errors (converted to POSIX-style +C<E*> error codes since Perl 5.20.0) into C<$!> was buggy due to +the non-equivalence of like-named Winsock and POSIX error constants, +a relationship between which has unfortunately been established +in one way or another since Perl 5.8.0. + +The new behavior provides a much more robust solution for checking +Winsock errors in portable software without accidentally matching +POSIX tests that were intended for other OSes and may have different +meanings for Winsock. + +The old behavior is currently retained, warts and all, for backwards +compatibility, but users are encouraged to change any code that +tests C<$!> against C<E*> constants for Winsock errors to instead +test C<$^E> against C<WSAE*> constants. After a suitable deprecation +period, which started with Perl 5.24, the old behavior may be +removed, leaving C<$!> unchanged after Winsock function calls, to +avoid any possible confusion over which error variable to check. + Also see: =over 4 @@ -2496,7 +2519,7 @@ L<perlunicode>, L<perlvms>, L<perlvos>, L<perlwin32>, and L<Win32>. =head1 AUTHORS / CONTRIBUTORS -Abigail <[email protected]>, +Abigail <[email protected]>, Charles Bailey <[email protected]>, Graham Barr <[email protected]>, Tom Christiansen <[email protected]>, diff --git a/pp_sys.c b/pp_sys.c index 65d0178275..35afd495d2 100644 --- a/pp_sys.c +++ b/pp_sys.c @@ -1719,7 +1719,8 @@ PP(pp_sysread) if ((fp_utf8 = PerlIO_isutf8(IoIFP(io))) && !IN_BYTES) { if (PL_op->op_type == OP_SYSREAD || PL_op->op_type == OP_RECV) { Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED), - "%s() is deprecated on :utf8 handles", + "%s() is deprecated on :utf8 handles. " + "This will be a fatal error in Perl 5.30", OP_DESC(PL_op)); } buffer = SvPVutf8_force(bufsv, blen); @@ -1982,7 +1983,8 @@ PP(pp_syswrite) if (PerlIO_isutf8(IoIFP(io))) { Perl_ck_warner_d(aTHX_ packWARN(WARN_DEPRECATED), - "%s() is deprecated on :utf8 handles", + "%s() is deprecated on :utf8 handles. " + "This will be a fatal error in Perl 5.30", OP_DESC(PL_op)); if (!SvUTF8(bufsv)) { /* We don't modify the original scalar. */ diff --git a/regcomp.c b/regcomp.c index 91a2792567..ee0a24f7cf 100644 --- a/regcomp.c +++ b/regcomp.c @@ -823,6 +823,13 @@ static const scan_data_t zero_scan_data = REPORT_LOCATION_ARGS(loc)); \ } STMT_END +#define vWARN4dep(loc, m, a1, a2, a3) STMT_START { \ + __ASSERT_(PASS2) Perl_warner(aTHX_ packWARN2(WARN_REGEXP,WARN_DEPRECATED), \ + m REPORT_LOCATION, \ + a1, a2, a3, \ + REPORT_LOCATION_ARGS(loc)); \ +} STMT_END + #define ckWARN4reg(loc, m, a1, a2, a3) STMT_START { \ __ASSERT_(PASS2) Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), \ m REPORT_LOCATION, \ @@ -16875,20 +16882,22 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, literal[d++] = (char) value; literal[d++] = '\0'; - vWARN4(RExC_parse, - "\"%.*s\" is more clearly written simply as \"%s\"", + vWARN4dep(RExC_parse, + "\"%.*s\" is more clearly written simply as \"%s\". " + "This will be a fatal error in Perl 5.28", (int) (RExC_parse - rangebegin), rangebegin, literal - ); + ); } else if isMNEMONIC_CNTRL(value) { - vWARN4(RExC_parse, - "\"%.*s\" is more clearly written simply as \"%s\"", + vWARN4dep(RExC_parse, + "\"%.*s\" is more clearly written simply as \"%s\". " + "This will be a fatal error in Perl 5.28", (int) (RExC_parse - rangebegin), rangebegin, cntrl_to_mnemonic((U8) value) - ); + ); } } } diff --git a/t/lib/croak/pp_ctl b/t/lib/croak/pp_ctl index ee1edbaffa..ec664138e0 100644 --- a/t/lib/croak/pp_ctl +++ b/t/lib/croak/pp_ctl @@ -1,9 +1,10 @@ __END__ # NAME dump with computed label +no warnings 'deprecated'; my $label = "foo"; dump $label; EXPECT -Can't find label foo at - line 2. +Can't find label foo at - line 3. ######## # NAME when outside given use 5.01; no warnings 'experimental::smartmatch'; diff --git a/t/lib/warnings/doop b/t/lib/warnings/doop index bcc85a365a..a62bc23b0f 100644 --- a/t/lib/warnings/doop +++ b/t/lib/warnings/doop @@ -26,12 +26,12 @@ $_ = "\x{100}" & "\x{103}"; $_ = "\x{101}" | "\x{104}"; $_ = "\x{102}" ^ "\x{105}"; EXPECT -Use of strings with code points over 0xFF as arguments to bitwise and (&) operator is deprecated at - line 1. -Use of strings with code points over 0xFF as arguments to bitwise or (|) operator is deprecated at - line 2. -Use of strings with code points over 0xFF as arguments to bitwise xor (^) operator is deprecated at - line 3. -Use of strings with code points over 0xFF as arguments to bitwise and (&) operator is deprecated at - line 4. -Use of strings with code points over 0xFF as arguments to bitwise or (|) operator is deprecated at - line 5. -Use of strings with code points over 0xFF as arguments to bitwise xor (^) operator is deprecated at - line 6. -Use of strings with code points over 0xFF as arguments to bitwise and (&) operator is deprecated at - line 7. -Use of strings with code points over 0xFF as arguments to bitwise or (|) operator is deprecated at - line 8. -Use of strings with code points over 0xFF as arguments to bitwise xor (^) operator is deprecated at - line 9. +Use of strings with code points over 0xFF as arguments to bitwise and (&) operator is deprecated. This will be a fatal error in Perl 5.28 at - line 1. +Use of strings with code points over 0xFF as arguments to bitwise or (|) operator is deprecated. This will be a fatal error in Perl 5.28 at - line 2. +Use of strings with code points over 0xFF as arguments to bitwise xor (^) operator is deprecated. This will be a fatal error in Perl 5.28 at - line 3. +Use of strings with code points over 0xFF as arguments to bitwise and (&) operator is deprecated. This will be a fatal error in Perl 5.28 at - line 4. +Use of strings with code points over 0xFF as arguments to bitwise or (|) operator is deprecated. This will be a fatal error in Perl 5.28 at - line 5. +Use of strings with code points over 0xFF as arguments to bitwise xor (^) operator is deprecated. This will be a fatal error in Perl 5.28 at - line 6. +Use of strings with code points over 0xFF as arguments to bitwise and (&) operator is deprecated. This will be a fatal error in Perl 5.28 at - line 7. +Use of strings with code points over 0xFF as arguments to bitwise or (|) operator is deprecated. This will be a fatal error in Perl 5.28 at - line 8. +Use of strings with code points over 0xFF as arguments to bitwise xor (^) operator is deprecated. This will be a fatal error in Perl 5.28 at - line 9. diff --git a/t/lib/warnings/op b/t/lib/warnings/op index e8d93e8a8c..92fa04e072 100644 --- a/t/lib/warnings/op +++ b/t/lib/warnings/op @@ -1766,13 +1766,13 @@ if (my $w2) { $a=1 } if ($a && (my $w3 = 1)) {$a = 2} EXPECT -Deprecated use of my() in false conditional at - line 2. -Deprecated use of my() in false conditional at - line 3. -Deprecated use of my() in false conditional at - line 4. -Deprecated use of my() in false conditional at - line 5. -Deprecated use of my() in false conditional at - line 6. -Deprecated use of my() in false conditional at - line 7. -Deprecated use of my() in false conditional at - line 8. +Deprecated use of my() in false conditional. This will be a fatal error in Perl 5.30 at - line 2. +Deprecated use of my() in false conditional. This will be a fatal error in Perl 5.30 at - line 3. +Deprecated use of my() in false conditional. This will be a fatal error in Perl 5.30 at - line 4. +Deprecated use of my() in false conditional. This will be a fatal error in Perl 5.30 at - line 5. +Deprecated use of my() in false conditional. This will be a fatal error in Perl 5.30 at - line 6. +Deprecated use of my() in false conditional. This will be a fatal error in Perl 5.30 at - line 7. +Deprecated use of my() in false conditional. This will be a fatal error in Perl 5.30 at - line 8. ######## # op.c $[ = 1; diff --git a/t/lib/warnings/pp b/t/lib/warnings/pp index defa3986b3..27629a7d29 100644 --- a/t/lib/warnings/pp +++ b/t/lib/warnings/pp @@ -21,7 +21,7 @@ Constant subroutine (anonymous) undefined $foo = sub () { 3 }; undef &$foo; - Use of strings with code points over 0xFF as arguments to 1's complement (~) operator is deprecated + Use of strings with code points over 0xFF as arguments to 1's complement (~) operator is deprecated. This will be a fatal error in Perl 5.28 Invalid negative number (%s) in chr @@ -138,7 +138,7 @@ $_ = ~ "\xff"; $_ = ~ "\x{100}"; EXPECT OPTION regex -Use of strings with code points over 0xFF as arguments to 1's complement \(~\) operator is deprecated at - line \d+. +Use of strings with code points over 0xFF as arguments to 1's complement \(~\) operator is deprecated. This will be a fatal error in Perl 5.28 at - line \d+. Use of code point 0xFF+EFF is deprecated; the permissible max is 0x7F+\. This will be fatal in Perl 5\.28 at - line \d+. ######## # NAME chr -1 diff --git a/t/lib/warnings/pp_sys b/t/lib/warnings/pp_sys index cf0998d6f6..9c544e088b 100644 --- a/t/lib/warnings/pp_sys +++ b/t/lib/warnings/pp_sys @@ -958,7 +958,7 @@ sysread $fh, $buf, 10; no warnings 'deprecated'; sysread $fh, $buf, 10; EXPECT -sysread() is deprecated on :utf8 handles at - line 5. +sysread() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 at - line 5. ######## # NAME syswrite() deprecated on :utf8 my $file = "syswwarn.tmp"; @@ -971,4 +971,4 @@ syswrite $fh, 'ABC'; close $fh; unlink $file; EXPECT -syswrite() is deprecated on :utf8 handles at - line 5. +syswrite() is deprecated on :utf8 handles. This will be a fatal error in Perl 5.30 at - line 5. diff --git a/t/lib/warnings/regcomp b/t/lib/warnings/regcomp index 2b084c59b0..44ef5c3e4e 100644 --- a/t/lib/warnings/regcomp +++ b/t/lib/warnings/regcomp @@ -31,12 +31,12 @@ BEGIN { use warnings; $a = qr/\c,/; $a = qr/[\c,]/; -no warnings 'syntax'; +no warnings 'syntax', 'deprecated'; $a = qr/\c,/; $a = qr/[\c,]/; EXPECT -"\c," is more clearly written simply as "l" at - line 9. -"\c," is more clearly written simply as "l" at - line 10. +"\c," is more clearly written simply as "l". This will be a fatal error in Perl 5.28 at - line 9. +"\c," is more clearly written simply as "l". This will be a fatal error in Perl 5.28 at - line 10. ######## # This is because currently a different error is output under # use re 'strict', so can't go in reg_mesg.t diff --git a/t/lib/warnings/toke b/t/lib/warnings/toke index 4102909bcf..e092aed119 100644 --- a/t/lib/warnings/toke +++ b/t/lib/warnings/toke @@ -1078,11 +1078,28 @@ Integer overflow in octal number at - line 11. ######## # toke.c BEGIN { $^C = 1; } +dump; +CORE::dump; +EXPECT +dump() better written as CORE::dump(). dump() will no longer be available in Perl 5.30 at - line 3. +- syntax OK +######## +# toke.c +BEGIN { $^C = 1; } +no warnings 'deprecated'; +dump; +CORE::dump; +EXPECT +- syntax OK +######## +# toke.c +BEGIN { $^C = 1; } +no warnings 'deprecated'; use warnings 'misc'; dump; CORE::dump; EXPECT -dump() better written as CORE::dump() at - line 4. +dump() better written as CORE::dump(). dump() will no longer be available in Perl 5.30 at - line 5. - syntax OK ######## # toke.c @@ -1340,12 +1357,12 @@ BEGIN { use warnings; $a = "\c,"; $a = "\c`"; -no warnings 'syntax'; +no warnings 'syntax', 'deprecated'; $a = "\c,"; $a = "\c`"; EXPECT -"\c," is more clearly written simply as "l" at - line 9. -"\c`" is more clearly written simply as "\ " at - line 10. +"\c," is more clearly written simply as "l". This will be a fatal error in Perl 5.28 at - line 9. +"\c`" is more clearly written simply as "\ ". This will be a fatal error in Perl 5.28 at - line 10. ######## # toke.c BEGIN { diff --git a/t/op/const-optree.t b/t/op/const-optree.t index b378d4a53c..4d897d247e 100644 --- a/t/op/const-optree.t +++ b/t/op/const-optree.t @@ -432,7 +432,8 @@ for \%_ (@tests) { if (exists $_{deprecated}) { if ($_{deprecated}) { like $w, qr/^Constants from lexical variables potentially (?x: - )modified elsewhere are deprecated at /, + )modified elsewhere are deprecated\. This will (?x: + )not be allowed in Perl 5\.32 at /, "$nickname is deprecated"; } else { diff --git a/t/op/dump.t b/t/op/dump.t index 6b53a0687b..2edba2035c 100644 --- a/t/op/dump.t +++ b/t/op/dump.t @@ -63,7 +63,13 @@ plan(2); # By do the dump in a child, the parent perl process exits back to sh with # a normal exit value, so sh won't complain. +# An unqualified dump() will give a deprecation warning. Usually, we'd +# do a "no warnings 'deprecated'" to shut this off, but since we have +# chdirred to /tmp, a 'no' won't find the pragma. Hence the fiddling with +# $SIG{__WARN__}. + fresh_perl_like(<<'PROG', qr/\AA(?!B\z)/, {}, "plain dump quits"); +BEGIN {$SIG {__WARN__} = sub {1;}} ++$|; my $pid = fork; die "fork: $!\n" unless defined $pid; @@ -80,6 +86,7 @@ else { PROG fresh_perl_like(<<'PROG', qr/A(?!B\z)/, {}, "dump with label quits"); +BEGIN {$SIG {__WARN__} = sub {1;}} ++$|; my $pid = fork; die "fork: $!\n" unless defined $pid; diff --git a/t/op/lex.t b/t/op/lex.t index df96ed745d..af763392f8 100644 --- a/t/op/lex.t +++ b/t/op/lex.t @@ -267,7 +267,7 @@ SKIP: ); fresh_perl_like( qq(BEGIN{\$^H=0x800000}\n 0m 0\xB5\xB500\xB5\0), - qr/Unrecognized character \\x\{0\}; marked by <-- HERE after 0m.*<-- HERE near column 12 at - line 2./, + qr/Malformed UTF-8 string in "XPosixWord" at - line 2./, {}, '[perl #129000] read before buffer' ); diff --git a/t/re/reg_mesg.t b/t/re/reg_mesg.t index 1c26650c25..c6951b408c 100644 --- a/t/re/reg_mesg.t +++ b/t/re/reg_mesg.t @@ -520,10 +520,10 @@ my @warning = ( ], '/a{1,1}?\x{100}/' => 'Useless use of greediness modifier \'?\' {#} m/a{1,1}?{#}\x{100}/', "/(?[ [ % - % ] ])/" => "", - "/(?[ [ : - \\x$colon_hex ] ])\\x{100}/" => "\": - \\x$colon_hex \" is more clearly written simply as \":\" {#} m/(?[ [ : - \\x$colon_hex {#}] ])\\x{100}/", - "/(?[ [ \\x$colon_hex - : ] ])\\x{100}/" => "\"\\x$colon_hex\ - : \" is more clearly written simply as \":\" {#} m/(?[ [ \\x$colon_hex - : {#}] ])\\x{100}/", - "/(?[ [ \\t - \\x$tab_hex ] ])\\x{100}/" => "\"\\t - \\x$tab_hex \" is more clearly written simply as \"\\t\" {#} m/(?[ [ \\t - \\x$tab_hex {#}] ])\\x{100}/", - "/(?[ [ \\x$tab_hex - \\t ] ])\\x{100}/" => "\"\\x$tab_hex\ - \\t \" is more clearly written simply as \"\\t\" {#} m/(?[ [ \\x$tab_hex - \\t {#}] ])\\x{100}/", + "/(?[ [ : - \\x$colon_hex ] ])\\x{100}/" => "\": - \\x$colon_hex \" is more clearly written simply as \":\". This will be a fatal error in Perl 5.28 {#} m/(?[ [ : - \\x$colon_hex {#}] ])\\x{100}/ ... [2 chars truncated] + "/(?[ [ \\x$colon_hex - : ] ])\\x{100}/" => "\"\\x$colon_hex\ - : \" is more clearly written simply as \":\". This will be a fatal error in Perl 5.28 {#} m/(?[ [ \\x$colon_hex - : {#}] ])\\x{100} ... [3 chars truncated] + "/(?[ [ \\t - \\x$tab_hex ] ])\\x{100}/" => "\"\\t - \\x$tab_hex \" is more clearly written simply as \"\\t\". This will be a fatal error in Perl 5.28 {#} m/(?[ [ \\t - \\x$tab_hex {#}] ])\\x{100 ... [4 chars truncated] + "/(?[ [ \\x$tab_hex - \\t ] ])\\x{100}/" => "\"\\x$tab_hex\ - \\t \" is more clearly written simply as \"\\t\". This will be a fatal error in Perl 5.28 {#} m/(?[ [ \\x$tab_hex - \\t {#}] ])\\x{10 ... [5 chars truncated] "/(?[ [ $B_hex - C ] ])/" => "Ranges of ASCII printables should be some subset of \"0-9\", \"A-Z\", or \"a-z\" {#} m/(?[ [ $B_hex - C {#}] ])/", "/(?[ [ A - $B_hex ] ])/" => "Ranges of ASCII printables should be some subset of \"0-9\", \"A-Z\", or \"a-z\" {#} m/(?[ [ A - $B_hex {#}] ])/", "/(?[ [ $low_mixed_alpha - $high_mixed_alpha ] ])/" => "Ranges of ASCII printables should be some subset of \"0-9\", \"A-Z\", or \"a-z\" {#} m/(?[ [ $low_mixed_alpha - $high_mixed_alpha {#}] ])/" ... [1 chars truncated] @@ -598,10 +598,10 @@ my @warning_only_under_strict = ( '/[\N{U+FF}-\x{100}]/' => 'Both or neither range ends should be Unicode {#} m/[\N{U+FF}-\x{100}{#}]/', '/[\N{U+100}-\x{101}]/' => "", "/[%-%]/" => "", - "/[:-\\x$colon_hex]\\x{100}/" => "\":-\\x$colon_hex\" is more clearly written simply as \":\" {#} m/[:-\\x$colon_hex\{#}]\\x{100}/", - "/[\\x$colon_hex-:]\\x{100}/" => "\"\\x$colon_hex-:\" is more clearly written simply as \":\" {#} m/[\\x$colon_hex\-:{#}]\\x{100}/", - "/[\\t-\\x$tab_hex]\\x{100}/" => "\"\\t-\\x$tab_hex\" is more clearly written simply as \"\\t\" {#} m/[\\t-\\x$tab_hex\{#}]\\x{100}/", - "/[\\x$tab_hex-\\t]\\x{100}/" => "\"\\x$tab_hex-\\t\" is more clearly written simply as \"\\t\" {#} m/[\\x$tab_hex\-\\t{#}]\\x{100}/", + "/[:-\\x$colon_hex]\\x{100}/" => "\":-\\x$colon_hex\" is more clearly written simply as \":\". This will be a fatal error in Perl 5.28 {#} m/[:-\\x$colon_hex\{#}]\\x{100}/", + "/[\\x$colon_hex-:]\\x{100}/" => "\"\\x$colon_hex-:\" is more clearly written simply as \":\". This will be a fatal error in Perl 5.28 {#} m/[\\x$colon_hex\-:{#}]\\x{100}/", + "/[\\t-\\x$tab_hex]\\x{100}/" => "\"\\t-\\x$tab_hex\" is more clearly written simply as \"\\t\". This will be a fatal error in Perl 5.28 {#} m/[\\t-\\x$tab_hex\{#}]\\x{100}/", + "/[\\x$tab_hex-\\t]\\x{100}/" => "\"\\x$tab_hex-\\t\" is more clearly written simply as \"\\t\". This will be a fatal error in Perl 5.28 {#} m/[\\x$tab_hex\-\\t{#}]\\x{100}/", "/[$B_hex-C]/" => "Ranges of ASCII printables should be some subset of \"0-9\", \"A-Z\", or \"a-z\" {#} m/[$B_hex-C{#}]/", "/[A-$B_hex]/" => "Ranges of ASCII printables should be some subset of \"0-9\", \"A-Z\", or \"a-z\" {#} m/[A-$B_hex\{#}]/", "/[$low_mixed_alpha-$high_mixed_alpha]/" => "Ranges of ASCII printables should be some subset of \"0-9\", \"A-Z\", or \"a-z\" {#} m/[$low_mixed_alpha-$high_mixed_alpha\{#}]/", diff --git a/t/uni/variables.t b/t/uni/variables.t index edeebf45ff..1e85983d90 100644 --- a/t/uni/variables.t +++ b/t/uni/variables.t @@ -130,8 +130,13 @@ for ( 0x0 .. 0xff ) { "$name as a length-1 variable generates a syntax error"); $tests++; utf8::upgrade($chr); + # + # These characters are malformed UTF-8. This will croak + # in an earlier stage. + # evalbytes "no strict; use utf8; \$$chr = 4;", - like($@, qr/ syntax\ error | Unrecognized\ character /x, + like($@, qr/ syntax\ error | Unrecognized\ character | + Malformed\ UTF-8\ string\ in /x, " ... and the same under 'use utf8'"); $tests++; } diff --git a/toke.c b/toke.c index b5f8685b9e..edd6f55f43 100644 --- a/toke.c +++ b/toke.c @@ -6894,8 +6894,10 @@ Perl_yylex(pTHX) else { /* no override */ tmp = -tmp; if (tmp == KEY_dump) { - Perl_ck_warner(aTHX_ packWARN(WARN_MISC), - "dump() better written as CORE::dump()"); + Perl_ck_warner_d(aTHX_ packWARN2(WARN_MISC,WARN_DEPRECATED), + "dump() better written as CORE::dump(). " + "dump() will no longer be available " + "in Perl 5.30"); } gv = NULL; gvp = 0; diff --git a/utf8.c b/utf8.c index 0a1136407c..e5b26eaf8d 100644 --- a/utf8.c +++ b/utf8.c @@ -2361,15 +2361,7 @@ S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, * character without reading beyond the end, and pass that number on to the * validating routine */ if (! isUTF8_CHAR(p, p + UTF8SKIP(p))) { - if (ckWARN_d(WARN_UTF8)) { - Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED,WARN_UTF8), - "Passing malformed UTF-8 to \"%s\" is deprecated", swashname); - if (ckWARN(WARN_UTF8)) { /* This will output details as to the - what the malformation is */ - utf8_to_uvchr_buf(p, p + UTF8SKIP(p), NULL); - } - } - return FALSE; + Perl_croak (aTHX_ "Malformed UTF-8 string in \"%s\"", swashname); } if (!*swash) { U8 flags = _CORE_SWASH_INIT_ACCEPT_INVLIST; -- Perl5 Master Repository
