From patchwork Mon Nov 13 11:50:14 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jakub Jelinek X-Patchwork-Id: 164439 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:b909:0:b0:403:3b70:6f57 with SMTP id t9csp1145879vqg; Mon, 13 Nov 2023 03:50:46 -0800 (PST) X-Google-Smtp-Source: AGHT+IGxGwFKTrLTkDvreL3Rmetmq6avkwjTBxWWdbNZGsE0XouL+cVfiCPBYAj3U3sLC71eZuwQ X-Received: by 2002:a05:622a:14c8:b0:418:1588:2653 with SMTP id u8-20020a05622a14c800b0041815882653mr9165042qtx.12.1699876246154; Mon, 13 Nov 2023 03:50:46 -0800 (PST) ARC-Seal: i=2; a=rsa-sha256; t=1699876246; cv=pass; d=google.com; s=arc-20160816; b=EqQChuQF03OYEx+TmiwaBWx4KLApbSLIt+9gutBim+766nfPj2/UJbsfETZt+TMOm/ j05ytNGBZ1iggvfiqLaUz/abCluhU8HO0Q5vG0P09blLO82J8mL1qH9d7BhuPnOVmVE7 AlmpsEPmM7tX0Y3H81JDLaoKKS0PcbdwLU2/dacrCUFdAcujWAjnV95gzIqScrg2nYs7 vb05rloXMMEWHxKELNJBNG1PwAYYoYctoPy0WjzEymBEJS4e66L47qL1WqTBsqeSr/FV LIoeYHGrMHEpj2ofLeiYUcNkSWhgjHTtl8K1DYlGxiuGcqHTvJ0JLTFB0Ein0Tc37hOC a9Zw== ARC-Message-Signature: i=2; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:reply-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-disposition :mime-version:message-id:subject:cc:to:from:date:dkim-signature :arc-filter:dmarc-filter:delivered-to; bh=VCPxxstRvlekmg/bu7DtjH2o3Bh+tnTMVNhsV63wQ/A=; fh=drb8jPahgz959MrupsiUi8XeCFozkYVF0F6zLW2CcMA=; b=ryrLZt3L6t0stT8BgM1IcZph5LcfUo7wNej8uUOU5eYy96nj1OgkQcT+WKvL6/AC6Q FDhkYEFUgYeO/EroSxYTbfmb+wlODMWb5vl3l933GAt59ntgHxrCtgzzgfNkTDKz1zrW LANy0/qZ7BQ8H/lhpD8yuS9rihhWYqjluSv0IKUoTGWIr+1zd8VT2JCC0LLwhsXMQkm4 uB5gjyaejs2JSheg5kb4oPnyx9xf04KojAuzviEqLSC58y1+ZSRiDzvNFyMmbdeLj6Kx twHeqf12YbbP/TXcsL4kWRDCUx3O+eZbE383YI9s2nljxwLbEx/7+E7IASSrFtsCaL4x BCpQ== ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@redhat.com header.s=mimecast20190719 header.b=OvnSrY+F; arc=pass (i=1); spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Received: from server2.sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id b12-20020ac85bcc000000b0041b7738ff49si4124728qtb.364.2023.11.13.03.50.46 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 13 Nov 2023 03:50:46 -0800 (PST) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@redhat.com header.s=mimecast20190719 header.b=OvnSrY+F; arc=pass (i=1); spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=redhat.com Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id BA5BB385C6F8 for ; Mon, 13 Nov 2023 11:50:45 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id 138D23858428 for ; Mon, 13 Nov 2023 11:50:20 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 138D23858428 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 138D23858428 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1699876223; cv=none; b=UwaO6xWy33Lizn4GAbUndFs9jTnl3Ry4zezAXmaO0rxNn+b9aRqX0cVoCMajNAxIVuVT4uzNTJSbkG0zJbvNTkUNY0sjhIuH7CthAb5IrZMBT6xcYTAWt/tAFVcD+UYt6/TieQKPyufbC5Ek1LA12TWEwAtVjmE8xyzg7DQY1ZE= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1699876223; c=relaxed/simple; bh=MMgr4DPrm8MkGwT5EmG0cpkBXAdN0FoFExvHZ+YR7js=; h=DKIM-Signature:Date:From:To:Subject:Message-ID:MIME-Version; b=w87hblHyalPoYwsuk5HMEsaDfy7pLSvc4iEKgJFuDLNwWiY9AcdOk/6D/I6xiu9zbsAz0CRbqMe3mEuDxGvEIcEZi9sFuV7zfmEGXC4uA2B6/ZWkXC17tpoJ8knUE57dTAP+fbxpCimBpu5f17kldWsVi7vuthMXictp5IGQ4o8= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1699876219; h=from:from:reply-to:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type; bh=VCPxxstRvlekmg/bu7DtjH2o3Bh+tnTMVNhsV63wQ/A=; b=OvnSrY+F3tn6j94HPeEsfDvEBEedJP6E5DdxV2qeFqbyA08KIb6yszOOBtEZRASrHnw1fk 6xe0Z5NQWa6FIuGuKZjYqEejDgU9RHFTG89Tiu9ClXxnuZDbrlBdwpBzCZCy+gevATNtK5 1xV4xd1Q9i8wqQOSzAGNoI+eJR2IkLY= Received: from mimecast-mx02.redhat.com (mimecast-mx02.redhat.com [66.187.233.88]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-127-Snh6OZjrME69STEwrYsGJg-1; Mon, 13 Nov 2023 06:50:18 -0500 X-MC-Unique: Snh6OZjrME69STEwrYsGJg-1 Received: from smtp.corp.redhat.com (int-mx10.intmail.prod.int.rdu2.redhat.com [10.11.54.10]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mimecast-mx02.redhat.com (Postfix) with ESMTPS id EFBE2185A780 for ; Mon, 13 Nov 2023 11:50:17 +0000 (UTC) Received: from tucnak.zalov.cz (unknown [10.39.194.53]) by smtp.corp.redhat.com (Postfix) with ESMTPS id 8A9F0492BFD; Mon, 13 Nov 2023 11:50:17 +0000 (UTC) Received: from tucnak.zalov.cz (localhost [127.0.0.1]) by tucnak.zalov.cz (8.17.1/8.17.1) with ESMTPS id 3ADBoEY74036672 (version=TLSv1.3 cipher=TLS_AES_256_GCM_SHA384 bits=256 verify=NOT); Mon, 13 Nov 2023 12:50:15 +0100 Received: (from jakub@localhost) by tucnak.zalov.cz (8.17.1/8.17.1/Submit) id 3ADBoEWj4036671; Mon, 13 Nov 2023 12:50:14 +0100 Date: Mon, 13 Nov 2023 12:50:14 +0100 From: Jakub Jelinek To: Jason Merrill Cc: gcc-patches@gcc.gnu.org, Marek Polacek Subject: [PATCH] c++: Implement C++26 P2864R2 - Remove Deprecated Arithmetic Conversion on Enumerations From C++26 Message-ID: MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.4.1 on 10.11.54.10 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Disposition: inline X-Spam-Status: No, score=-3.1 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, KAM_NUMSUBJECT, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: Jakub Jelinek Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1782449435052714101 X-GMAIL-MSGID: 1782449435052714101 Hi! The following patch implements C++26 P2864R2 by emitting pedwarn enabled by the same options as the C++20 and later warnings (i.e. -Wenum-compare, -Wdeprecated-enum-enum-conversion and -Wdeprecated-enum-float-conversion which are all enabled by default). I think we still want to allow users some option workaround, so am not using directly error, but if that is what you want instead, I can change it. Tested on x86_64-linux with GXX_TESTSUITE_STDS=98,11,14,17,20,23,2c, ok for trunk? 2023-11-13 Jakub Jelinek gcc/cp/ * typeck.cc: Implement C++26 P2864R2 - Remove Deprecated Arithmetic Conversion on Enumerations From C++26. (do_warn_enum_conversions): Use pedwarn rather than warning_at for C++26 and remove " is deprecated" part of the diagnostics in that case. (cp_build_binary_op): For C++26 call do_warn_enum_conversions for complain & tf_warning_or_error. * call.cc (build_conditional_expr): Use pedwarn rather than warning_at for C++26 and remove " is deprecated" part of the diagnostics in that case and check for complain & tf_warning_or_error. Use emit_diagnostic with cxx_dialect >= cxx26 ? DK_PEDWARN : DK_WARNING. (build_new_op): Use emit_diagnostic with cxx_dialect >= cxx26 ? DK_PEDWARN : DK_WARNING and complain & tf_warning_or_error check for C++26. gcc/testsuite/ * g++.dg/cpp2a/enum-conv1.C: Adjust expected diagnostics in C++26. * g++.dg/diagnostic/enum3.C: Likewise. * g++.dg/parse/attr3.C: Likewise. * g++.dg/cpp0x/linkage2.C: Likewise. Jakub --- gcc/cp/typeck.cc.jj 2023-11-02 07:49:16.135878656 +0100 +++ gcc/cp/typeck.cc 2023-11-13 11:03:42.869760702 +0100 @@ -4976,13 +4976,21 @@ do_warn_enum_conversions (location_t loc case BIT_AND_EXPR: case BIT_IOR_EXPR: case BIT_XOR_EXPR: - warning_at (loc, opt, "bitwise operation between different " - "enumeration types %qT and %qT is deprecated", - type0, type1); + if (cxx_dialect >= cxx26) + pedwarn (loc, opt, "bitwise operation between different " + "enumeration types %qT and %qT", type0, type1); + else + warning_at (loc, opt, "bitwise operation between different " + "enumeration types %qT and %qT is deprecated", + type0, type1); return; default: - warning_at (loc, opt, "arithmetic between different enumeration " - "types %qT and %qT is deprecated", type0, type1); + if (cxx_dialect >= cxx26) + pedwarn (loc, opt, "arithmetic between different enumeration " + "types %qT and %qT", type0, type1); + else + warning_at (loc, opt, "arithmetic between different enumeration " + "types %qT and %qT is deprecated", type0, type1); return; } } @@ -5010,7 +5018,13 @@ do_warn_enum_conversions (location_t loc case LE_EXPR: case EQ_EXPR: case NE_EXPR: - if (enum_first_p) + if (enum_first_p && cxx_dialect >= cxx26) + pedwarn (loc, opt, "comparison of enumeration type %qT with " + "floating-point type %qT", type0, type1); + else if (cxx_dialect >= cxx26) + pedwarn (loc, opt, "comparison of floating-point type %qT " + "with enumeration type %qT", type0, type1); + else if (enum_first_p) warning_at (loc, opt, "comparison of enumeration type %qT with " "floating-point type %qT is deprecated", type0, type1); @@ -5023,7 +5037,13 @@ do_warn_enum_conversions (location_t loc /* This is invalid, don't warn. */ return; default: - if (enum_first_p) + if (enum_first_p && cxx_dialect >= cxx26) + pedwarn (loc, opt, "arithmetic between enumeration type %qT " + "and floating-point type %qT", type0, type1); + else if (cxx_dialect >= cxx26) + pedwarn (loc, opt, "arithmetic between floating-point type %qT " + "and enumeration type %qT", type0, type1); + else if (enum_first_p) warning_at (loc, opt, "arithmetic between enumeration type %qT " "and floating-point type %qT is deprecated", type0, type1); @@ -6163,15 +6183,13 @@ cp_build_binary_op (const op_location_t return error_mark_node; } if (complain & tf_warning) - { - do_warn_double_promotion (result_type, type0, type1, - "implicit conversion from %qH to %qI " - "to match other operand of binary " - "expression", - location); - do_warn_enum_conversions (location, code, TREE_TYPE (orig_op0), - TREE_TYPE (orig_op1)); - } + do_warn_double_promotion (result_type, type0, type1, + "implicit conversion from %qH to %qI " + "to match other operand of binary " + "expression", location); + if (complain & (cxx_dialect >= cxx26 ? tf_warning_or_error : tf_warning)) + do_warn_enum_conversions (location, code, TREE_TYPE (orig_op0), + TREE_TYPE (orig_op1)); } if (may_need_excess_precision && (orig_type0 != type0 || orig_type1 != type1) --- gcc/cp/call.cc.jj 2023-11-11 08:51:54.419204769 +0100 +++ gcc/cp/call.cc 2023-11-13 11:16:08.033333959 +0100 @@ -6163,19 +6163,30 @@ build_conditional_expr (const op_locatio == DECL_CONTEXT (stripped_orig_arg3))) /* Two enumerators from the same enumeration can have different types when the enumeration is still being defined. */; - else if (complain & tf_warning) - warning_at (loc, OPT_Wenum_compare, "enumerated mismatch " - "in conditional expression: %qT vs %qT", - arg2_type, arg3_type); + else if (complain & (cxx_dialect >= cxx26 + ? tf_warning_or_error : tf_warning)) + emit_diagnostic (cxx_dialect >= cxx26 ? DK_PEDWARN : DK_WARNING, + loc, OPT_Wenum_compare, "enumerated mismatch " + "in conditional expression: %qT vs %qT", + arg2_type, arg3_type); } - else if ((complain & tf_warning) + else if ((complain & (cxx_dialect >= cxx26 + ? tf_warning_or_error : tf_warning)) && warn_deprecated_enum_float_conv && ((TREE_CODE (arg2_type) == ENUMERAL_TYPE && SCALAR_FLOAT_TYPE_P (arg3_type)) || (SCALAR_FLOAT_TYPE_P (arg2_type) && TREE_CODE (arg3_type) == ENUMERAL_TYPE))) { - if (TREE_CODE (arg2_type) == ENUMERAL_TYPE) + if (cxx_dialect >= cxx26 && TREE_CODE (arg2_type) == ENUMERAL_TYPE) + pedwarn (loc, OPT_Wdeprecated_enum_float_conversion, + "conditional expression between enumeration type " + "%qT and floating-point type %qT", arg2_type, arg3_type); + else if (cxx_dialect >= cxx26) + pedwarn (loc, OPT_Wdeprecated_enum_float_conversion, + "conditional expression between floating-point type " + "%qT and enumeration type %qT", arg2_type, arg3_type); + else if (TREE_CODE (arg2_type) == ENUMERAL_TYPE) warning_at (loc, OPT_Wdeprecated_enum_float_conversion, "conditional expression between enumeration type " "%qT and floating-point type %qT is deprecated", @@ -7259,10 +7270,13 @@ build_new_op (const op_location_t &loc, && TREE_CODE (arg2_type) == ENUMERAL_TYPE && (TYPE_MAIN_VARIANT (arg1_type) != TYPE_MAIN_VARIANT (arg2_type)) - && (complain & tf_warning)) - warning_at (loc, OPT_Wenum_compare, - "comparison between %q#T and %q#T", - arg1_type, arg2_type); + && (complain & (cxx_dialect >= cxx26 + ? tf_warning_or_error : tf_warning))) + emit_diagnostic (cxx_dialect >= cxx26 + ? DK_PEDWARN : DK_WARNING, + loc, OPT_Wenum_compare, + "comparison between %q#T and %q#T", + arg1_type, arg2_type); break; default: break; --- gcc/testsuite/g++.dg/cpp2a/enum-conv1.C.jj 2020-10-30 08:59:57.068496404 +0100 +++ gcc/testsuite/g++.dg/cpp2a/enum-conv1.C 2023-11-13 11:38:24.454690122 +0100 @@ -14,11 +14,16 @@ void conv () { bool b1 = e == e1; - bool b2 = e == f; // { dg-warning "comparison between .enum E1. and .enum E2." } - bool b3 = e == 0.0; // { dg-warning "comparison of enumeration type .E1. with floating-point type .double." "" { target c++20 } } - bool b4 = 0.0 == f; // { dg-warning "comparison of floating-point type .double. with enumeration type .E2." "" { target c++20 } } - int n1 = true ? e : f; // { dg-warning "enumerated mismatch" } - int n2 = true ? e : 0.0; // { dg-warning "conditional expression between" "" { target c++20 } } + bool b2 = e == f; // { dg-warning "comparison between .enum E1. and .enum E2." "" { target c++23_down } } + // { dg-error "comparison between .enum E1. and .enum E2." "" { target c++26 } .-1 } + bool b3 = e == 0.0; // { dg-warning "comparison of enumeration type .E1. with floating-point type .double." "" { target { c++20 && c++23_down } } } + // { dg-error "comparison of enumeration type .E1. with floating-point type .double." "" { target c++26 } .-1 } + bool b4 = 0.0 == f; // { dg-warning "comparison of floating-point type .double. with enumeration type .E2." "" { target { c++20 && c++23_down } } } + // { dg-error "comparison of floating-point type .double. with enumeration type .E2." "" { target c++26 } .-1 } + int n1 = true ? e : f; // { dg-warning "enumerated mismatch" "" { target c++23_down } } + // { dg-error "enumerated mismatch" "" { target c++26 } .-1 } + int n2 = true ? e : 0.0; // { dg-warning "conditional expression between" "" { target { c++20 && c++23_down } } } + // { dg-error "conditional expression between" "" { target c++26 } .-1 } } int @@ -29,42 +34,60 @@ enum_enum (bool b) r += e - e; r += e - e1; - r += e - f; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target c++20 } } - r += f - e; // { dg-warning "arithmetic between different enumeration types .E2. and .E1." "" { target c++20 } } - + r += e - f; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between different enumeration types .E1. and .E2." "" { target c++26 } .-1 } + r += f - e; // { dg-warning "arithmetic between different enumeration types .E2. and .E1." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between different enumeration types .E2. and .E1." "" { target c++26 } .-1 } r += f + f; - r += f + e; // { dg-warning "arithmetic between different enumeration types .E2. and .E1." "" { target c++20 } } - r += e + f; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target c++20 } } + r += f + e; // { dg-warning "arithmetic between different enumeration types .E2. and .E1." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between different enumeration types .E2. and .E1." "" { target c++26 } .-1 } + r += e + f; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between different enumeration types .E1. and .E2." "" { target c++26 } .-1 } - r += e1 - e2; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target c++20 } } + r += e1 - e2; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between different enumeration types .E1. and .E2." "" { target c++26 } .-1 } r += e1 - e1c; r += e1c - e1; - r += e * f; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target c++20 } } - r += f * e; // { dg-warning "arithmetic between different enumeration types .E2. and .E1." "" { target c++20 } } + r += e * f; // { dg-warning "arithmetic between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between different enumeration types .E1. and .E2." "" { target c++26 } .-1 } + r += f * e; // { dg-warning "arithmetic between different enumeration types .E2. and .E1." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between different enumeration types .E2. and .E1." "" { target c++26 } .-1 } r += e * e; r += e1 < e1c; r += e < e1; - r += e1 < e2; // { dg-warning "comparison between .enum E1. and .enum E2." } - r += e < f; // { dg-warning "comparison between .enum E1. and .enum E2." } - r += f < e; // { dg-warning "comparison between .enum E2. and .enum E1." } + r += e1 < e2; // { dg-warning "comparison between .enum E1. and .enum E2." "" { target c++23_down } } + // { dg-error "comparison between .enum E1. and .enum E2." "" { target c++26 } .-1 } + r += e < f; // { dg-warning "comparison between .enum E1. and .enum E2." "" { target c++23_down } } + // { dg-error "comparison between .enum E1. and .enum E2." "" { target c++26 } .-1 } + r += f < e; // { dg-warning "comparison between .enum E2. and .enum E1." "" { target c++23_down } } + // { dg-error "comparison between .enum E2. and .enum E1." "" { target c++26 } .-1 } r += e1 == e1c; r += e == e1; - r += e == f; // { dg-warning "comparison between .enum E1. and .enum E2." } - r += f == e; // { dg-warning "comparison between .enum E2. and .enum E1." } - r += e1 == e2; // { dg-warning "comparison between .enum E1. and .enum E2." } - r += e2 == e1; // { dg-warning "comparison between .enum E2. and .enum E1." } + r += e == f; // { dg-warning "comparison between .enum E1. and .enum E2." "" { target c++23_down } } + // { dg-error "comparison between .enum E1. and .enum E2." "" { target c++26 } .-1 } + r += f == e; // { dg-warning "comparison between .enum E2. and .enum E1." "" { target c++23_down } } + // { dg-error "comparison between .enum E2. and .enum E1." "" { target c++26 } .-1 } + r += e1 == e2; // { dg-warning "comparison between .enum E1. and .enum E2." "" { target c++23_down } } + // { dg-error "comparison between .enum E1. and .enum E2." "" { target c++26 } .-1 } + r += e2 == e1; // { dg-warning "comparison between .enum E2. and .enum E1." "" { target c++23_down } } + // { dg-error "comparison between .enum E2. and .enum E1." "" { target c++26 } .-1 } r += b ? e1 : e1c; r += b ? e1 : e; - r += b ? f : e; // { dg-warning "enumerated mismatch in conditional expression: .E2. vs .E1." } - r += b ? e1 : e2; // { dg-warning "enumerated mismatch in conditional expression: .E1. vs .E2." } - - r += e | f; // { dg-warning "bitwise operation between different enumeration types .E1. and .E2." "" { target c++20 } } - r += e ^ f; // { dg-warning "bitwise operation between different enumeration types .E1. and .E2." "" { target c++20 } } - r += e & f; // { dg-warning "bitwise operation between different enumeration types .E1. and .E2." "" { target c++20 } } + r += b ? f : e; // { dg-warning "enumerated mismatch in conditional expression: .E2. vs .E1." "" { target c++23_down } } + // { dg-error "enumerated mismatch in conditional expression: .E2. vs .E1." "" { target c++26 } .-1 } + r += b ? e1 : e2; // { dg-warning "enumerated mismatch in conditional expression: .E1. vs .E2." "" { target c++23_down } } + // { dg-error "enumerated mismatch in conditional expression: .E1. vs .E2." "" { target c++26 } .-1 } + + r += e | f; // { dg-warning "bitwise operation between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } } + // { dg-error "bitwise operation between different enumeration types .E1. and .E2." "" { target c++26 } .-1 } + r += e ^ f; // { dg-warning "bitwise operation between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } } + // { dg-error "bitwise operation between different enumeration types .E1. and .E2." "" { target c++26 } .-1 } + r += e & f; // { dg-warning "bitwise operation between different enumeration types .E1. and .E2." "" { target { c++20 && c++23_down } } } + // { dg-error "bitwise operation between different enumeration types .E1. and .E2." "" { target c++26 } .-1 } r += !e; r += e1 | e; @@ -76,10 +99,14 @@ enum_enum (bool b) // Anonymous enum. r += u1 - u1; - r += u1 + u2; // { dg-warning "arithmetic between different enumeration types" "" { target c++20 } } - r += u1 * u2; // { dg-warning "arithmetic between different enumeration types" "" { target c++20 } } - r += u1 == u2; // { dg-warning "comparison between" } - r += u1 & u2; // { dg-warning "bitwise operation between different enumeration types" "" { target c++20 } } + r += u1 + u2; // { dg-warning "arithmetic between different enumeration types" "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between different enumeration types" "" { target c++26 } .-1 } + r += u1 * u2; // { dg-warning "arithmetic between different enumeration types" "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between different enumeration types" "" { target c++26 } .-1 } + r += u1 == u2; // { dg-warning "comparison between" "" { target c++23_down } } + // { dg-error "comparison between" "" { target c++26 } .-1 } + r += u1 & u2; // { dg-warning "bitwise operation between different enumeration types" "" { target { c++20 && c++23_down } } } + // { dg-error "bitwise operation between different enumeration types" "" { target c++26 } .-1 } return r; } @@ -89,28 +116,47 @@ enum_float (bool b) { double r = 0.0; - r += e1 - d; // { dg-warning "arithmetic between enumeration type .E1. and floating-point type .double." "" { target c++20 } } - r += d - e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++20 } } - r += e1 + d; // { dg-warning "arithmetic between enumeration type .E1. and floating-point type .double." "" { target c++20 } } - r += d + e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++20 } } - r += e1 * d; // { dg-warning "arithmetic between enumeration type .E1. and floating-point type .double." "" { target c++20 } } - r += d * e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++20 } } - r += u1 * d; // { dg-warning "arithmetic between enumeration type" "" { target c++20 } } - r += d * u1; // { dg-warning "arithmetic between floating-point type" "" { target c++20 } } - - r += e1 < d; // { dg-warning "comparison of enumeration type .E1. with floating-point type .double." "" { target c++20 } } - r += d < e1; // { dg-warning "comparison of floating-point type .double. with enumeration type .E1." "" { target c++20 } } - r += d == e1; // { dg-warning "comparison of floating-point type .double. with enumeration type .E1." "" { target c++20 } } - r += e1 == d; // { dg-warning "comparison of enumeration type .E1. with floating-point type .double." "" { target c++20 } } - r += u1 == d; // { dg-warning "comparison of enumeration type" "" { target c++20 } } - r += d == u1; // { dg-warning "comparison of floating-point type" "" { target c++20 } } - - r += b ? e1 : d; // { dg-warning "conditional expression between enumeration type .E1. and floating-point type .double." "" { target c++20 } } - r += b ? d : e1; // { dg-warning "conditional expression between floating-point type .double. and enumeration type .E1." "" { target c++20 } } - r += b ? d : u1; // { dg-warning "conditional expression between" "" { target c++20 } } - r += b ? u1 : d; // { dg-warning "conditional expression between" "" { target c++20 } } + r += e1 - d; // { dg-warning "arithmetic between enumeration type .E1. and floating-point type .double." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between enumeration type .E1. and floating-point type .double." "" { target c++26 } .-1 } + r += d - e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++26 } .-1 } + r += e1 + d; // { dg-warning "arithmetic between enumeration type .E1. and floating-point type .double." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between enumeration type .E1. and floating-point type .double." "" { target c++26 } .-1 } + r += d + e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++26 } .-1 } + r += e1 * d; // { dg-warning "arithmetic between enumeration type .E1. and floating-point type .double." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between enumeration type .E1. and floating-point type .double." "" { target c++26 } .-1 } + r += d * e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++26 } .-1 } + r += u1 * d; // { dg-warning "arithmetic between enumeration type" "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between enumeration type" "" { target c++26 } .-1 } + r += d * u1; // { dg-warning "arithmetic between floating-point type" "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between floating-point type" "" { target c++26 } .-1 } + + r += e1 < d; // { dg-warning "comparison of enumeration type .E1. with floating-point type .double." "" { target { c++20 && c++23_down } } } + // { dg-error "comparison of enumeration type .E1. with floating-point type .double." "" { target c++26 } .-1 } + r += d < e1; // { dg-warning "comparison of floating-point type .double. with enumeration type .E1." "" { target { c++20 && c++23_down } } } + // { dg-error "comparison of floating-point type .double. with enumeration type .E1." "" { target c++26 } .-1 } + r += d == e1; // { dg-warning "comparison of floating-point type .double. with enumeration type .E1." "" { target { c++20 && c++23_down } } } + // { dg-error "comparison of floating-point type .double. with enumeration type .E1." "" { target c++26 } .-1 } + r += e1 == d; // { dg-warning "comparison of enumeration type .E1. with floating-point type .double." "" { target { c++20 && c++23_down } } } + // { dg-error "comparison of enumeration type .E1. with floating-point type .double." "" { target c++26 } .-1 } + r += u1 == d; // { dg-warning "comparison of enumeration type" "" { target { c++20 && c++23_down } } } + // { dg-error "comparison of enumeration type" "" { target c++26 } .-1 } + r += d == u1; // { dg-warning "comparison of floating-point type" "" { target { c++20 && c++23_down } } } + // { dg-error "comparison of floating-point type" "" { target c++26 } .-1 } + + r += b ? e1 : d; // { dg-warning "conditional expression between enumeration type .E1. and floating-point type .double." "" { target { c++20 && c++23_down } } } + // { dg-error "conditional expression between enumeration type .E1. and floating-point type .double." "" { target c++26 } .-1 } + r += b ? d : e1; // { dg-warning "conditional expression between floating-point type .double. and enumeration type .E1." "" { target { c++20 && c++23_down } } } + // { dg-error "conditional expression between floating-point type .double. and enumeration type .E1." "" { target c++26 } .-1 } + r += b ? d : u1; // { dg-warning "conditional expression between" "" { target { c++20 && c++23_down } } } + // { dg-error "conditional expression between" "" { target c++26 } .-1 } + r += b ? u1 : d; // { dg-warning "conditional expression between" "" { target { c++20 && c++23_down } } } + // { dg-error "conditional expression between" "" { target c++26 } .-1 } - d += e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++20 } } + d += e1; // { dg-warning "arithmetic between floating-point type .double. and enumeration type .E1." "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between floating-point type .double. and enumeration type .E1." "" { target c++26 } .-1 } d = e1; return r; --- gcc/testsuite/g++.dg/diagnostic/enum3.C.jj 2021-06-09 10:20:08.971342523 +0200 +++ gcc/testsuite/g++.dg/diagnostic/enum3.C 2023-11-13 12:28:19.035521575 +0100 @@ -5,5 +5,6 @@ enum e1 { e1val }; enum e2 { e3val }; int main( int, char * [] ) { - if ( e1val == e3val ) return 1; // { dg-warning -Wenum-compare } + if ( e1val == e3val ) return 1; // { dg-warning "comparison between 'enum e1' and 'enum e2'" "" { target c++23_down } } + // { dg-error "comparison between 'enum e1' and 'enum e2'" "" { target c++26 } .-1 } } --- gcc/testsuite/g++.dg/parse/attr3.C.jj 2020-10-29 10:10:11.569397839 +0100 +++ gcc/testsuite/g++.dg/parse/attr3.C 2023-11-13 12:29:13.241759469 +0100 @@ -10,5 +10,6 @@ int main () { S::F y; // { dg-warning "'F' is deprecated" } y = S::f; - return x + y; // { dg-warning "arithmetic between different enumeration types" "" { target c++20 } } + return x + y; // { dg-warning "arithmetic between different enumeration types" "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between different enumeration types" "" { target c++26 } .-1 } } --- gcc/testsuite/g++.dg/cpp0x/linkage2.C.jj 2020-10-29 10:10:11.560397940 +0100 +++ gcc/testsuite/g++.dg/cpp0x/linkage2.C 2023-11-13 12:30:26.712726512 +0100 @@ -29,5 +29,6 @@ void f() { ba.g(a); // OK ba.h(a); // error, B::h never defined i(ba, a); // OK - e1+e2+e3; // { dg-warning "arithmetic between different enumeration types" "" { target c++20 } } + e1+e2+e3; // { dg-warning "arithmetic between different enumeration types" "" { target { c++20 && c++23_down } } } + // { dg-error "arithmetic between different enumeration types" "" { target c++26 } .-1 } }