From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wr1-x42a.google.com (mail-wr1-x42a.google.com [IPv6:2a00:1450:4864:20::42a]) by sourceware.org (Postfix) with ESMTPS id B67383858407 for ; Tue, 21 Feb 2023 12:04:06 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org B67383858407 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=embecosm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=embecosm.com Received: by mail-wr1-x42a.google.com with SMTP id l25so3758738wrb.3 for ; Tue, 21 Feb 2023 04:04:06 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=embecosm.com; s=google; h=content-transfer-encoding:mime-version:reply-to:references :in-reply-to:message-id:date:subject:cc:to:from:from:to:cc:subject :date:message-id:reply-to; bh=OKUjLOAKFbXHwJjqjnkbMGlApLgsGgSq0nNCpQ7jW8c=; b=IWY5s0yQeXG42ARJSO7RkHMDVBD8dA/8uK1uSdHDPXs6KgEfxkrwBC0kOQNxdnuAFq SsRvk8bNqJemx4x/ghqXuNSumvvYHCCEsHROA1ajPynhm67cxxSGX/jpxG987sq+79uN PeWGX88HXLbP7LQRlTPWjjfIPxkOSBNrZy8QVF/XiMsRbuo7rhZUe/QtTjjA9mwnYc/U 0OFofdxbjkRYRArhuX+NMa+Lf6y06GID+zq9/nsgg8kI96y0BtxUiTc15olAcORZSrHV 8Mqm+OseDypbXXH3flXnNOHW7zCFyL4lfdsBILurv52gA2Axsi51dz5Q/AR2ZX9vL3Fj /f+g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:mime-version:reply-to: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=OKUjLOAKFbXHwJjqjnkbMGlApLgsGgSq0nNCpQ7jW8c=; b=6nqAfjOlSg7Dj4Lc0k49JOy+4WPkufa1KYy4XUvHpgx9s5xChibOWXqMRsxAgskXxk Cq8nZ0mNx7Rswx5Jo2jj9XvSeeJux2/HemM5BZXKxtMRheh4sFAkJS6OUu0Hy9R4Gjfp bEJqfNBPHCJwQCeIN5L0Ll0GY8rvxYwPMrinfCxFov3OSYUDlT2YoqSnUnNXRFKkQMT9 yzbUtjuMg0r3qcH2aMl+M9Nt/CynyL65hnE8IhheN288btOoKGG8B1klFkHvA1gp1n9L ODdeOuQfz6OKpjj2L0hMrubFBYpCGKnxf4m5ByGx0cfUuZvDr3XK7UoHsjQuggopfLBp 0fGg== X-Gm-Message-State: AO0yUKXeL39/Yxek6iamv/HnvlBgD5vcy/T3pCPn4puGzdc2VUcvsnvU RTP2QPYYfZoM6JWc4MlG9MGsC1J+VEF11hZu/A== X-Google-Smtp-Source: AK7set9iuMIPDuNk19dk7w24e7kAVi08P03lCHhxuj8khYCPJDmGbNhecRizVg8+UEfj0xrOrstdcA== X-Received: by 2002:adf:f450:0:b0:2bf:f4f7:be9c with SMTP id f16-20020adff450000000b002bff4f7be9cmr2329183wrp.14.1676981045511; Tue, 21 Feb 2023 04:04:05 -0800 (PST) Received: from platypus.localdomain ([62.23.166.218]) by smtp.gmail.com with ESMTPSA id c15-20020adffb4f000000b002c55b0e6ef1sm5013811wrs.4.2023.02.21.04.04.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 21 Feb 2023 04:04:04 -0800 (PST) From: arthur.cohen@embecosm.com To: gcc-patches@gcc.gnu.org Cc: gcc-rust@gcc.gnu.org, Philip Herron Subject: [committed 052/103] gccrs: Add missing hir lowering to function type-path segments Date: Tue, 21 Feb 2023 13:01:42 +0100 Message-Id: <20230221120230.596966-53-arthur.cohen@embecosm.com> X-Mailer: git-send-email 2.39.1 In-Reply-To: <20230221120230.596966-1-arthur.cohen@embecosm.com> References: <20230221120230.596966-1-arthur.cohen@embecosm.com> Reply-To: arthur.cohen@embecosm.com MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spam-Status: No, score=-14.3 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,KAM_SHORT,RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,TXREP autolearn=unavailable autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: From: Philip Herron gcc/rust/ChangeLog: * Make-lang.in: Compile rust-ast-lower-type.cc. * ast/rust-path.h: Add `get_locus` method to `TypePathFunction`. * hir/rust-ast-lower-base.cc (ASTLowerTypePath::visit): Move implementation to rust-ast-lower-type.cc. (ASTLowerQualifiedPathInType::visit): Likewise. (ASTLoweringType::visit): Likewise. * hir/rust-ast-lower-type.h: Move implementations to source file. * hir/tree/rust-hir-path.h: Likewise. * hir/rust-ast-lower-type.cc: New file. --- gcc/rust/Make-lang.in | 1 + gcc/rust/ast/rust-path.h | 2 + gcc/rust/hir/rust-ast-lower-base.cc | 113 -------------- gcc/rust/hir/rust-ast-lower-type.cc | 232 ++++++++++++++++++++++++++++ gcc/rust/hir/rust-ast-lower-type.h | 63 +------- gcc/rust/hir/tree/rust-hir-path.h | 68 ++++---- 6 files changed, 269 insertions(+), 210 deletions(-) create mode 100644 gcc/rust/hir/rust-ast-lower-type.cc diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in index 2f4f409f54f..dddc70a26ec 100644 --- a/gcc/rust/Make-lang.in +++ b/gcc/rust/Make-lang.in @@ -95,6 +95,7 @@ GRS_OBJS = \ rust/rust-ast-lower-pattern.o \ rust/rust-ast-lower-item.o \ rust/rust-ast-lower-expr.o \ + rust/rust-ast-lower-type.o \ rust/rust-early-name-resolver.o \ rust/rust-name-resolver.o \ rust/rust-ast-resolve.o \ diff --git a/gcc/rust/ast/rust-path.h b/gcc/rust/ast/rust-path.h index 9683ad6ad68..b5c9c3aab3a 100644 --- a/gcc/rust/ast/rust-path.h +++ b/gcc/rust/ast/rust-path.h @@ -898,6 +898,8 @@ public: rust_assert (has_return_type ()); return return_type; } + + Location get_locus () const { return locus; } }; // Segment used in type path with a function argument diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc index 098014ff92b..f5402efe066 100644 --- a/gcc/rust/hir/rust-ast-lower-base.cc +++ b/gcc/rust/hir/rust-ast-lower-base.cc @@ -658,119 +658,6 @@ ASTLoweringBase::lower_self (AST::SelfParam &self) self.get_locus ()); } -void -ASTLowerTypePath::visit (AST::TypePathSegmentGeneric &segment) -{ - std::vector binding_args; // TODO - - std::string segment_name = segment.get_ident_segment ().as_string (); - bool has_separating_scope_resolution - = segment.get_separating_scope_resolution (); - - auto generic_args = lower_generic_args (segment.get_generic_args ()); - - auto crate_num = mappings->get_current_crate (); - auto hirid = mappings->get_next_hir_id (crate_num); - Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid, - UNKNOWN_LOCAL_DEFID); - - translated_segment - = new HIR::TypePathSegmentGeneric (std::move (mapping), segment_name, - has_separating_scope_resolution, - generic_args, segment.get_locus ()); -} - -void -ASTLowerQualifiedPathInType::visit (AST::QualifiedPathInType &path) -{ - auto crate_num = mappings->get_current_crate (); - auto hirid = mappings->get_next_hir_id (crate_num); - Analysis::NodeMapping qual_mappings ( - crate_num, path.get_qualified_path_type ().get_node_id (), hirid, - UNKNOWN_LOCAL_DEFID); - - HIR::Type *qual_type = ASTLoweringType::translate ( - path.get_qualified_path_type ().get_type ().get ()); - HIR::TypePath *qual_trait = ASTLowerTypePath::translate ( - path.get_qualified_path_type ().get_as_type_path ()); - - HIR::QualifiedPathType qual_path_type ( - qual_mappings, std::unique_ptr (qual_type), - std::unique_ptr (qual_trait), - path.get_qualified_path_type ().get_locus ()); - - translated_segment = nullptr; - path.get_associated_segment ()->accept_vis (*this); - if (translated_segment == nullptr) - { - rust_fatal_error (path.get_associated_segment ()->get_locus (), - "failed to translate AST TypePathSegment"); - return; - } - std::unique_ptr associated_segment (translated_segment); - - std::vector> translated_segments; - for (auto &seg : path.get_segments ()) - { - translated_segment = nullptr; - seg->accept_vis (*this); - if (translated_segment == nullptr) - { - rust_fatal_error (seg->get_locus (), - "failed to translte AST TypePathSegment"); - } - translated_segments.push_back ( - std::unique_ptr (translated_segment)); - } - - Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid, - mappings->get_next_localdef_id (crate_num)); - translated = new HIR::QualifiedPathInType (std::move (mapping), - std::move (qual_path_type), - std::move (associated_segment), - std::move (translated_segments), - path.get_locus ()); -} - -void -ASTLoweringType::visit (AST::TraitObjectTypeOneBound &type) -{ - std::vector> bounds; - HIR::TypeParamBound *translated_bound - = ASTLoweringTypeBounds::translate (&type.get_trait_bound ()); - bounds.push_back (std::unique_ptr (translated_bound)); - - auto crate_num = mappings->get_current_crate (); - Analysis::NodeMapping mapping (crate_num, type.get_node_id (), - mappings->get_next_hir_id (crate_num), - mappings->get_next_localdef_id (crate_num)); - - translated = new HIR::TraitObjectType (mapping, std::move (bounds), - type.get_locus (), type.is_dyn ()); -} - -void -ASTLoweringType::visit (AST::TraitObjectType &type) -{ - std::vector> bounds; - - for (auto &bound : type.get_type_param_bounds ()) - { - HIR::TypeParamBound *translated_bound - = ASTLoweringTypeBounds::translate (bound.get ()); - bounds.push_back ( - std::unique_ptr (translated_bound)); - } - - auto crate_num = mappings->get_current_crate (); - Analysis::NodeMapping mapping (crate_num, type.get_node_id (), - mappings->get_next_hir_id (crate_num), - mappings->get_next_localdef_id (crate_num)); - - translated = new HIR::TraitObjectType (mapping, std::move (bounds), - type.get_locus (), type.is_dyn ()); -} - HIR::Type * ASTLoweringBase::lower_type_no_bounds (AST::TypeNoBounds *type) { diff --git a/gcc/rust/hir/rust-ast-lower-type.cc b/gcc/rust/hir/rust-ast-lower-type.cc new file mode 100644 index 00000000000..92a14f4dacf --- /dev/null +++ b/gcc/rust/hir/rust-ast-lower-type.cc @@ -0,0 +1,232 @@ +// Copyright (C) 2020-2022 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 +// . + +#include "rust-ast-lower-type.h" + +namespace Rust { +namespace HIR { + +HIR::TypePath * +ASTLowerTypePath::translate (AST::TypePath &type) +{ + ASTLowerTypePath resolver; + type.accept_vis (resolver); + rust_assert (resolver.translated != nullptr); + return resolver.translated; +} + +void +ASTLowerTypePath::visit (AST::TypePathSegmentFunction &segment) +{ + auto crate_num = mappings->get_current_crate (); + auto hirid = mappings->get_next_hir_id (crate_num); + Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid, + UNKNOWN_LOCAL_DEFID); + + HIR::PathIdentSegment ident (segment.get_ident_segment ().as_string ()); + + AST::TypePathFunction &fn = segment.get_type_path_function (); + std::vector> inputs; + for (auto ¶m : fn.get_params ()) + { + HIR::Type *hir_type = ASTLoweringType::translate (param.get ()); + inputs.push_back (std::unique_ptr (hir_type)); + } + + HIR::Type *result_type + = fn.has_return_type () + ? ASTLoweringType::translate (fn.get_return_type ().get ()) + : nullptr; + + HIR::TypePathFunction function_path (std::move (inputs), + std::unique_ptr ( + result_type)); + + translated_segment = new HIR::TypePathSegmentFunction ( + mapping, std::move (ident), segment.get_separating_scope_resolution (), + std::move (function_path), segment.get_locus ()); +} + +void +ASTLowerTypePath::visit (AST::TypePathSegment &segment) +{ + auto crate_num = mappings->get_current_crate (); + auto hirid = mappings->get_next_hir_id (crate_num); + Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid, + UNKNOWN_LOCAL_DEFID); + + HIR::PathIdentSegment ident (segment.get_ident_segment ().as_string ()); + translated_segment + = new HIR::TypePathSegment (std::move (mapping), ident, + segment.get_separating_scope_resolution (), + segment.get_locus ()); +} + +void +ASTLowerTypePath::visit (AST::TypePathSegmentGeneric &segment) +{ + std::vector binding_args; // TODO + + std::string segment_name = segment.get_ident_segment ().as_string (); + bool has_separating_scope_resolution + = segment.get_separating_scope_resolution (); + + auto generic_args = lower_generic_args (segment.get_generic_args ()); + + auto crate_num = mappings->get_current_crate (); + auto hirid = mappings->get_next_hir_id (crate_num); + Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid, + UNKNOWN_LOCAL_DEFID); + + translated_segment + = new HIR::TypePathSegmentGeneric (std::move (mapping), segment_name, + has_separating_scope_resolution, + generic_args, segment.get_locus ()); +} + +void +ASTLowerTypePath::visit (AST::TypePath &path) +{ + std::vector> translated_segments; + + for (auto &seg : path.get_segments ()) + { + translated_segment = nullptr; + seg->accept_vis (*this); + if (translated_segment == nullptr) + { + rust_fatal_error (seg->get_locus (), + "failed to translate AST TypePathSegment"); + } + translated_segments.push_back ( + std::unique_ptr (translated_segment)); + } + + auto crate_num = mappings->get_current_crate (); + auto hirid = mappings->get_next_hir_id (crate_num); + Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid, + mappings->get_next_localdef_id (crate_num)); + + translated + = new HIR::TypePath (std::move (mapping), std::move (translated_segments), + path.get_locus (), + path.has_opening_scope_resolution_op ()); +} + +HIR::QualifiedPathInType * +ASTLowerQualifiedPathInType::translate (AST::QualifiedPathInType &type) +{ + ASTLowerQualifiedPathInType resolver; + type.accept_vis (resolver); + rust_assert (resolver.translated != nullptr); + return resolver.translated; +} + +void +ASTLowerQualifiedPathInType::visit (AST::QualifiedPathInType &path) +{ + auto crate_num = mappings->get_current_crate (); + auto hirid = mappings->get_next_hir_id (crate_num); + Analysis::NodeMapping qual_mappings ( + crate_num, path.get_qualified_path_type ().get_node_id (), hirid, + UNKNOWN_LOCAL_DEFID); + + HIR::Type *qual_type = ASTLoweringType::translate ( + path.get_qualified_path_type ().get_type ().get ()); + HIR::TypePath *qual_trait = ASTLowerTypePath::translate ( + path.get_qualified_path_type ().get_as_type_path ()); + + HIR::QualifiedPathType qual_path_type ( + qual_mappings, std::unique_ptr (qual_type), + std::unique_ptr (qual_trait), + path.get_qualified_path_type ().get_locus ()); + + translated_segment = nullptr; + path.get_associated_segment ()->accept_vis (*this); + if (translated_segment == nullptr) + { + rust_fatal_error (path.get_associated_segment ()->get_locus (), + "failed to translate AST TypePathSegment"); + return; + } + std::unique_ptr associated_segment (translated_segment); + + std::vector> translated_segments; + for (auto &seg : path.get_segments ()) + { + translated_segment = nullptr; + seg->accept_vis (*this); + if (translated_segment == nullptr) + { + rust_fatal_error (seg->get_locus (), + "failed to translte AST TypePathSegment"); + } + translated_segments.push_back ( + std::unique_ptr (translated_segment)); + } + + Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid, + mappings->get_next_localdef_id (crate_num)); + translated = new HIR::QualifiedPathInType (std::move (mapping), + std::move (qual_path_type), + std::move (associated_segment), + std::move (translated_segments), + path.get_locus ()); +} + +void +ASTLoweringType::visit (AST::TraitObjectTypeOneBound &type) +{ + std::vector> bounds; + HIR::TypeParamBound *translated_bound + = ASTLoweringTypeBounds::translate (&type.get_trait_bound ()); + bounds.push_back (std::unique_ptr (translated_bound)); + + auto crate_num = mappings->get_current_crate (); + Analysis::NodeMapping mapping (crate_num, type.get_node_id (), + mappings->get_next_hir_id (crate_num), + mappings->get_next_localdef_id (crate_num)); + + translated = new HIR::TraitObjectType (mapping, std::move (bounds), + type.get_locus (), type.is_dyn ()); +} + +void +ASTLoweringType::visit (AST::TraitObjectType &type) +{ + std::vector> bounds; + + for (auto &bound : type.get_type_param_bounds ()) + { + HIR::TypeParamBound *translated_bound + = ASTLoweringTypeBounds::translate (bound.get ()); + bounds.push_back ( + std::unique_ptr (translated_bound)); + } + + auto crate_num = mappings->get_current_crate (); + Analysis::NodeMapping mapping (crate_num, type.get_node_id (), + mappings->get_next_hir_id (crate_num), + mappings->get_next_localdef_id (crate_num)); + + translated = new HIR::TraitObjectType (mapping, std::move (bounds), + type.get_locus (), type.is_dyn ()); +} + +} // namespace HIR +} // namespace Rust diff --git a/gcc/rust/hir/rust-ast-lower-type.h b/gcc/rust/hir/rust-ast-lower-type.h index 56442110e07..a0761023ce8 100644 --- a/gcc/rust/hir/rust-ast-lower-type.h +++ b/gcc/rust/hir/rust-ast-lower-type.h @@ -32,59 +32,12 @@ protected: using Rust::HIR::ASTLoweringBase::visit; public: - static HIR::TypePath *translate (AST::TypePath &type) - { - ASTLowerTypePath resolver; - type.accept_vis (resolver); - rust_assert (resolver.translated != nullptr); - return resolver.translated; - } - - void visit (AST::TypePathSegmentFunction &) override { gcc_unreachable (); } - - void visit (AST::TypePathSegment &segment) override - { - auto crate_num = mappings->get_current_crate (); - auto hirid = mappings->get_next_hir_id (crate_num); - Analysis::NodeMapping mapping (crate_num, segment.get_node_id (), hirid, - UNKNOWN_LOCAL_DEFID); - - HIR::PathIdentSegment ident (segment.get_ident_segment ().as_string ()); - translated_segment - = new HIR::TypePathSegment (std::move (mapping), ident, - segment.get_separating_scope_resolution (), - segment.get_locus ()); - } + static HIR::TypePath *translate (AST::TypePath &type); + void visit (AST::TypePathSegmentFunction &segment) override; + void visit (AST::TypePathSegment &segment) override; void visit (AST::TypePathSegmentGeneric &segment) override; - - void visit (AST::TypePath &path) override - { - std::vector> translated_segments; - - for (auto &seg : path.get_segments ()) - { - translated_segment = nullptr; - seg->accept_vis (*this); - if (translated_segment == nullptr) - { - rust_fatal_error (seg->get_locus (), - "failed to translate AST TypePathSegment"); - } - translated_segments.push_back ( - std::unique_ptr (translated_segment)); - } - - auto crate_num = mappings->get_current_crate (); - auto hirid = mappings->get_next_hir_id (crate_num); - Analysis::NodeMapping mapping (crate_num, path.get_node_id (), hirid, - mappings->get_next_localdef_id (crate_num)); - - translated - = new HIR::TypePath (std::move (mapping), std::move (translated_segments), - path.get_locus (), - path.has_opening_scope_resolution_op ()); - } + void visit (AST::TypePath &path) override; protected: HIR::TypePathSegment *translated_segment; @@ -98,13 +51,7 @@ class ASTLowerQualifiedPathInType : public ASTLowerTypePath using ASTLowerTypePath::visit; public: - static HIR::QualifiedPathInType *translate (AST::QualifiedPathInType &type) - { - ASTLowerQualifiedPathInType resolver; - type.accept_vis (resolver); - rust_assert (resolver.translated != nullptr); - return resolver.translated; - } + static HIR::QualifiedPathInType *translate (AST::QualifiedPathInType &type); void visit (AST::QualifiedPathInType &path) override; diff --git a/gcc/rust/hir/tree/rust-hir-path.h b/gcc/rust/hir/tree/rust-hir-path.h index 64df6f7fd02..fa8347b2cf8 100644 --- a/gcc/rust/hir/tree/rust-hir-path.h +++ b/gcc/rust/hir/tree/rust-hir-path.h @@ -529,24 +529,9 @@ protected: struct TypePathFunction { private: - // TODO: remove - /*bool has_inputs; - TypePathFnInputs inputs;*/ - // inlined from TypePathFnInputs std::vector > inputs; - - // bool has_type; std::unique_ptr return_type; - // FIXME: think of better way to mark as invalid than taking up storage - bool is_invalid; - - // TODO: should this have location info? - -protected: - // Constructor only used to create invalid type path functions. - TypePathFunction (bool is_invalid) : is_invalid (is_invalid) {} - public: // Returns whether the return type of the function has been specified. bool has_return_type () const { return return_type != nullptr; } @@ -554,31 +539,19 @@ public: // Returns whether the function has inputs. bool has_inputs () const { return !inputs.empty (); } - // Returns whether function is in an error state. - bool is_error () const { return is_invalid; } - - // Creates an error state function. - static TypePathFunction create_error () { return TypePathFunction (true); } - - // Constructor - TypePathFunction (std::vector > inputs, - Type *type = nullptr) - : inputs (std::move (inputs)), return_type (type), is_invalid (false) - {} - // FIXME: deprecated - // Constructor TypePathFunction (std::vector > inputs, - std::unique_ptr type = nullptr) - : inputs (std::move (inputs)), return_type (std::move (type)), - is_invalid (false) + std::unique_ptr type) + : inputs (std::move (inputs)), return_type (std::move (type)) {} // Copy constructor with clone TypePathFunction (TypePathFunction const &other) - : return_type (other.return_type->clone_type ()), - is_invalid (other.is_invalid) { + return_type = other.has_return_type () + ? other.get_return_type ()->clone_type () + : nullptr; + inputs.reserve (other.inputs.size ()); for (const auto &e : other.inputs) inputs.push_back (e->clone_type ()); @@ -589,8 +562,9 @@ public: // Overloaded assignment operator to clone type TypePathFunction &operator= (TypePathFunction const &other) { - return_type = other.return_type->clone_type (); - is_invalid = other.is_invalid; + return_type = other.has_return_type () + ? other.get_return_type ()->clone_type () + : nullptr; inputs.reserve (other.inputs.size ()); for (const auto &e : other.inputs) @@ -604,6 +578,23 @@ public: TypePathFunction &operator= (TypePathFunction &&other) = default; std::string as_string () const; + + const std::vector > &get_params () const + { + return inputs; + }; + std::vector > &get_params () { return inputs; }; + + const std::unique_ptr &get_return_type () const + { + rust_assert (has_return_type ()); + return return_type; + }; + std::unique_ptr &get_return_type () + { + rust_assert (has_return_type ()); + return return_type; + }; }; // Segment used in type path with a function argument @@ -638,10 +629,9 @@ public: void accept_vis (HIRFullVisitor &vis) override; - virtual SegmentType get_type () const override final - { - return SegmentType::FUNCTION; - } + SegmentType get_type () const override final { return SegmentType::FUNCTION; } + + TypePathFunction &get_function_path () { return function_path; } protected: // Use covariance to override base class method -- 2.39.1