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 207A03858410 for ; Thu, 6 Jan 2022 18:25:57 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 207A03858410 Received: from mail-qt1-f199.google.com (mail-qt1-f199.google.com [209.85.160.199]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-486-1bgU0RRlNRKQRKvI3lIZUg-1; Thu, 06 Jan 2022 13:25:55 -0500 X-MC-Unique: 1bgU0RRlNRKQRKvI3lIZUg-1 Received: by mail-qt1-f199.google.com with SMTP id e30-20020ac8011e000000b002c4bb72a062so2642559qtg.15 for ; Thu, 06 Jan 2022 10:25:55 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:date:to:cc:subject:in-reply-to:message-id :references:mime-version; bh=NunM1lL8l34+SeaJi9n1WTpQbszFQUhxcLA3KlWYatc=; b=tWAFykIxLkYcgWiNrdcV1/tVodJ3IDf3xoOUUwYXUMIIbZ2sTL01T48UP9EDLP2gC5 uqB0VzyIvBXO41jWDyLjl0O4+UZFIR+el8q6ApNNMx1gCZgIAFehYfNBgbY9aD/kzCIi W4LYT7U474VEfre71oHq0assR3ROOcQRqhQNoX5tWHMrgYYcG7erkIpvAci47ZQXwAXR QBdfC7ahk1SpmTA5V2wkOdQkMoDVUc1GmsiSnJ2N0uIst9gICfRWR8bHvg49C0oTC31B qvnb80LroLfiOd8TGKvB9efm3ufefk6WajVYgKANB5RSWaTWj2RjOI/7PZLwg3kuqzPN uOmA== X-Gm-Message-State: AOAM530TmTOH2QFRX31laRGSxriTeOz4OOvq/1PN2tzTd4RixG6lLjhJ iSO5QVr4gC06AydnSIW9O5fBYEch/wc8DUIEew4QO00cvnvbaChU8XbMDjmWFDADfVxAffF+l/8 Vv/OlTkfwQTkKNTBXRQ== X-Received: by 2002:a05:622a:40f:: with SMTP id n15mr52064302qtx.296.1641493554545; Thu, 06 Jan 2022 10:25:54 -0800 (PST) X-Google-Smtp-Source: ABdhPJxTBGG5ljbYRDUlikt/nu7tRJnktZMwUyDLtCEKy7KqQlSaVLnWwjudCW+xACX0BSLb4Bn9cQ== X-Received: by 2002:a05:622a:40f:: with SMTP id n15mr52064269qtx.296.1641493553884; Thu, 06 Jan 2022 10:25:53 -0800 (PST) Received: from [192.168.1.130] (ool-18e40894.dyn.optonline.net. [24.228.8.148]) by smtp.gmail.com with ESMTPSA id bs30sm1856222qkb.87.2022.01.06.10.25.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 06 Jan 2022 10:25:53 -0800 (PST) From: Patrick Palka X-Google-Original-From: Patrick Palka Date: Thu, 6 Jan 2022 13:25:52 -0500 (EST) To: Patrick Palka cc: Jason Merrill , GCC Patches Subject: Re: [PATCH] c++: CTAD within alias template [PR91911] In-Reply-To: <0879be3d-936f-9a01-ec86-6b826eaac66c@idea> Message-ID: References: <20210624204529.4136660-1-ppalka@redhat.com> <3802ce35-3e48-fb97-8868-d1274ed0a778@redhat.com> <0719adf2-7a17-a8a7-9374-cbfa41846499@redhat.com> <8b6edd86-9db0-f6e2-386f-4693d1692f5f@idea> <67855539-bf99-ac7-a995-35871cd23712@idea> <7f944b48-7c8f-755a-8cea-0880cbda4ccc@redhat.com> <7d2f4e2b-4e31-4ae7-8d80-5676a17e9de5@redhat.com> <8bec1e70-7ea6-b885-2c89-443d96822efd@redhat.com> <0879be3d-936f-9a01-ec86-6b826eaac66c@idea> 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=-14.7 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 06 Jan 2022 18:26:00 -0000 On Mon, 3 Jan 2022, Patrick Palka wrote: > On Wed, 22 Dec 2021, Jason Merrill wrote: > > > On 12/21/21 14:08, Patrick Palka wrote: > > > On Tue, Dec 21, 2021 at 2:03 PM Patrick Palka wrote: > > > > > > > > On Wed, Jun 30, 2021 at 4:23 PM Jason Merrill wrote: > > > > > > > > > > On 6/30/21 4:18 PM, Patrick Palka wrote: > > > > > > On Wed, Jun 30, 2021 at 3:51 PM Jason Merrill > > > > > > wrote: > > > > > > > > > > > > > > On 6/30/21 11:58 AM, Patrick Palka wrote: > > > > > > > > On Wed, 30 Jun 2021, Patrick Palka wrote: > > > > > > > > > > > > > > > > > On Fri, 25 Jun 2021, Jason Merrill wrote: > > > > > > > > > > > > > > > > > > > On 6/25/21 1:11 PM, Patrick Palka wrote: > > > > > > > > > > > On Fri, 25 Jun 2021, Jason Merrill wrote: > > > > > > > > > > > > > > > > > > > > > > > On 6/24/21 4:45 PM, Patrick Palka wrote: > > > > > > > > > > > > > In the first testcase below, during parsing of the alias > > > > > > > > > > > > > template > > > > > > > > > > > > > ConstSpanType, transparency of alias template > > > > > > > > > > > > > specializations means we > > > > > > > > > > > > > replace SpanType with SpanType's substituted > > > > > > > > > > > > > definition. But this > > > > > > > > > > > > > substitution lowers the level of the CTAD placeholder > > > > > > > > > > > > > for span(T()) from > > > > > > > > > > > > > 2 to 1, and so the later instantiantion of > > > > > > > > > > > > > ConstSpanType > > > > > > > > > > > > > erroneously substitutes this CTAD placeholder with the > > > > > > > > > > > > > template argument > > > > > > > > > > > > > at level 1 index 0, i.e. with int, before we get a > > > > > > > > > > > > > chance to perform the > > > > > > > > > > > > > CTAD. > > > > > > > > > > > > > > > > > > > > > > > > > > In light of this, it seems we should avoid level > > > > > > > > > > > > > lowering when > > > > > > > > > > > > > substituting through through the type-id of a dependent > > > > > > > > > > > > > alias template > > > > > > > > > > > > > specialization. To that end this patch makes > > > > > > > > > > > > > lookup_template_class_1 > > > > > > > > > > > > > pass tf_partial to tsubst in this situation. > > > > > > > > > > > > > > > > > > > > > > > > This makes sense, but what happens if SpanType is a member > > > > > > > > > > > > template, so > > > > > > > > > > > > that > > > > > > > > > > > > the levels of it and ConstSpanType don't match? Or the > > > > > > > > > > > > other way around? > > > > > > > > > > > > > > > > > > > > > > If SpanType is a member template of say the class > > > > > > > > > > > template A (and > > > > > > > > > > > thus its level is greater than ConstSpanType): > > > > > > > > > > > > > > > > > > > > > > template > > > > > > > > > > > struct A { > > > > > > > > > > > template > > > > > > > > > > > using SpanType = decltype(span(T())); > > > > > > > > > > > }; > > > > > > > > > > > > > > > > > > > > > > template > > > > > > > > > > > using ConstSpanType = span > > > > > > > > > > A::SpanType::value_type>; > > > > > > > > > > > > > > > > > > > > > > using type = ConstSpanType; > > > > > > > > > > > > > > > > > > > > > > then this case luckily works even without the patch because > > > > > > > > > > > instantiate_class_template now reuses the specialization > > > > > > > > > > > A::SpanType > > > > > > > > > > > that was formed earlier during instantiation of A, > > > > > > > > > > > where we > > > > > > > > > > > substitute only a single level of template arguments, so the > > > > > > > > > > > level of > > > > > > > > > > > the CTAD placeholder inside the defining-type-id of this > > > > > > > > > > > specialization > > > > > > > > > > > dropped from 3 to 2, so still more than the level of > > > > > > > > > > > ConstSpanType. > > > > > > > > > > > > > > > > > > > > > > This luck is short-lived though, because if we replace > > > > > > > > > > > A::SpanType with say A::SpanType then > > > > > > > > > > > the testcase > > > > > > > > > > > breaks again (without the patch) because we no longer can > > > > > > > > > > > reuse that > > > > > > > > > > > specialization, so we instead form it on the spot by > > > > > > > > > > > substituting two > > > > > > > > > > > levels of template arguments (U=int,T=T) into the > > > > > > > > > > > defining-type-id, > > > > > > > > > > > causing the level of the placeholder to drop to 1. I think > > > > > > > > > > > the patch > > > > > > > > > > > causes its level to remain 3 (though I guess it should > > > > > > > > > > > really be 2). > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > For the other way around, if ConstSpanType is a member > > > > > > > > > > > template of > > > > > > > > > > > say the class template B (and thus its level is greater > > > > > > > > > > > than > > > > > > > > > > > SpanType): > > > > > > > > > > > > > > > > > > > > > > template > > > > > > > > > > > using SpanType = decltype(span(T())); > > > > > > > > > > > > > > > > > > > > > > template > > > > > > > > > > > struct B { > > > > > > > > > > > template > > > > > > > > > > > using ConstSpanType = span > > > > > > > > > > SpanType::value_type>; > > > > > > > > > > > }; > > > > > > > > > > > > > > > > > > > > > > using type = B::ConstSpanType; > > > > > > > > > > > > > > > > > > > > > > then tf_partial doesn't help here at all; we end up > > > > > > > > > > > substituting 'int' > > > > > > > > > > > for the CTAD placeholder... What it seems we need is to > > > > > > > > > > > _increase_ the > > > > > > > > > > > level of the CTAD placeholder from 2 to 3 during the > > > > > > > > > > > dependent > > > > > > > > > > > substitution.. > > > > > > > > > > > > > > > > > > > > > > Hmm, rather than messing with tf_partial, which is > > > > > > > > > > > apparently only a > > > > > > > > > > > partial solution, maybe we should just make tsubst never > > > > > > > > > > > substitute a > > > > > > > > > > > CTAD placeholder -- they should always be resolved from > > > > > > > > > > > do_class_deduction, > > > > > > > > > > > and their level doesn't really matter otherwise. (But we'd > > > > > > > > > > > still want > > > > > > > > > > > to substitute into the CLASS_PLACEHOLDER_TEMPLATE of the > > > > > > > > > > > placeholder in > > > > > > > > > > > case it's a template template parm.) Something like: > > > > > > > > > > > > > > > > > > > > > > diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c > > > > > > > > > > > index 5107bfbf9d1..dead651ed84 100644 > > > > > > > > > > > --- a/gcc/cp/pt.c > > > > > > > > > > > +++ b/gcc/cp/pt.c > > > > > > > > > > > @@ -15552,7 +15550,8 @@ tsubst (tree t, tree args, > > > > > > > > > > > tsubst_flags_t complain, > > > > > > > > > > > tree in_decl) > > > > > > > > > > > levels = TMPL_ARGS_DEPTH (args); > > > > > > > > > > > if (level <= levels > > > > > > > > > > > - && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args, level)) > > > > > > > > > > > > 0) > > > > > > > > > > > + && TREE_VEC_LENGTH (TMPL_ARGS_LEVEL (args, level)) > > > > > > > > > > > > 0 > > > > > > > > > > > + && !template_placeholder_p (t)) > > > > > > > > > > > { > > > > > > > > > > > arg = TMPL_ARG (args, level, idx); > > > > > > > > > > > > > > > > > > > > > > seems to work better. > > > > > > > > > > > > > > > > > > > > Makes sense. > > > > > > > > > > > > > > > > > > Here's a patch that implements that. I reckon it's good to have > > > > > > > > > both > > > > > > > > > workarounds in place because the tf_partial workaround is > > > > > > > > > necessary to > > > > > > > > > accept class-deduction93a.C below, and the tsubst workaround is > > > > > > > > > necessary to accept class-deduction-92b.C below. > > > > > > > > > > > > > > > > Whoops, forgot to git-add class-deduction93a.C: > > > > > > > > > > > > > > > > -- >8 -- > > > > > > > > > > > > > > > > Subject: [PATCH] c++: CTAD within alias template [PR91911] > > > > > > > > > > > > > > > > In the first testcase below, during parsing of the alias template > > > > > > > > ConstSpanType, transparency of alias template specializations > > > > > > > > means we > > > > > > > > replace SpanType with SpanType's substituted definition. But > > > > > > > > this > > > > > > > > substitution lowers the level of the CTAD placeholder for > > > > > > > > span{T()} from > > > > > > > > 2 to 1, and so the later instantiation of ConstSpanType > > > > > > > > erroneously > > > > > > > > substitutes this CTAD placeholder with the template argument at > > > > > > > > level 1 > > > > > > > > index 0, i.e. with int, before we get a chance to perform the > > > > > > > > CTAD. > > > > > > > > > > > > > > > > In light of this, it seems we should avoid level lowering when > > > > > > > > substituting through the type-id of a dependent alias template > > > > > > > > specialization. To that end this patch makes > > > > > > > > lookup_template_class_1 > > > > > > > > pass tf_partial to tsubst in this situation. > > > > > > > > > > > > > > > > Unfortunately, using tf_partial alone isn't sufficient because the > > > > > > > > template context in which we perform the dependent substitution > > > > > > > > may > > > > > > > > have more levels than the substituted alias template and so we > > > > > > > > end up substituting the CTAD placeholder anyway, as in > > > > > > > > class-deduction92b.C below. (There, it seems we'd need to > > > > > > > > _increase_ > > > > > > > > the level of the placeholder for span{T()} from 2 to 3 during the > > > > > > > > dependent substitution.) Since we never want to resolve a CTAD > > > > > > > > placeholder outside of CTAD proper, this patch takes the > > > > > > > > relatively > > > > > > > > ad-hoc approach of making tsubst explicitly avoid doing so. > > > > > > > > > > > > > > > > This tsubst workaround doesn't obviate the tf_partial workaround > > > > > > > > because > > > > > > > > it's still desirable to avoid prematurely level lowering a CTAD > > > > > > > > placeholder: > > > > > > > > it's less work for the compiler, and it gives us a chance to > > > > > > > > substitute > > > > > > > > a template placeholder that's a template template parameter with a > > > > > > > > concrete template template argument, as in the last testcase > > > > > > > > below. > > > > > > > > > > > > > > Hmm, what if we combine the template template parameter with the > > > > > > > level > > > > > > > mismatch? > > > > > > > > > > > > So for e.g. > > > > > > > > > > > > template class Tmpl> > > > > > > using CallableTraitT = CallableTrait; > > > > > > > > > > > > template > > > > > > struct A { > > > > > > template class Tmpl> > > > > > > using ReturnType = typename CallableTraitT::ReturnType; > > > > > > }; > > > > > > > > > > > > using type = A::ReturnType; > > > > > > using type = int; > > > > > > > > > > > > sadly we crash, because during the dependent substitution of the > > > > > > innermost arguments into the defining-type-id, tf_partial means we > > > > > > don't lower the level of the CTAD placeholder and therefore don't > > > > > > substitute into CLASS_PLACEHOLDER_TEMPLATE, so > > > > > > CLASS_PLACEHOLDER_TEMPLATE remains a template template parm at index 1 > > > > > > level 1 (as opposed to level 2). Later during the full > > > > > > instantiation, there is no such template template argument at that > > > > > > position (it's at index 1 level 2 rather). > > > > > > > > > > > > To handle this testcase, it seems we need a way to substitute into > > > > > > CTAD placeholders without lowering their level I guess. > > > > > > > > > > Or replacing their level with the appropriate level for the args we're > > > > > dealing with/whether tf_partial is set? > > > > > > > > That sounds like it might work for CTAD placeholders, since we never > > > > want to replace them via tsubst anyway. But I suppose a complete > > > > solution to this problem would also need to adjust the level of 'auto' > > > > that appears inside unevaluated lambdas (and C++23 auto(x) now too, I > > > > guess). And the tricky part with those is that we do sometimes want > > > > to replace 'auto's via tsubst, in particular during > > > > do_auto_deduction.. > > > > > > > > I wonder if for now the v1 patch (the one consisting of just the > > > > lookup_template_class_1 change) can go in? I noticed that it also > > > > fixes a slew of (essentially duplicate) PRs about simple uses of > > > > unevaluated lambdas within alias templates: 100594, 92211, 103569, > > > > 102680, 101315, 101013, 92707. (The template_placeholder_p change in > > > > the v2 patch I realized is buggy -- by avoiding substitution into the > > > > CTAD placeholder, we fall back to level-lowering, but since level <= > > > > levels we end up creating a CTAD > > > placeholder with nonpositive level. > > > > > - t = tsubst (TREE_TYPE (gen_tmpl), arglist, complain, in_decl); > > > + /* When substituting a dependent alias template specialization, > > > + we pass tf_partial to avoid lowering the level of any 'auto' > > > + in its type-id which might correspond to CTAD placeholders. */ > > > + t = tsubst (TREE_TYPE (gen_tmpl), arglist, > > > + complain | (is_dependent_type * tf_partial), > > > + in_decl); > > > > So, if we aren't changing any containing template scopes from dependent to > > non-dependent, we don't want to mess with levels. > > > > I think is_dependent_type is a bit too broad here; I'd expect this could cause > > trouble when e.g. instantiating a class A with a member template B and we > > have both B and an auto in the signature of a member template. I think > > what we want to check is whether the outermost args are dependent. > > Ah yeah, I see what you mean... > > > > > It would also be safer to handle adding tf_partial for alias templates in > > instantiate_alias_template rather than lookup_template_class. Perhaps in > > alias_ctad_tweaks as well. > > > > I tried adding an assert that tf_partial is set any time we see dependent > > outermost args; I expected to need to override that for deduction guide > > rewriting, but also seem to hit problems in concepts and TTP. Attached in > > case you're interested; I don't think this is going to become a patch suitable > > for GCC 12. The use of uses_template_parms_level was a kludge because > > dependent_template_arg_p returns true for null args. > > Interesting. In light of this general problem, I wonder if representing > autos as template parameters with one level greater than the template > depth, while convenient, is ultimately not the best approach? > > Back to the original issue concerning CTAD within alias templates, > here's an approach that seems to work well. The idea is to treat > CTAD placeholders less like template parameters, by giving them > the special level 0, and by making tsubst avoid substituting them > like template parameters. With this approach the representation > of a CTAD placeholder no longer depends on the template depth, so > alias template transparency for alias templates that contain CTAD > just works. > > I tried extending this approach to all autos (i.e. giving all > autos a level of 0 and adjusting tsubst accordingly), and it nearly > works modulo handling concepts TS auto... deduction: > > tuple x = tuple{}. > > since unify_pack_expansion isn't prepared to see a parameter pack of > level 0. This is likely fixable, but I suppose it'd be good to first > get confirmation that this is a good approach before continuing down > this patch. > > Below the patch that implements this approach only for CTAD > placeholders. Attached is an incremental WIP diff that additionally > extends the approach to all autos, which passes testing modulo the > concept TS thing. I should note one other complication with extending this approach to all autos is the handling of the constraint on a constrained auto such as template void g() { C auto x = ...; } We represent such a constraint as a concept-id whose first argument is the auto itself, e.g. C for the above example, and we check satisfaction by passing the deduced type as an additional innermost template argument level, and this works precisely because the level of the auto is one greater than the template depth. So by giving autos a level of 0, we also have to somehow change the representation of the concept-id or change the way we check satisfaction of a constrained auto. One idea is to surgically replace the first argument of the concept-id with the deduced type before checking satisfaction. But this approach is not quite equivalent: it may sometimes lead to unexpected hard errors during normalization, e.g. in g++.dg/cpp2a/concepts-return-req1.C (there we'd complain about the substitution of T::type with T=int during normalization). So it's important that the first argument remains dependent before checking satisfaction. Another idea is to surgically replace the first argument of the concept-id with 'decltype(dependent-init)'. This seems like it'd work, but we currently don't have the dependent initializer readily available from do_auto_deduction. The approach the incremental patch takes here is to give the first argument of the concept-id a different, dummy auto with level 1 + template_depth while giving the overall constrained auto level 0. So it's not quite true that all autos have level 0 after the patch -- the one exception is the implicit first argument of a concept-id that represents the constraint on a constrained auto. Hmm, perhaps it might be better to not call this dummy parm an auto at all, and instead just treat it as an anonymous template parm (with level 1 + template_depth), so that we can truly say "all autos have level 0"... > > -- >8 -- > > Subject: [PATCH] c++: CTAD inside alias template [PR91911] > > In the first testcase below, during parsing of the alias template > ConstSpanType, transparency of alias template specializations means we > replace SpanType with its instantiated definition. But this > instantiation lowers the level of the CTAD placeholder for span{T()} from > 2 to 1, and so the later instantiation of ConstSpanType erroneously > substitutes this CTAD placeholder with the template argument at level 1 > index 0, i.e. with int, before we get a chance to perform the CTAD. > > Although we represent CTAD placeholders as template parameters, we never > actually want to replace them via tsubst. So this patch adjusts tsubst > to handle CTAD placeholders by simply substituting the template and > returning a new CTAD placeholder. Moreover, this means that the level > of a CTAD placeholder doesn't matter, so we may as well give them all > the same level. This patch gives them the special level 0. > > The change in grokdeclarator makes us reject an invalid function > return type consisting of a CTAD placeholder sooner (as in pr88187.C), > which helps guarantee that splice_late_return_type doesn't see or need > to handle a erroneous CTAD placeholder return type. > > The change in tsubst_decl removes a CHECKING_P workaround added in 2017, > which would otherwise now get triggered for variables with CTAD placeholder > types (since their level is 0). Alternatively, we could just guard the > workaround with !template_placeholder_p if that's preferable. > > Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look OK for > trunk? > > PR c++/91911 > > gcc/cp/ChangeLog: > > * decl.c (grokdeclarator): Diagnose CTAD placeholder in function > return type even when !funcdecl_p. > * pt.c (keep_template_parm): Punt on a level 0 template parm. > (tsubst_decl) : Remove CHECKING_P workaround. > (tsubst) : Handle CTAD placeholders > specially. > (make_auto_1): Add defaulted 'level' parameter. > (make_template_placeholder): Pass 0 as 'level' to make_auto_1. > > gcc/testsuite/ChangeLog: > > * g++.dg/cpp1z/class-deduction100.C: New test. > * g++.dg/cpp1z/class-deduction100a.C: New test. > * g++.dg/cpp1z/class-deduction100b.C: New test. > * g++.dg/cpp1z/class-deduction101.C: New test. > * g++.dg/cpp1z/class-deduction101a.C: New test. > * g++.dg/cpp1z/class-deduction101b.C: New test. > --- > gcc/cp/decl.c | 6 +- > gcc/cp/pt.c | 60 ++++++++----------- > .../g++.dg/cpp1z/class-deduction100.C | 17 ++++++ > .../g++.dg/cpp1z/class-deduction100a.C | 22 +++++++ > .../g++.dg/cpp1z/class-deduction100b.C | 22 +++++++ > .../g++.dg/cpp1z/class-deduction101.C | 25 ++++++++ > .../g++.dg/cpp1z/class-deduction101a.C | 27 +++++++++ > .../g++.dg/cpp1z/class-deduction101b.C | 30 ++++++++++ > gcc/testsuite/g++.dg/other/pr88187.C | 2 +- > 9 files changed, 173 insertions(+), 38 deletions(-) > create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction100.C > create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction100a.C > create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction100b.C > create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction101.C > create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction101a.C > create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction101b.C > > diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c > index 0b71c00f5ab..406a9163ffd 100644 > --- a/gcc/cp/decl.c > +++ b/gcc/cp/decl.c > @@ -12635,11 +12635,11 @@ grokdeclarator (const cp_declarator *declarator, > if (!tmpl) > if (tree late_auto = type_uses_auto (late_return_type)) > tmpl = CLASS_PLACEHOLDER_TEMPLATE (late_auto); > - if (tmpl && funcdecl_p) > + if (tmpl) > { > - if (!dguide_name_p (unqualified_id)) > + if (!funcdecl_p || !dguide_name_p (unqualified_id)) > { > - error_at (declarator->id_loc, "deduced class " > + error_at (typespec_loc, "deduced class " > "type %qD in function return type", > DECL_NAME (tmpl)); > inform (DECL_SOURCE_LOCATION (tmpl), > diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c > index c587966adbe..08e34c7404a 100644 > --- a/gcc/cp/pt.c > +++ b/gcc/cp/pt.c > @@ -10660,7 +10660,7 @@ keep_template_parm (tree t, void* data) > int level; > int index; > template_parm_level_and_index (t, &level, &index); > - if (level > ftpi->max_depth) > + if (level == 0 || level > ftpi->max_depth) > return 0; > > if (TREE_CODE (t) == BOUND_TEMPLATE_TEMPLATE_PARM) > @@ -14796,20 +14796,7 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain) > && VAR_HAD_UNKNOWN_BOUND (t) > && type != error_mark_node) > type = strip_array_domain (type); > - tree sub_args = args; > - if (tree auto_node = type_uses_auto (type)) > - { > - /* Mask off any template args past the variable's context so we > - don't replace the auto with an unrelated argument. */ > - int nouter = TEMPLATE_TYPE_LEVEL (auto_node) - 1; > - int extra = TMPL_ARGS_DEPTH (args) - nouter; > - if (extra > 0) > - /* This should never happen with the new lambda instantiation > - model, but keep the handling just in case. */ > - gcc_assert (!CHECKING_P), > - sub_args = strip_innermost_template_args (args, extra); > - } > - type = tsubst (type, sub_args, complain, in_decl); > + type = tsubst (type, args, complain, in_decl); > /* Substituting the type might have recursively instantiated this > same alias (c++/86171). */ > if (gen_tmpl && DECL_ALIAS_TEMPLATE_P (gen_tmpl) > @@ -15561,6 +15548,19 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) > } > > case TEMPLATE_TYPE_PARM: > + if (template_placeholder_p (t)) > + { > + tree tmpl = CLASS_PLACEHOLDER_TEMPLATE (t); > + tmpl = tsubst_copy (tmpl, args, complain, in_decl); > + if (TREE_CODE (tmpl) == TEMPLATE_TEMPLATE_PARM) > + tmpl = TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (tmpl); > + > + if (tmpl != CLASS_PLACEHOLDER_TEMPLATE (t)) > + return make_template_placeholder (tmpl); > + else > + return t; > + } > + /* Fall through. */ > case TEMPLATE_TEMPLATE_PARM: > case BOUND_TEMPLATE_TEMPLATE_PARM: > case TEMPLATE_PARM_INDEX: > @@ -15734,7 +15734,6 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) > of a constrained placeholder. */; > else if (TREE_CODE (t) == TEMPLATE_TYPE_PARM > && !PLACEHOLDER_TYPE_CONSTRAINTS_INFO (t) > - && !CLASS_PLACEHOLDER_TEMPLATE (t) > && (arg = TEMPLATE_TYPE_PARM_INDEX (t), > r = TEMPLATE_PARM_DESCENDANTS (arg)) > && (TEMPLATE_PARM_LEVEL (r) > @@ -15753,19 +15752,10 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl) > TYPE_REFERENCE_TO (r) = NULL_TREE; > > if (TREE_CODE (t) == TEMPLATE_TYPE_PARM) > - { > + if (tree ci = PLACEHOLDER_TYPE_CONSTRAINTS_INFO (t)) > /* Propagate constraints on placeholders since they are > only instantiated during satisfaction. */ > - if (tree ci = PLACEHOLDER_TYPE_CONSTRAINTS_INFO (t)) > - PLACEHOLDER_TYPE_CONSTRAINTS_INFO (r) = ci; > - else if (tree pl = CLASS_PLACEHOLDER_TEMPLATE (t)) > - { > - pl = tsubst_copy (pl, args, complain, in_decl); > - if (TREE_CODE (pl) == TEMPLATE_TEMPLATE_PARM) > - pl = TEMPLATE_TEMPLATE_PARM_TEMPLATE_DECL (pl); > - CLASS_PLACEHOLDER_TEMPLATE (r) = pl; > - } > - } > + PLACEHOLDER_TYPE_CONSTRAINTS_INFO (r) = ci; > > if (TREE_CODE (r) == TEMPLATE_TEMPLATE_PARM) > /* We have reduced the level of the template > @@ -28491,18 +28481,18 @@ make_args_non_dependent (vec *args) > } > > /* Returns a type which represents 'auto' or 'decltype(auto)'. We use a > - TEMPLATE_TYPE_PARM with a level one deeper than the actual template > - parms. If set_canonical is true, we set TYPE_CANONICAL on it. */ > + TEMPLATE_TYPE_PARM with a level one deeper than the actual template parms, > + by default. If set_canonical is true, we set TYPE_CANONICAL on it. */ > > static tree > -make_auto_1 (tree name, bool set_canonical) > +make_auto_1 (tree name, bool set_canonical, > + int level = current_template_depth + 1) > { > tree au = cxx_make_type (TEMPLATE_TYPE_PARM); > TYPE_NAME (au) = build_decl (input_location, TYPE_DECL, name, au); > TYPE_STUB_DECL (au) = TYPE_NAME (au); > TEMPLATE_TYPE_PARM_INDEX (au) = build_template_parm_index > - (0, current_template_depth + 1, current_template_depth + 1, > - TYPE_NAME (au), NULL_TREE); > + (0, level, level, TYPE_NAME (au), NULL_TREE); > if (set_canonical) > TYPE_CANONICAL (au) = canonical_type_parameter (au); > DECL_ARTIFICIAL (TYPE_NAME (au)) = 1; > @@ -28525,12 +28515,14 @@ make_auto (void) > return make_auto_1 (auto_identifier, true); > } > > -/* Return a C++17 deduction placeholder for class template TMPL. */ > +/* Return a C++17 deduction placeholder for class template TMPL. > + There are represented as an 'auto' with the special level 0 and > + CLASS_PLACEHOLDER_TEMPLATE set. */ > > tree > make_template_placeholder (tree tmpl) > { > - tree t = make_auto_1 (auto_identifier, false); > + tree t = make_auto_1 (auto_identifier, false, /*level=*/0); > CLASS_PLACEHOLDER_TEMPLATE (t) = tmpl; > /* Our canonical type depends on the placeholder. */ > TYPE_CANONICAL (t) = canonical_type_parameter (t); > diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction100.C b/gcc/testsuite/g++.dg/cpp1z/class-deduction100.C > new file mode 100644 > index 00000000000..379eb960da6 > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction100.C > @@ -0,0 +1,17 @@ > +// PR c++/91911 > +// { dg-do compile { target c++17 } } > + > +template > +struct span { > + using value_type = T; > + span(T); > +}; > + > +template > +using SpanType = decltype(span{T()}); > + > +template > +using ConstSpanType = span::value_type>; > + > +using type = ConstSpanType; > +using type = span; > diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction100a.C b/gcc/testsuite/g++.dg/cpp1z/class-deduction100a.C > new file mode 100644 > index 00000000000..958ac4f9762 > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction100a.C > @@ -0,0 +1,22 @@ > +// PR c++/91911 > +// { dg-do compile { target c++17 } } > +// A variant of class-deduction100.C where SpanType has more levels than > +// ConstSpanType. > + > +template > +struct span { > + using value_type = T; > + span(T); > +}; > + > +template > +struct A { > + template > + using SpanType = decltype(span{T()}); > +}; > + > +template > +using ConstSpanType = span::SpanType::value_type>; > + > +using type = ConstSpanType; > +using type = span; > diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction100b.C b/gcc/testsuite/g++.dg/cpp1z/class-deduction100b.C > new file mode 100644 > index 00000000000..9b5c684449c > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction100b.C > @@ -0,0 +1,22 @@ > +// PR c++/91911 > +// { dg-do compile { target c++17 } } > +// A variant of class-deduction100.C where SpanType has fewer levels than > +// ConstSpanType. > + > +template > +struct span { > + using value_type = T; > + span(T); > +}; > + > +template > +using SpanType = decltype(span{T()}); > + > +template > +struct B { > + template > + using ConstSpanType = span::value_type>; > +}; > + > +using type = B::ConstSpanType; > +using type = span; > diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction101.C b/gcc/testsuite/g++.dg/cpp1z/class-deduction101.C > new file mode 100644 > index 00000000000..20504780d32 > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction101.C > @@ -0,0 +1,25 @@ > +// PR c++/98077 > +// { dg-do compile { target c++17 } } > + > +template > +struct function { > + template function(T); > + using type = R; > +}; > + > +template function(T) -> function; > + > +template > +struct CallableTrait; > + > +template > +struct CallableTrait> { using ReturnType = R; }; > + > +template > +using CallableTraitT = CallableTrait; > + > +template > +using ReturnType = typename CallableTraitT::ReturnType; > + > +using type = ReturnType; > +using type = int; > diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction101a.C b/gcc/testsuite/g++.dg/cpp1z/class-deduction101a.C > new file mode 100644 > index 00000000000..77b05d23b62 > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction101a.C > @@ -0,0 +1,27 @@ > +// PR c++/98077 > +// { dg-do compile { target c++17 } } > +// A variant of class-deduction101.C where the template placeholder is a template > +// template parameter. > + > +template > +struct function { > + template function(T); > + using type = R; > +}; > + > +template function(T) -> function; > + > +template > +struct CallableTrait; > + > +template > +struct CallableTrait> { using ReturnType = R; }; > + > +template class Tmpl> > +using CallableTraitT = CallableTrait; > + > +template class Tmpl> > +using ReturnType = typename CallableTraitT::ReturnType; > + > +using type = ReturnType; > +using type = int; > diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction101b.C b/gcc/testsuite/g++.dg/cpp1z/class-deduction101b.C > new file mode 100644 > index 00000000000..50df934796d > --- /dev/null > +++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction101b.C > @@ -0,0 +1,30 @@ > +// PR c++/98077 > +// { dg-do compile { target c++17 } } > +// A variant of class-deduction101.C where the template placeholder is a template > +// template parameter and ReturnType has more levels than CallableTraitT. > + > +template > +struct function { > + template function(T); > + using type = R; > +}; > + > +template function(T) -> function; > + > +template > +struct CallableTrait; > + > +template > +struct CallableTrait> { using ReturnType = R; }; > + > +template class Tmpl> > +using CallableTraitT = CallableTrait; > + > +template > +struct A { > + template class Tmpl> > + using ReturnType = typename CallableTraitT::ReturnType; > +}; > + > +using type = A::ReturnType; > +using type = int; > diff --git a/gcc/testsuite/g++.dg/other/pr88187.C b/gcc/testsuite/g++.dg/other/pr88187.C > index 13466d3ce57..c33644d14ca 100644 > --- a/gcc/testsuite/g++.dg/other/pr88187.C > +++ b/gcc/testsuite/g++.dg/other/pr88187.C > @@ -4,4 +4,4 @@ > template struct A; > void f (A ()); // { dg-error "6:variable or field 'f' declared void" "" { target c++14_down } } > // { dg-error "missing template arguments before '\\(' token" "" { target c++14_down } .-1 } > - // { dg-error "placeholder .A. not permitted in this context" "" { target c++17 } .-2 } > + // { dg-error "deduced class type .A. in function return type" "" { target c++17 } .-2 } > -- > 2.34.1.390.g2ae0a9cb82 >