From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id 836423858D35 for ; Fri, 20 Oct 2023 21:31:53 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 836423858D35 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 836423858D35 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=170.10.133.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1697837517; cv=none; b=TjZoXWAy+xKe8VyGLLZ8ZwFx7nzxs8aBq+c4DtsoR5svsB5hjle1op1OsqPvg3SHbn61QbDVKE8yUO028eZtmwQr4vuJn58X3NArcG1Q9Sd/+p18QxMv55Pn3pMKvq3tNzG/KR0pECqTMXgAWg55LKN3JvwiqS9ZtXZ7Io6x048= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1697837517; c=relaxed/simple; bh=J1gchVJUVYks4wWTIVTa0y1PRQ1ndvIwKsSEfZ0I1wg=; h=DKIM-Signature:From:Date:To:Subject:Message-ID:MIME-Version; b=NENq2YUelnXhK4KK0+5HsuauAp4L12CirjdDKDn1Lq2aQxs5PCY8XzdR3MQD3tCkWYQc7qSDc5fHbh+SuMktVTYrL0PZWEX6qyMeMXZXrdxD4Mjhh8e0tXM2PSKNPnf2hkhkHMro5Up3LT4QNrV4+lY5JFjz+OXkq+2YDDbPbWM= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1697837513; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: in-reply-to:in-reply-to:references:references; bh=PELmKG/a42xdTR9T39udJcfq4I04iHgXOGXTNKIXzgI=; b=iOBrCKt9K0aIn6+FHVcizWjaYpskBXUoyxHekiHebDStR3t53KSoGZryGhXU1avCPvyd4q +aqqlGAfyT60hg1JeDPxuHdcf5ariaPFrVQG3GW3Gf+5aNL3zlYLOtE95siAs6J6L11fSr V+YsXtyoPFBmih+XPvhhsMnZbOKfVbQ= Received: from mail-qk1-f200.google.com (mail-qk1-f200.google.com [209.85.222.200]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-96-2y69aIN6MtaOFSQsgmMgHQ-1; Fri, 20 Oct 2023 17:31:51 -0400 X-MC-Unique: 2y69aIN6MtaOFSQsgmMgHQ-1 Received: by mail-qk1-f200.google.com with SMTP id af79cd13be357-778964b7c8bso150277285a.1 for ; Fri, 20 Oct 2023 14:31:51 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1697837511; x=1698442311; h=mime-version:references:message-id:in-reply-to:subject:cc:to:date :from:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=PELmKG/a42xdTR9T39udJcfq4I04iHgXOGXTNKIXzgI=; b=TQ7/CVYHQEiZhtdn78ScdhE0F2XZbeQu42KBywiesgwR8X6RKfbEx/qFWKYCJqkXp2 vQ9yXDIH5/yX2u850j4xVH0hd0DjB3uOeuNh3JPYS/TEQd7QUlpX5BzkKr+rxudcym71 eaY72pbDPSOhMhxARDdjkWJsSVLg8C1ppqcjlO8I6dKQYqmfOyNoVQlXmnWbUS7sq1Yb ktLoBV7xC/2NrxZTHV1uNFtNvwZetj55fN9wLEwTKj+SwtbEUtisbsrRQUoUhLrUlWFo YtaGUAN89N+hRto9EoQJpM6kDj0g2tdqoJRVWYcEQKtdWpNpw218+B4MwlBoayESX5Uz TNUQ== X-Gm-Message-State: AOJu0YzoRZlWosewUmMV0mWyNix8YJqkqSK73iD+WKoTgZ5vB9BOnyz3 Rl9jfL4NZQQ6HoLSxNwaTcnXTr5RvFkYv+RU4WkVl8EAGxPg4WyF8s9Cvl0z4lV3xpSJlqoNIOz tzo9EHuddhgJv4QA= X-Received: by 2002:a05:620a:28d2:b0:76d:95bc:7aaa with SMTP id l18-20020a05620a28d200b0076d95bc7aaamr3388972qkp.29.1697837511065; Fri, 20 Oct 2023 14:31:51 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGCknWR1O85qWEuW4WlB9P37YXeO4BHn3A9fWwpy02P4VN7ZsKrtNMSqsiTk7WkXdErLt8/Sw== X-Received: by 2002:a05:620a:28d2:b0:76d:95bc:7aaa with SMTP id l18-20020a05620a28d200b0076d95bc7aaamr3388953qkp.29.1697837510572; Fri, 20 Oct 2023 14:31:50 -0700 (PDT) Received: from [192.168.1.130] (ool-457670bb.dyn.optonline.net. [69.118.112.187]) by smtp.gmail.com with ESMTPSA id vr3-20020a05620a55a300b0076f18be9a64sm906411qkn.81.2023.10.20.14.31.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 20 Oct 2023 14:31:50 -0700 (PDT) From: Patrick Palka X-Google-Original-From: Patrick Palka Date: Fri, 20 Oct 2023 17:31:49 -0400 (EDT) To: Patrick Palka cc: Ken Matsui , gcc-patches@gcc.gnu.org, libstdc++@gcc.gnu.org Subject: Re: [PATCH v23 32/33] c++: Implement __is_invocable built-in trait In-Reply-To: Message-ID: <024758c0-21f1-ef6e-4bc7-e615a7084c86@idea> References: <20231017113822.677344-1-kmatsui@gcc.gnu.org> <20231020135748.1846670-1-kmatsui@gcc.gnu.org> <20231020135748.1846670-33-kmatsui@gcc.gnu.org> MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=US-ASCII X-Spam-Status: No, score=-13.8 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,KAM_SHORT,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H3,RCVD_IN_MSPIKE_WL,SPF_HELO_NONE,SPF_NONE,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: On Fri, 20 Oct 2023, Patrick Palka wrote: > On Fri, 20 Oct 2023, Ken Matsui wrote: > > > This patch implements built-in trait for std::is_invocable. > > Nice! My email client unfortunately ate my first review attempt, so > apologies for my brevity this time around. > > > gcc/cp/ChangeLog: > > > > * cp-trait.def: Define __is_invocable. > > * constraint.cc (diagnose_trait_expr): Handle CPTK_IS_INVOCABLE. > > * semantics.cc (trait_expr_value): Likewise. > > (finish_trait_expr): Likewise. > > (is_invocable_p): New function. > > * method.h: New file to export build_trait_object in method.cc. > > > > gcc/testsuite/ChangeLog: > > > > * g++.dg/ext/has-builtin-1.C: Test existence of __is_invocable. > > * g++.dg/ext/is_invocable1.C: New test. > > * g++.dg/ext/is_invocable2.C: New test. > > * g++.dg/ext/is_invocable3.C: New test. > > * g++.dg/ext/is_invocable4.C: New test. > > > > Signed-off-by: Ken Matsui > > --- > > gcc/cp/constraint.cc | 6 + > > gcc/cp/cp-trait.def | 1 + > > gcc/cp/method.h | 28 ++ > > gcc/cp/semantics.cc | 135 +++++++++ > > gcc/testsuite/g++.dg/ext/has-builtin-1.C | 3 + > > gcc/testsuite/g++.dg/ext/is_invocable1.C | 337 +++++++++++++++++++++++ > > gcc/testsuite/g++.dg/ext/is_invocable2.C | 139 ++++++++++ > > gcc/testsuite/g++.dg/ext/is_invocable3.C | 51 ++++ > > gcc/testsuite/g++.dg/ext/is_invocable4.C | 33 +++ > > 9 files changed, 733 insertions(+) > > create mode 100644 gcc/cp/method.h > > create mode 100644 gcc/testsuite/g++.dg/ext/is_invocable1.C > > create mode 100644 gcc/testsuite/g++.dg/ext/is_invocable2.C > > create mode 100644 gcc/testsuite/g++.dg/ext/is_invocable3.C > > create mode 100644 gcc/testsuite/g++.dg/ext/is_invocable4.C > > > > diff --git a/gcc/cp/constraint.cc b/gcc/cp/constraint.cc > > index 9fce36e12d1..29bf548d30a 100644 > > --- a/gcc/cp/constraint.cc > > +++ b/gcc/cp/constraint.cc > > @@ -3754,6 +3754,12 @@ diagnose_trait_expr (tree expr, tree args) > > case CPTK_IS_FUNCTION: > > inform (loc, " %qT is not a function", t1); > > break; > > + case CPTK_IS_INVOCABLE: > > + if (!t2) > > + inform (loc, " %qT is not invocable", t1); > > + else > > + inform (loc, " %qT is not invocable by %qE", t1, t2); > > + break; > > case CPTK_IS_LAYOUT_COMPATIBLE: > > inform (loc, " %qT is not layout compatible with %qT", t1, t2); > > break; > > diff --git a/gcc/cp/cp-trait.def b/gcc/cp/cp-trait.def > > index 05514a51c21..b8b7608c122 100644 > > --- a/gcc/cp/cp-trait.def > > +++ b/gcc/cp/cp-trait.def > > @@ -71,6 +71,7 @@ DEFTRAIT_EXPR (IS_EMPTY, "__is_empty", 1) > > DEFTRAIT_EXPR (IS_ENUM, "__is_enum", 1) > > DEFTRAIT_EXPR (IS_FINAL, "__is_final", 1) > > DEFTRAIT_EXPR (IS_FUNCTION, "__is_function", 1) > > +DEFTRAIT_EXPR (IS_INVOCABLE, "__is_invocable", -1) > > DEFTRAIT_EXPR (IS_LAYOUT_COMPATIBLE, "__is_layout_compatible", 2) > > DEFTRAIT_EXPR (IS_LITERAL_TYPE, "__is_literal_type", 1) > > DEFTRAIT_EXPR (IS_MEMBER_FUNCTION_POINTER, "__is_member_function_pointer", 1) > > diff --git a/gcc/cp/method.h b/gcc/cp/method.h > > new file mode 100644 > > index 00000000000..1aec8ec5cfd > > --- /dev/null > > +++ b/gcc/cp/method.h > > @@ -0,0 +1,28 @@ > > +/* Functions exported by method.cc. > > + Copyright (C) 2023 Free Software Foundation, Inc. > > + > > +This file is part of GCC. > > + > > +GCC is free software; you can redistribute it and/or modify > > +it under the terms of the GNU General Public License as published by > > +the Free Software Foundation; either version 3, or (at your option) > > +any later version. > > + > > +GCC is distributed in the hope that it will be useful, > > +but WITHOUT ANY WARRANTY; without even the implied warranty of > > +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > > +GNU General Public License for more details. > > + > > +You should have received a copy of the GNU General Public License > > +along with GCC; see the file COPYING3. If not see > > +. */ > > + > > +#ifndef GCC_CP_METHOD_H > > +#define GCC_CP_METHOD_H 1 > > + > > +#include "tree.h" > > + > > +/* In method.cc */ > > +extern tree build_trait_object (tree type); > > Since other method.cc exports are already declared in cp-tree.h, for now > let's just declare this in cp-tree.h as well (under build_stub_object) > instead of creating a new header file. > > > + > > +#endif /* GCC_CP_METHOD_H */ > > diff --git a/gcc/cp/semantics.cc b/gcc/cp/semantics.cc > > index 7cccbae5287..cc2e400531a 100644 > > --- a/gcc/cp/semantics.cc > > +++ b/gcc/cp/semantics.cc > > @@ -45,6 +45,10 @@ along with GCC; see the file COPYING3. If not see > > #include "gomp-constants.h" > > #include "predict.h" > > #include "memmodel.h" > > +#include "method.h" > > + > > +#include "print-tree.h" > > +#include "tree-pretty-print.h" > > > > /* There routines provide a modular interface to perform many parsing > > operations. They may therefore be used during actual parsing, or > > @@ -11714,6 +11718,133 @@ classtype_has_nothrow_assign_or_copy_p (tree type, bool assign_p) > > return saw_copy; > > } > > > > +/* Return true if FN_TYPE is invocable with the given ARG_TYPES. */ > > + > > +static bool > > +is_invocable_p (tree fn_type, tree arg_types) > > +{ > > + /* ARG_TYPES must be a TREE_VEC. */ > > + gcc_assert (TREE_CODE (arg_types) == TREE_VEC); > > + > > + /* Access check is required to determine if the given is invocable. */ > > + deferring_access_check_sentinel acs (dk_no_deferred); > > + > > + /* std::is_invocable is an unevaluated context. */ > > + cp_unevaluated cp_uneval_guard; > > + > > + bool is_ptrdatamem; > > + bool is_ptrmemfunc; > > + if (TREE_CODE (fn_type) == REFERENCE_TYPE) > > + { > > + tree deref_fn_type = TREE_TYPE (fn_type); > > + is_ptrdatamem = TYPE_PTRDATAMEM_P (deref_fn_type); > > + is_ptrmemfunc = TYPE_PTRMEMFUNC_P (deref_fn_type); > > + > > + /* Dereference fn_type if it is a pointer to member. */ > > + if (is_ptrdatamem || is_ptrmemfunc) > > + fn_type = deref_fn_type; > > + } > > + else > > + { > > + is_ptrdatamem = TYPE_PTRDATAMEM_P (fn_type); > > + is_ptrmemfunc = TYPE_PTRMEMFUNC_P (fn_type); > > + } > > + > > + if (is_ptrdatamem && TREE_VEC_LENGTH (arg_types) != 1) > > + /* A pointer to data member with non-one argument is not invocable. */ > > + return false; > > + > > + if (is_ptrmemfunc && TREE_VEC_LENGTH (arg_types) == 0) > > + /* A pointer to member function with no arguments is not invocable. */ > > + return false; > > + > > + /* Construct an expression of a pointer to member. */ > > + tree datum; > > + if (is_ptrdatamem || is_ptrmemfunc) > > + { > > + tree datum_type = TREE_VEC_ELT (arg_types, 0); > > + > > + /* Dereference datum. */ > > + if (CLASS_TYPE_P (datum_type)) > > + { > > + bool is_refwrap = false; > > + > > + tree datum_decl = TYPE_NAME (TYPE_MAIN_VARIANT (datum_type)); > > + if (decl_in_std_namespace_p (datum_decl)) > > + { > > + tree name = DECL_NAME (datum_decl); > > + if (name && (id_equal (name, "reference_wrapper"))) > > + { > > + /* Handle std::reference_wrapper. */ > > + is_refwrap = true; > > + datum_type = cp_build_reference_type (datum_type, false); > > + } > > + } > > + > > + datum = build_trait_object (datum_type); > > + > > + /* If datum_type was not std::reference_wrapper, check if it has > > + operator*() overload. If datum_type was std::reference_wrapper, > > + avoid dereferencing the datum twice. */ > > + if (!is_refwrap) > > + if (get_class_binding (datum_type, get_identifier ("operator*"))) > > We probably should use lookup_member instead of get_class_binding since > IIUC the latter doesn't look into bases: > > struct A { int m; }; > struct B { A& operator*(): }; > struct C : B { }; > static_assert(std::is_invocable_v); > > However, I notice that the specification of INVOKE > (https://eel.is/c++draft/func.require#lib:INVOKE) doesn't mention name > lookup at all so it strikes me as suspicious that we'd perform name > lookup here. I think this would misbehave for: > > struct A { }; > struct B : A { A& operator*() = delete; }; > static_assert(std::is_invocable_v); > > struct C : private A { A& operator*(); }; > static_assert(std::is_invocable_v); Oops, this static_assert is missing a ! > > ultimately because we end up choosing the dereference form of INVOKE, > but according to 1.1/1.4 we should choose the non-dereference form? > > > + /* Handle operator*(). */ > > + datum = build_x_indirect_ref (UNKNOWN_LOCATION, datum, > > + RO_UNARY_STAR, NULL_TREE, > > + tf_none); > > + } > > + else if (POINTER_TYPE_P (datum_type)) > > + datum = build_trait_object (TREE_TYPE (datum_type)); > > + else > > + datum = build_trait_object (datum_type); > > + } > > + > > + /* Build a function expression. */ > > + tree fn; > > + if (is_ptrdatamem) > > + fn = build_m_component_ref (datum, build_trait_object (fn_type), tf_none); > > Maybe exit early for the is_ptrdatamem case here (and simplify the rest > of the function accordingly)? > > > + else if (is_ptrmemfunc) > > + fn = build_trait_object (TYPE_PTRMEMFUNC_FN_TYPE (fn_type)); > > + else > > + fn = build_trait_object (fn_type); > > + > > + /* Construct arguments to the function and an expression of a call. */ > > + if (!is_ptrdatamem) > > + { > > + releasing_vec args; > > + > > + if (is_ptrmemfunc) > > + { > > + /* A pointer to member function is internally converted to a pointer > > + to function that takes a pointer to the dereferenced datum type > > + as its first argument and original arguments afterward. If the > > + function is a const member function, the first argument also > > + requires a const datum pointer and vice-versa. */ > > + > > + tree datum_type = TREE_TYPE (datum); > > + if (TYPE_REF_P (datum_type)) > > + datum_type = TREE_TYPE (datum_type); > > + > > + datum = build_trait_object (build_pointer_type (datum_type)); > > + vec_safe_push (args, datum); > > + } > > + > > + for (int i = is_ptrmemfunc ? 1 : 0; i < TREE_VEC_LENGTH (arg_types); ++i) > > + { > > + tree arg_type = TREE_VEC_ELT (arg_types, i); > > + tree arg = build_trait_object (arg_type); > > + vec_safe_push (args, arg); > > + } > > + > > + fn = finish_call_expr (fn, &args, false, false, tf_none); > > + } > > + > > + if (error_operand_p (fn)) > > + return false; > > + > > + return true; > > +} > > + > > /* Return true if DERIVED is pointer interconvertible base of BASE. */ > > > > static bool > > @@ -12181,6 +12312,9 @@ trait_expr_value (cp_trait_kind kind, tree type1, tree type2) > > case CPTK_IS_FUNCTION: > > return type_code1 == FUNCTION_TYPE; > > > > + case CPTK_IS_INVOCABLE: > > + return is_invocable_p (type1, type2); > > + > > case CPTK_IS_LAYOUT_COMPATIBLE: > > return layout_compatible_type_p (type1, type2); > > > > @@ -12390,6 +12524,7 @@ finish_trait_expr (location_t loc, cp_trait_kind kind, tree type1, tree type2) > > break; > > > > case CPTK_IS_CONVERTIBLE: > > + case CPTK_IS_INVOCABLE: > > case CPTK_IS_NOTHROW_ASSIGNABLE: > > case CPTK_IS_NOTHROW_CONSTRUCTIBLE: > > case CPTK_IS_NOTHROW_CONVERTIBLE: > > diff --git a/gcc/testsuite/g++.dg/ext/has-builtin-1.C b/gcc/testsuite/g++.dg/ext/has-builtin-1.C > > index b1430e9bd8b..3a9bda1ee03 100644 > > --- a/gcc/testsuite/g++.dg/ext/has-builtin-1.C > > +++ b/gcc/testsuite/g++.dg/ext/has-builtin-1.C > > @@ -92,6 +92,9 @@ > > #if !__has_builtin (__is_function) > > # error "__has_builtin (__is_function) failed" > > #endif > > +#if !__has_builtin (__is_invocable) > > +# error "__has_builtin (__is_invocable) failed" > > +#endif > > #if !__has_builtin (__is_layout_compatible) > > # error "__has_builtin (__is_layout_compatible) failed" > > #endif > > diff --git a/gcc/testsuite/g++.dg/ext/is_invocable1.C b/gcc/testsuite/g++.dg/ext/is_invocable1.C > > new file mode 100644 > > index 00000000000..2fd3906b571 > > --- /dev/null > > +++ b/gcc/testsuite/g++.dg/ext/is_invocable1.C > > @@ -0,0 +1,337 @@ > > +// { dg-do compile { target c++11 } } > > + > > +#define SA(X) static_assert((X),#X) > > + > > +using func_type_v0 = void(*)(); > > + > > +SA( __is_invocable( func_type_v0 ) ); > > +SA( ! __is_invocable( func_type_v0, int ) ); > > + > > +using func_type_i0 = int(*)(); > > + > > +SA( __is_invocable( func_type_i0 ) ); > > +SA( ! __is_invocable( func_type_i0, int ) ); > > + > > +using func_type_l0 = int&(*)(); > > + > > +SA( __is_invocable( func_type_l0 ) ); > > +SA( ! __is_invocable( func_type_l0(int) ) ); > > + > > +using func_type_ii = int(*)(int); > > + > > +SA( ! __is_invocable( func_type_ii ) ); > > +SA( __is_invocable( func_type_ii, int ) ); > > + > > +using func_type_il = int(*)(int&); > > + > > +SA( ! __is_invocable( func_type_il ) ); > > +SA( ! __is_invocable( func_type_il, int ) ); > > +SA( __is_invocable( func_type_il, int& ) ); > > + > > +using func_type_ir = int(*)(int&&); > > + > > +SA( ! __is_invocable( func_type_ir ) ); > > +SA( ! __is_invocable( func_type_ir, int& ) ); > > +SA( __is_invocable( func_type_ir, int ) ); > > +SA( __is_invocable( func_type_ir, int&& ) ); > > + > > +struct A { }; > > + > > +using mem_type_i = int A::*; > > + > > +SA( ! __is_invocable( mem_type_i ) ); > > +SA( ! __is_invocable( mem_type_i, int ) ); > > +SA( ! __is_invocable( mem_type_i, int* ) ); > > +SA( ! __is_invocable( mem_type_i, int& ) ); > > +SA( ! __is_invocable( mem_type_i, int&& ) ); > > +SA( __is_invocable( mem_type_i, A ) ); > > +SA( __is_invocable( mem_type_i, A* ) ); > > +SA( __is_invocable( mem_type_i, A& ) ); > > +SA( __is_invocable( mem_type_i, A&& ) ); > > +SA( __is_invocable( mem_type_i, const A& ) ); > > +SA( ! __is_invocable( mem_type_i, A&, int ) ); > > + > > +using memfun_type_i = int (A::*)(); > > + > > +SA( ! __is_invocable( memfun_type_i ) ); > > +SA( ! __is_invocable( memfun_type_i, int ) ); > > +SA( ! __is_invocable( memfun_type_i, int* ) ); > > +SA( ! __is_invocable( memfun_type_i, int& ) ); > > +SA( ! __is_invocable( memfun_type_i, int&& ) ); > > +SA( __is_invocable( memfun_type_i, A ) ); > > +SA( __is_invocable( memfun_type_i, A* ) ); > > +SA( __is_invocable( memfun_type_i, A& ) ); > > +SA( __is_invocable( memfun_type_i, A&& ) ); > > +SA( ! __is_invocable( memfun_type_i, const A& ) ); > > +SA( ! __is_invocable( memfun_type_i, A&, int ) ); > > + > > +using memfun_type_ic = int (A::*)() const; > > + > > +SA( ! __is_invocable( memfun_type_ic ) ); > > +SA( ! __is_invocable( memfun_type_ic, int ) ); > > +SA( ! __is_invocable( memfun_type_ic, int& ) ); > > +SA( __is_invocable( memfun_type_ic, A& ) ); > > +SA( __is_invocable( memfun_type_ic, A* ) ); > > +SA( ! __is_invocable( memfun_type_ic, A&, int ) ); > > +SA( ! __is_invocable( memfun_type_ic, A*, int& ) ); > > +SA( __is_invocable( memfun_type_ic, const A& ) ); > > +SA( __is_invocable( memfun_type_ic, const A* ) ); > > +SA( ! __is_invocable( memfun_type_ic, const A&, int& ) ); > > +SA( ! __is_invocable( memfun_type_ic, const A*, int ) ); > > + > > +using memfun_type_iic = int& (A::*)(int&) const; > > + > > +SA( ! __is_invocable( memfun_type_iic ) ); > > +SA( ! __is_invocable( memfun_type_iic, int ) ); > > +SA( ! __is_invocable( memfun_type_iic, int& ) ); > > +SA( ! __is_invocable( memfun_type_iic, A&, int ) ); > > +SA( __is_invocable( memfun_type_iic, A&, int& ) ); > > +SA( ! __is_invocable( memfun_type_iic, A*, int ) ); > > +SA( __is_invocable( memfun_type_iic, A*, int& ) ); > > +SA( ! __is_invocable( memfun_type_iic, const A&, int ) ); > > +SA( ! __is_invocable( memfun_type_iic, const A&, int&, int ) ); > > +SA( __is_invocable( memfun_type_iic, const A&, int& ) ); > > +SA( __is_invocable( memfun_type_iic, const A*, int& ) ); > > + > > +struct B { > > + int& operator()(); > > + long& operator()() const; > > + bool& operator()(int); > > +private: > > + void operator()(int, int); > > +}; > > +using CB = const B; > > + > > +SA( __is_invocable( B ) ); > > +SA( __is_invocable( B& ) ); > > +SA( __is_invocable( B&& ) ); > > +SA( ! __is_invocable( B* ) ); > > +SA( __is_invocable( CB ) ); > > +SA( __is_invocable( CB& ) ); > > +SA( ! __is_invocable( CB* ) ); > > + > > +SA( __is_invocable( B, int ) ); > > +SA( __is_invocable( B&, int ) ); > > +SA( __is_invocable( B&&, int ) ); > > +SA( ! __is_invocable( B*, int ) ); > > +SA( ! __is_invocable( CB, int ) ); > > +SA( ! __is_invocable( CB&, int ) ); > > +SA( ! __is_invocable( CB*, int ) ); > > + > > +SA( ! __is_invocable( B, int, int ) ); > > +SA( ! __is_invocable( B&, int, int ) ); > > +SA( ! __is_invocable( B&&, int, int ) ); > > +SA( ! __is_invocable( B*, int, int ) ); > > +SA( ! __is_invocable( CB, int, int ) ); > > +SA( ! __is_invocable( CB&, int, int ) ); > > +SA( ! __is_invocable( CB*, int, int ) ); > > + > > +struct C : B { int& operator()() = delete; }; > > +using CC = const C; > > + > > +SA( ! __is_invocable( C ) ); > > +SA( ! __is_invocable( C& ) ); > > +SA( ! __is_invocable( C&& ) ); > > +SA( ! __is_invocable( C* ) ); > > +SA( ! __is_invocable( CC ) ); > > +SA( ! __is_invocable( CC& ) ); > > +SA( ! __is_invocable( CC* ) ); > > + > > +struct D { B operator*(); }; > > +using CD = const D; > > + > > +SA( ! __is_invocable( D ) ); > > + > > +struct E { void v(); }; > > +using CE = const E; > > + > > +SA( ! __is_invocable( E ) ); > > +SA( ! __is_invocable( void (E::*)() ) ); > > +SA( __is_invocable( void (E::*)(), E ) ); > > +SA( __is_invocable( void (E::*)(), E* ) ); > > +SA( ! __is_invocable( void (E::*)(), CE ) ); > > + > > +struct F : E {}; > > +using CF = const F; > > + > > +SA( ! __is_invocable( F ) ); > > +SA( __is_invocable( void (E::*)(), F ) ); > > +SA( __is_invocable( void (E::*)(), F* ) ); > > +SA( ! __is_invocable( void (E::*)(), CF ) ); > > + > > +struct G { E operator*(); }; > > +using CG = const G; > > + > > +SA( ! __is_invocable( G ) ); > > +SA( __is_invocable( void (E::*)(), G ) ); > > +SA( ! __is_invocable( void (E::*)(), G* ) ); > > +SA( ! __is_invocable( void (E::*)(), CG ) ); > > + > > +struct H { E& operator*(); }; > > +using CH = const H; > > + > > +SA( ! __is_invocable( H ) ); > > +SA( __is_invocable( void (E::*)(), H ) ); > > +SA( ! __is_invocable( void (E::*)(), H* ) ); > > +SA( ! __is_invocable( void (E::*)(), CH ) ); > > + > > +struct I { E&& operator*(); }; > > +using CI = const I; > > + > > +SA( ! __is_invocable( I ) ); > > +SA( __is_invocable( void (E::*)(), I ) ); > > +SA( ! __is_invocable( void (E::*)(), I* ) ); > > +SA( ! __is_invocable( void (E::*)(), CI ) ); > > + > > +struct K { E* operator*(); }; > > +using CK = const K; > > + > > +SA( ! __is_invocable( K ) ); > > +SA( ! __is_invocable( void (E::*)(), K ) ); > > +SA( ! __is_invocable( void (E::*)(), K* ) ); > > +SA( ! __is_invocable( void (E::*)(), CK ) ); > > + > > +struct L { CE operator*(); }; > > +using CL = const L; > > + > > +SA( ! __is_invocable( L ) ); > > +SA( ! __is_invocable( void (E::*)(), L ) ); > > +SA( ! __is_invocable( void (E::*)(), L* ) ); > > +SA( ! __is_invocable( void (E::*)(), CL ) ); > > + > > +struct M { > > + int i; > > +private: > > + long l; > > +}; > > +using CM = const M; > > + > > +SA( ! __is_invocable( M ) ); > > +SA( ! __is_invocable( M& ) ); > > +SA( ! __is_invocable( M&& ) ); > > +SA( ! __is_invocable( M* ) ); > > +SA( ! __is_invocable( CM ) ); > > +SA( ! __is_invocable( CM& ) ); > > +SA( ! __is_invocable( CM* ) ); > > + > > +SA( ! __is_invocable( int M::* ) ); > > +SA( __is_invocable( int M::*, M ) ); > > +SA( __is_invocable( int M::*, M& ) ); > > +SA( __is_invocable( int M::*, M&& ) ); > > +SA( __is_invocable( int M::*, M* ) ); > > +SA( __is_invocable( int M::*, CM ) ); > > +SA( __is_invocable( int M::*, CM& ) ); > > +SA( __is_invocable( int M::*, CM* ) ); > > +SA( ! __is_invocable( int M::*, int ) ); > > + > > +SA( ! __is_invocable( int CM::* ) ); > > +SA( __is_invocable( int CM::*, M ) ); > > +SA( __is_invocable( int CM::*, M& ) ); > > +SA( __is_invocable( int CM::*, M&& ) ); > > +SA( __is_invocable( int CM::*, M* ) ); > > +SA( __is_invocable( int CM::*, CM ) ); > > +SA( __is_invocable( int CM::*, CM& ) ); > > +SA( __is_invocable( int CM::*, CM* ) ); > > +SA( ! __is_invocable( int CM::*, int ) ); > > + > > +SA( ! __is_invocable( long M::* ) ); > > +SA( __is_invocable( long M::*, M ) ); > > +SA( __is_invocable( long M::*, M& ) ); > > +SA( __is_invocable( long M::*, M&& ) ); > > +SA( __is_invocable( long M::*, M* ) ); > > +SA( __is_invocable( long M::*, CM ) ); > > +SA( __is_invocable( long M::*, CM& ) ); > > +SA( __is_invocable( long M::*, CM* ) ); > > +SA( ! __is_invocable( long M::*, long ) ); > > + > > +SA( ! __is_invocable( long CM::* ) ); > > +SA( __is_invocable( long CM::*, M ) ); > > +SA( __is_invocable( long CM::*, M& ) ); > > +SA( __is_invocable( long CM::*, M&& ) ); > > +SA( __is_invocable( long CM::*, M* ) ); > > +SA( __is_invocable( long CM::*, CM ) ); > > +SA( __is_invocable( long CM::*, CM& ) ); > > +SA( __is_invocable( long CM::*, CM* ) ); > > +SA( ! __is_invocable( long CM::*, long ) ); > > + > > +SA( ! __is_invocable( short M::* ) ); > > +SA( __is_invocable( short M::*, M ) ); > > +SA( __is_invocable( short M::*, M& ) ); > > +SA( __is_invocable( short M::*, M&& ) ); > > +SA( __is_invocable( short M::*, M* ) ); > > +SA( __is_invocable( short M::*, CM ) ); > > +SA( __is_invocable( short M::*, CM& ) ); > > +SA( __is_invocable( short M::*, CM* ) ); > > +SA( ! __is_invocable( short M::*, short ) ); > > + > > +SA( ! __is_invocable( short CM::* ) ); > > +SA( __is_invocable( short CM::*, M ) ); > > +SA( __is_invocable( short CM::*, M& ) ); > > +SA( __is_invocable( short CM::*, M&& ) ); > > +SA( __is_invocable( short CM::*, M* ) ); > > +SA( __is_invocable( short CM::*, CM ) ); > > +SA( __is_invocable( short CM::*, CM& ) ); > > +SA( __is_invocable( short CM::*, CM* ) ); > > +SA( ! __is_invocable( short CM::*, short ) ); > > + > > +struct N { M operator*(); }; > > +SA( __is_invocable( int M::*, N ) ); > > +SA( ! __is_invocable( int M::*, N* ) ); > > + > > +struct O { M& operator*(); }; > > +SA( __is_invocable( int M::*, O ) ); > > +SA( ! __is_invocable( int M::*, O* ) ); > > + > > +struct P { M&& operator*(); }; > > +SA( __is_invocable( int M::*, P ) ); > > +SA( ! __is_invocable( int M::*, P* ) ); > > + > > +struct Q { M* operator*(); }; > > +SA( ! __is_invocable( int M::*, Q ) ); > > +SA( ! __is_invocable( int M::*, Q* ) ); > > + > > +struct R { void operator()(int = 0); }; > > + > > +SA( __is_invocable( R ) ); > > +SA( __is_invocable( R, int ) ); > > +SA( ! __is_invocable( R, int, int ) ); > > + > > +struct S { void operator()(int, ...); }; > > + > > +SA( ! __is_invocable( S ) ); > > +SA( __is_invocable( S, int ) ); > > +SA( __is_invocable( S, int, int ) ); > > +SA( __is_invocable( S, int, int, int ) ); > > + > > +void fn1() {} > > + > > +SA( __is_invocable( decltype(fn1) ) ); > > + > > +void fn2(int arr[10]); > > + > > +SA( __is_invocable( decltype(fn2), int[10] ) ); > > +SA( __is_invocable( decltype(fn2), int(&)[10] ) ); > > +SA( __is_invocable( decltype(fn2), int(&&)[10] ) ); > > +SA( ! __is_invocable( decltype(fn2), int(*)[10] ) ); > > +SA( ! __is_invocable( decltype(fn2), int(*&)[10] ) ); > > +SA( ! __is_invocable( decltype(fn2), int(*&&)[10] ) ); > > +SA( __is_invocable( decltype(fn2), int[] ) ); > > + > > +auto lambda = []() {}; > > + > > +SA( __is_invocable( decltype(lambda) ) ); > > + > > +template > > +struct can_invoke { > > + static constexpr bool value = __is_invocable( Func, Args... ); > > +}; > > + > > +SA( can_invoke::value ); > > + > > +struct T { > > + void func() const {} > > + int data; > > +}; > > + > > +SA( __is_invocable( decltype(&T::func)&, T& ) ); > > +SA( __is_invocable( decltype(&T::data)&, T& ) ); > > diff --git a/gcc/testsuite/g++.dg/ext/is_invocable2.C b/gcc/testsuite/g++.dg/ext/is_invocable2.C > > new file mode 100644 > > index 00000000000..a68aefd3e13 > > --- /dev/null > > +++ b/gcc/testsuite/g++.dg/ext/is_invocable2.C > > @@ -0,0 +1,139 @@ > > +// { dg-do compile { target c++11 } } > > +// __is_invocable should handle std::reference_wrapper correctly. > > + > > +#include > > + > > +#define SA(X) static_assert((X),#X) > > + > > +using std::reference_wrapper; > > + > > +using func_type_v0 = void(*)(); > > + > > +SA( __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper, int ) ); > > + > > +using func_type_i0 = int(*)(); > > + > > +SA( __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper, int ) ); > > + > > +using func_type_l0 = int&(*)(); > > + > > +SA( __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper ) ); > > + > > +using func_type_ii = int(*)(int); > > + > > +SA( ! __is_invocable( reference_wrapper ) ); > > +SA( __is_invocable( reference_wrapper, int ) ); > > + > > +using func_type_il = int(*)(int&); > > + > > +SA( ! __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper, int ) ); > > +SA( __is_invocable( reference_wrapper, int& ) ); > > + > > +using func_type_ir = int(*)(int&&); > > + > > +SA( ! __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper, int& ) ); > > +SA( __is_invocable( reference_wrapper, int ) ); > > +SA( __is_invocable( reference_wrapper, int&& ) ); > > + > > +struct A { }; > > + > > +using mem_type_i = int A::*; > > + > > +SA( ! __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper, int ) ); > > +SA( ! __is_invocable( reference_wrapper, int* ) ); > > +SA( ! __is_invocable( reference_wrapper, int& ) ); > > +SA( ! __is_invocable( reference_wrapper, int&& ) ); > > +SA( __is_invocable( reference_wrapper, A ) ); > > +SA( __is_invocable( reference_wrapper, A* ) ); > > +SA( __is_invocable( reference_wrapper, A& ) ); > > +SA( __is_invocable( reference_wrapper, A&& ) ); > > + > > +using memfun_type_i = int (A::*)(); > > + > > +SA( ! __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper, int ) ); > > +SA( ! __is_invocable( reference_wrapper, int* ) ); > > +SA( ! __is_invocable( reference_wrapper, int& ) ); > > +SA( ! __is_invocable( reference_wrapper, int&& ) ); > > +SA( __is_invocable( reference_wrapper, A ) ); > > +SA( __is_invocable( reference_wrapper, A* ) ); > > +SA( __is_invocable( reference_wrapper, A& ) ); > > +SA( __is_invocable( reference_wrapper, A&& ) ); > > +SA( ! __is_invocable( reference_wrapper, const A& ) ); > > +SA( ! __is_invocable( reference_wrapper, A&, int ) ); > > + > > +using memfun_type_ic = int (A::*)() const; > > + > > +SA( ! __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper, int ) ); > > +SA( ! __is_invocable( reference_wrapper, int& ) ); > > +SA( __is_invocable( reference_wrapper, A& ) ); > > +SA( __is_invocable( reference_wrapper, A* ) ); > > +SA( ! __is_invocable( reference_wrapper, A&, int ) ); > > +SA( ! __is_invocable( reference_wrapper, A*, int& ) ); > > +SA( __is_invocable( reference_wrapper, const A& ) ); > > +SA( __is_invocable( reference_wrapper, const A* ) ); > > +SA( ! __is_invocable( reference_wrapper, const A&, int& ) ); > > +SA( ! __is_invocable( reference_wrapper, const A*, int ) ); > > + > > +using memfun_type_iic = int& (A::*)(int&) const; > > + > > +SA( ! __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper, int ) ); > > +SA( ! __is_invocable( reference_wrapper, int& ) ); > > +SA( ! __is_invocable( reference_wrapper, A&, int ) ); > > +SA( __is_invocable( reference_wrapper, A&, int& ) ); > > +SA( ! __is_invocable( reference_wrapper, A*, int ) ); > > +SA( __is_invocable( reference_wrapper, A*, int& ) ); > > +SA( ! __is_invocable( reference_wrapper, const A&, int ) ); > > +SA( ! __is_invocable( reference_wrapper, const A&, int&, int ) ); > > +SA( __is_invocable( reference_wrapper, const A&, int& ) ); > > +SA( __is_invocable( reference_wrapper, const A*, int& ) ); > > + > > +struct B { > > + int& operator()(); > > + long& operator()() const; > > + bool& operator()(int); > > +private: > > + void operator()(int, int); > > +}; > > +using CB = const B; > > + > > +SA( __is_invocable( reference_wrapper ) ); > > +SA( __is_invocable( reference_wrapper& ) ); > > +SA( __is_invocable( reference_wrapper&& ) ); > > +SA( __is_invocable( reference_wrapper ) ); > > +SA( __is_invocable( reference_wrapper& ) ); > > +SA( __is_invocable( reference_wrapper, int ) ); > > +SA( ! __is_invocable( reference_wrapper&, int, int ) ); > > + > > +struct C : B { int& operator()() = delete; }; > > +using CC = const C; > > + > > +SA( ! __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper& ) ); > > +SA( ! __is_invocable( reference_wrapper&& ) ); > > +SA( ! __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper& ) ); > > + > > +struct D { B operator*(); }; > > +using CD = const D; > > + > > +SA( ! __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper& ) ); > > +SA( ! __is_invocable( reference_wrapper&& ) ); > > +SA( ! __is_invocable( reference_wrapper* ) ); > > +SA( ! __is_invocable( reference_wrapper ) ); > > +SA( ! __is_invocable( reference_wrapper* ) ); > > + > > +std::function fn = []() {}; > > +auto refwrap = std::ref(fn); > > + > > +SA( __is_invocable( decltype(fn) ) ); > > +SA( __is_invocable( decltype(refwrap) ) ); > > diff --git a/gcc/testsuite/g++.dg/ext/is_invocable3.C b/gcc/testsuite/g++.dg/ext/is_invocable3.C > > new file mode 100644 > > index 00000000000..e2b0c5ef406 > > --- /dev/null > > +++ b/gcc/testsuite/g++.dg/ext/is_invocable3.C > > @@ -0,0 +1,51 @@ > > +// { dg-do compile { target c++11 } } > > +// __is_invocable should handle incomplete class correctly. > > + > > +#define SA(X) static_assert((X),#X) > > + > > +struct Incomplete; > > + > > +SA( ! __is_invocable( Incomplete ) ); // { dg-error "incomplete type" } > > +SA( ! __is_invocable( Incomplete, int ) ); // { dg-error "incomplete type" } > > + > > +SA( ! __is_invocable( int, Incomplete, int ) ); // { dg-error "incomplete type" } > > +SA( ! __is_invocable( int, Incomplete ) ); // { dg-error "incomplete type" } > > + > > +SA( ! __is_invocable( Incomplete, Incomplete() ) ); // { dg-error "incomplete type" } > > +SA( ! __is_invocable( Incomplete, Incomplete(int), int ) ); // { dg-error "incomplete type" } > > +SA( ! __is_invocable( Incomplete, Incomplete(int, int), int, int ) ); // { dg-error "incomplete type" } > > + > > +SA( ! __is_invocable( Incomplete, Incomplete(), int, int ) ); // { dg-error "incomplete type" } > > + > > +SA( ! __is_invocable( int(Incomplete), Incomplete ) ); // { dg-error "incomplete type" } > > +SA( ! __is_invocable( int(int, Incomplete), int, Incomplete ) ); // { dg-error "incomplete type" } > > +SA( ! __is_invocable( int(int, Incomplete), Incomplete, int ) ); // { dg-error "incomplete type" } > > + > > +SA( __is_invocable( int(Incomplete&), Incomplete& ) ); // { dg-bogus "incomplete type" } > > +SA( __is_invocable( int(int, Incomplete&), int, Incomplete& ) ); // { dg-bogus "incomplete type" } > > + > > +SA( __is_invocable( int(Incomplete&&), Incomplete&& ) ); // { dg-bogus "incomplete type" } > > +SA( __is_invocable( int(int, Incomplete&&), int, Incomplete&& ) ); // { dg-bogus "incomplete type" } > > + > > +SA( __is_invocable( int(const Incomplete&&), const Incomplete&& ) ); // { dg-bogus "incomplete type" } > > +SA( __is_invocable( int(int, const Incomplete&&), int, const Incomplete&& ) ); // { dg-bogus "incomplete type" } > > + > > +SA( __is_invocable( int(const Incomplete&), const Incomplete& ) ); // { dg-bogus "incomplete type" } > > +SA( __is_invocable( int(int, const Incomplete&), int, const Incomplete& ) ); // { dg-bogus "incomplete type" } > > + > > +SA( __is_invocable( int(const Incomplete&), Incomplete& ) ); // { dg-bogus "incomplete type" } > > +SA( __is_invocable( int(int, const Incomplete&), int, Incomplete& ) ); // { dg-bogus "incomplete type" } > > + > > +SA( __is_invocable( int Incomplete::*, const Incomplete& ) ); // { dg-bogus "incomplete type" } > > +SA( ! __is_invocable( void (Incomplete::*)(long&), const Incomplete*, long& ) ); // { dg-bogus "incomplete type" } > > +SA( __is_invocable( void (Incomplete::*)(long&) const, Incomplete*, long& ) ); // { dg-bogus "incomplete type" } > > + > > +template > > +struct Holder { T t; }; > > + > > +SA( __is_invocable( int(Holder&), Holder& ) ); // { dg-bogus "incomplete type" } > > + > > +// Define Incomplete, which is now not incomplete. > > +struct Incomplete { void operator()(); }; > > + > > +SA( __is_invocable( Incomplete ) ); // { dg-bogus "incomplete type" } > > diff --git a/gcc/testsuite/g++.dg/ext/is_invocable4.C b/gcc/testsuite/g++.dg/ext/is_invocable4.C > > new file mode 100644 > > index 00000000000..d1efccf08f8 > > --- /dev/null > > +++ b/gcc/testsuite/g++.dg/ext/is_invocable4.C > > @@ -0,0 +1,33 @@ > > +// { dg-do compile { target c++11 } } > > +// Failed access check should be a substitution failure, not an error. > > + > > +#define SA(X) static_assert((X),#X) > > + > > +template > > +struct bool_constant { static constexpr bool value = B; }; > > + > > +template > > +struct is_invocable > > +: public bool_constant<__is_invocable(_Fn, _ArgTypes...)> > > +{ }; > > + > > +#if __cpp_variable_templates > > +template > > +constexpr bool is_invocable_v = __is_invocable(_Fn, _ArgTypes...); > > +#endif > > + > > +class Private > > +{ > > + void operator()() const > > + { > > + SA( ! is_invocable::value ); > > +#if __cpp_variable_templates > > + SA( ! is_invocable_v ); > > +#endif > > + } > > +}; > > + > > +SA( ! is_invocable::value ); > > +#if __cpp_variable_templates > > +SA( ! is_invocable_v ); > > +#endif > > -- > > 2.42.0 > > > > >