From patchwork Thu Aug 1 14:57:55 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Arthur Cohen X-Patchwork-Id: 1967870 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=embecosm.com header.i=@embecosm.com header.a=rsa-sha256 header.s=google header.b=NfqS3RNr; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4WZYD21zfqz1ybV for ; Fri, 2 Aug 2024 01:44:02 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 7221D3860769 for ; Thu, 1 Aug 2024 15:44:00 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-ed1-x536.google.com (mail-ed1-x536.google.com [IPv6:2a00:1450:4864:20::536]) by sourceware.org (Postfix) with ESMTPS id E212F3861826 for ; Thu, 1 Aug 2024 15:00:54 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org E212F3861826 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=embecosm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=embecosm.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org E212F3861826 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::536 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1722524500; cv=none; b=nwUYGVW2/2qL3C1N4UvA6K8VIHERd/OPiQiK5W0/nURFHbjMb3zJbkFk9tYVytWoC4Z/6p46xJWfWMZOuNlgGLf2Rnl4qrJWW+fxzUtWqmqlnLWIWEpBlsaDwPs7exE3GAUHDXL8d3ABx7JhrNUc2w9nHRA8vriVQQEebFfgVZE= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1722524500; c=relaxed/simple; bh=EtolwvNGgojHY2KC1098yXx+sxaggKPFwnn+9fzOBOg=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=wNHI6xZpOw3fHlJTpPI0Egm6zAcTYlcK55K6fu4O1SmEJO8Kqbr56Bt2YtQUybCCiLoayjyNo7Hf4ckBBQfn0o/Oby6vJ90PJeAtl80sDhVj5I2tymrpP+/KuImzdEvRVtPmJT3MztIV9m2u+1KdJ+PSYDR5CJ7KqJUfEek3w9k= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-ed1-x536.google.com with SMTP id 4fb4d7f45d1cf-5a167b9df7eso11120389a12.3 for ; Thu, 01 Aug 2024 08:00:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=embecosm.com; s=google; t=1722524453; x=1723129253; darn=gcc.gnu.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=6F2FVvo1fbwFM2+jY/5i53HbouAfxu/GQagnXcJM3ZM=; b=NfqS3RNrJxUp+CFo8qBQtaJydzSlgvvWklmEm87WmqHp5QVv/wbCviZ0lT9gtm5jcU fkFw9IchhDdY24j8s+zMLlEzZW1bq/fSmI+R5dGmb6a2KWEuowHsnFFxfGP63ZBF8fH+ YQRDdziMpglnYUsQHQvvDuzH0QmuNHdPpVjxh2EdO/t080Gj7WoHc4JmUtbgXlawNUAV 4QwkG7uLCdZufMnt4nIfLPJmwrC752QvWc1eLqV1qNpqNEA1+CtvWyO3mSGjRYUTNPQv XsdJVqUVU8PYocg3Iopc1nKb6sxZGhfHQGLGVI3rzuNt9YTFYTT2ven2lHVmILC4oKTa qeIQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1722524453; x=1723129253; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=6F2FVvo1fbwFM2+jY/5i53HbouAfxu/GQagnXcJM3ZM=; b=FAzJK7kIqySIAj9K07tCwd+gbGG3kaSZQgicwRzxEh21KtKcfBGbLbkVV16SjEgu8W zi6b66l4EmcVu3FDXEMxsHnsA82aoOAAlW5zuXFrKDTU6wPJiiGz+SlBZ5Cn47Bk1ljY MmI8eZqBNnzixa/9ZaN5qPmd2ddo6ccHNWXbOn0Byx8t7W5OHFTC7yl6cTAn+kCg/kx5 Q+zWXgFWSp6VziM/OX/iH/1hPii0hjYZbIfD6D8VdPt/uX2HWifVhY7lMyVHiA/2qeZT 1nb3gLLC2ktVnaBWDSLp+mNPFUPsvD9jVuez9kup9EUA7VyURMy5MzVr/mnC3P3/zfSi fdjg== X-Gm-Message-State: AOJu0YxusjH5wl1nAaf/FDMfGuefCvmzsrdP4vpQeolOfKaFjohCWm/O MARIXIb86C+7eiatZ/vdgLwmoR8YNAir1cK3Ugi5wshlD5M4JMUb12InUkFV+dEncdRpu+2put1 HnTa1 X-Google-Smtp-Source: AGHT+IFkNs2bamumhUhRhlClwtzpSn2ZGtgAuAQYlcDv8x4qMS8O86EqNf7MY9QaAjwqXNf0MidwDA== X-Received: by 2002:a05:6402:1ac4:b0:5a0:f39a:b371 with SMTP id 4fb4d7f45d1cf-5b7f3cc60cfmr432700a12.10.1722524453019; Thu, 01 Aug 2024 08:00:53 -0700 (PDT) Received: from platypus.lan ([2a04:cec2:9:dc84:3622:6733:ff49:ee91]) by smtp.gmail.com with ESMTPSA id 4fb4d7f45d1cf-5ac63590592sm10252456a12.25.2024.08.01.08.00.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 01 Aug 2024 08:00:52 -0700 (PDT) From: Arthur Cohen To: gcc-patches@gcc.gnu.org Cc: gcc-rust@gcc.gnu.org, Jakub Dupak Subject: [PATCH 119/125] gccrs: borrowck: extract regions from types using VA Date: Thu, 1 Aug 2024 16:57:55 +0200 Message-ID: <20240801145809.366388-121-arthur.cohen@embecosm.com> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240801145809.366388-2-arthur.cohen@embecosm.com> References: <20240801145809.366388-2-arthur.cohen@embecosm.com> MIME-Version: 1.0 X-Spam-Status: No, score=-14.1 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, 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 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: , Errors-To: gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org From: Jakub Dupak Biggybag on variance analysis to extract regions of fields from ADT regions. gcc/rust/ChangeLog: * typecheck/rust-tyty-variance-analysis-private.h (class FieldVisitorCtx): Region extraction. * typecheck/rust-tyty-variance-analysis.cc (query_field_regions): Region extraction. (FieldVisitorCtx::collect_regions): Region extraction. (FieldVisitorCtx::add_constraints_from_ty): Region extraction. (FieldVisitorCtx::add_constraints_from_region): Region extraction. (FieldVisitorCtx::add_constrints_from_param): Region extraction. * typecheck/rust-tyty-variance-analysis.h (query_field_regions): Region extraction. Signed-off-by: Jakub Dupak --- .../rust-tyty-variance-analysis-private.h | 41 +++++++++ .../typecheck/rust-tyty-variance-analysis.cc | 87 ++++++++++++++++++- .../typecheck/rust-tyty-variance-analysis.h | 31 +++---- 3 files changed, 140 insertions(+), 19 deletions(-) diff --git a/gcc/rust/typecheck/rust-tyty-variance-analysis-private.h b/gcc/rust/typecheck/rust-tyty-variance-analysis-private.h index ab8c039238e..41a0d6f582f 100644 --- a/gcc/rust/typecheck/rust-tyty-variance-analysis-private.h +++ b/gcc/rust/typecheck/rust-tyty-variance-analysis-private.h @@ -201,6 +201,13 @@ public: // Module internal API std::vector query_generic_variance (const ADTType &type); + std::vector query_field_regions (const ADTType *parent, + size_t variant_index, + size_t field_index, + const FreeRegions &parent_regions); + + std::vector query_type_regions (BaseType *base); + public: // Data used by visitors. // This whole class is private, therfore members can be public. @@ -296,6 +303,40 @@ private: std::vector regions; }; +/** Extracts regions of a field from regions of parent ADT. */ +class FieldVisitorCtx : public VarianceVisitorCtx +{ +public: + using Visitor = VisitorBase; + + std::vector collect_regions (BaseType &ty); + + FieldVisitorCtx (GenericTyPerCrateCtx &ctx, const SubstitutionRef &subst, + const FreeRegions &parent_regions) + : ctx (ctx), subst (subst), parent_regions (parent_regions) + {} + + void add_constraints_from_ty (BaseType *ty, Variance variance) override; + void add_constraints_from_region (const Region ®ion, + Variance variance) override; + void add_constraints_from_generic_args (HirId ref, SubstitutionRef &subst, + Variance variance, + bool invariant_args) override{}; + void add_constrints_from_param (ParamType ¶m, Variance variance) override; + + Variance contra (Variance variance) override + { + return Variance::transform (variance, Variance::contravariant ()); + } + +private: + GenericTyPerCrateCtx &ctx; + const SubstitutionRef &subst; + std::vector regions; + FreeRegions parent_regions; + std::vector type_param_ranges; +}; + } // namespace VarianceAnalysis } // namespace TyTy diff --git a/gcc/rust/typecheck/rust-tyty-variance-analysis.cc b/gcc/rust/typecheck/rust-tyty-variance-analysis.cc index 5a21d69651b..d7116f5eb80 100644 --- a/gcc/rust/typecheck/rust-tyty-variance-analysis.cc +++ b/gcc/rust/typecheck/rust-tyty-variance-analysis.cc @@ -49,8 +49,16 @@ CrateCtx::query_type_variances (BaseType *type) std::vector CrateCtx::query_type_regions (BaseType *type) { - TyVisitorCtx ctx (*private_ctx); - return ctx.collect_regions (*type); + return private_ctx->query_type_regions (type); +} + +std::vector +CrateCtx::query_field_regions (const ADTType *parent, size_t variant_index, + size_t field_index, + const FreeRegions &parent_regions) +{ + return private_ctx->query_field_regions (parent, variant_index, field_index, + parent_regions); } Variance @@ -324,6 +332,29 @@ GenericTyPerCrateCtx::query_generic_variance (const ADTType &type) return result; } +std::vector +GenericTyPerCrateCtx::query_field_regions (const ADTType *parent, + size_t variant_index, + size_t field_index, + const FreeRegions &parent_regions) +{ + auto orig = lookup_type (parent->get_orig_ref ()); + FieldVisitorCtx ctx (*this, *parent->as (), + parent_regions); + return ctx.collect_regions (*orig->as () + ->get_variants () + .at (variant_index) + ->get_fields () + .at (field_index) + ->get_field_type ()); +} +std::vector +GenericTyPerCrateCtx::query_type_regions (BaseType *type) +{ + TyVisitorCtx ctx (*this); + return ctx.collect_regions (*type); +} + SolutionIndex GenericTyVisitorCtx::lookup_or_add_type (HirId hir_id) { @@ -506,6 +537,58 @@ TyVisitorCtx::add_constraints_from_generic_args (HirId ref, } } +std::vector +FieldVisitorCtx::collect_regions (BaseType &ty) +{ + // Segment the regions into ranges for each type parameter. Type parameter + // at index i contains regions from type_param_ranges[i] to + // type_param_ranges[i+1] (exclusive).; + type_param_ranges.push_back (subst.get_num_lifetime_params ()); + + for (size_t i = 0; i < subst.get_num_type_params (); i++) + { + auto arg = subst.get_arg_at (i); + rust_assert (arg.has_value ()); + type_param_ranges.push_back ( + ctx.query_type_regions (arg.value ().get_tyty ()).size ()); + } + + add_constraints_from_ty (&ty, Variance::covariant ()); + return regions; +} + +void +FieldVisitorCtx::add_constraints_from_ty (BaseType *ty, Variance variance) +{ + Visitor visitor (*this, variance); + ty->accept_vis (visitor); +} + +void +FieldVisitorCtx::add_constraints_from_region (const Region ®ion, + Variance variance) +{ + if (region.is_early_bound ()) + { + regions.push_back (parent_regions[region.get_index ()]); + } + else if (region.is_late_bound ()) + { + rust_debug ("Ignoring late bound region"); + } +} + +void +FieldVisitorCtx::add_constrints_from_param (ParamType ¶m, Variance variance) +{ + size_t param_i = subst.get_used_arguments ().find_symbol (param).value (); + for (size_t i = type_param_ranges[param_i]; + i < type_param_ranges[param_i + 1]; i++) + { + regions.push_back (parent_regions[i]); + } +} + Variance TyVisitorCtx::contra (Variance variance) { diff --git a/gcc/rust/typecheck/rust-tyty-variance-analysis.h b/gcc/rust/typecheck/rust-tyty-variance-analysis.h index a1defd62e54..27e8d8b3ea0 100644 --- a/gcc/rust/typecheck/rust-tyty-variance-analysis.h +++ b/gcc/rust/typecheck/rust-tyty-variance-analysis.h @@ -3,6 +3,8 @@ #include "rust-tyty.h" +#include + namespace Rust { namespace TyTy { namespace VarianceAnalysis { @@ -31,11 +33,19 @@ public: /** Get regions mentioned in a type. */ std::vector query_type_regions (BaseType *type); + std::vector query_field_regions (const ADTType *parent, + size_t variant_index, + size_t field_index, + const FreeRegions &parent_regions); private: std::unique_ptr private_ctx; }; +std::vector +query_field_regions (const ADTType *parent, size_t variant_index, + size_t field_index, const FreeRegions &parent_regions); + /** Variance semilattice */ class Variance { @@ -55,22 +65,10 @@ class Variance public: constexpr Variance () : kind (TOP) {} - WARN_UNUSED_RESULT constexpr bool is_bivariant () const - { - return kind == BIVARIANT; - } - WARN_UNUSED_RESULT constexpr bool is_covariant () const - { - return kind == COVARIANT; - } - WARN_UNUSED_RESULT constexpr bool is_contravariant () const - { - return kind == CONTRAVARIANT; - } - WARN_UNUSED_RESULT constexpr bool is_invariant () const - { - return kind == INVARIANT; - } + constexpr bool is_bivariant () const { return kind == BIVARIANT; } + constexpr bool is_covariant () const { return kind == COVARIANT; } + constexpr bool is_contravariant () const { return kind == CONTRAVARIANT; } + constexpr bool is_invariant () const { return kind == INVARIANT; } static constexpr Variance bivariant () { return {BIVARIANT}; } static constexpr Variance covariant () { return {COVARIANT}; } @@ -97,7 +95,6 @@ public: { return lhs.kind == rhs.kind; } - constexpr friend bool operator!= (const Variance &lhs, const Variance &rhs) { return !(lhs == rhs);