From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1643) id C47973858292; Sat, 22 Oct 2022 10:48:26 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org C47973858292 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1666435706; bh=U6KCuOP2M1mMLO5IatAHxGLSZ92rFJZiFBE9XV+PJhw=; h=From:To:Subject:Date:From; b=Ln2vguPweq6wVo3nhXVTaLt+Di3uWaF6XmF/ndO/a9TrtxwyLX0EIQ7fBu0KjkLIC 84tSxUVLRVBVv3x9tF2KRSovJhB8aOCcCmYDZPp7+yRyYSwayBQCL+CWrM99/2RRC0 Jr5He/38zhGL/a7A14otUefr6GZylCjsMlT4mmQo= Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Thomas Schwinge To: gcc-cvs@gcc.gnu.org Subject: [gcc/devel/rust/master] Add missing hir lowering to function type-path segments X-Act-Checkin: gcc X-Git-Author: Philip Herron X-Git-Refname: refs/heads/devel/rust/master X-Git-Oldrev: 8e09dfb538db9af6eb312ecd0a5a4e5931db201e X-Git-Newrev: d396692534019f1e80b821c9e483164f302679bf Message-Id: <20221022104826.C47973858292@sourceware.org> Date: Sat, 22 Oct 2022 10:48:26 +0000 (GMT) List-Id: https://gcc.gnu.org/g:d396692534019f1e80b821c9e483164f302679bf commit d396692534019f1e80b821c9e483164f302679bf Author: Philip Herron Date: Thu Oct 20 17:59:27 2022 +0100 Add missing hir lowering to function type-path segments Diff: --- 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(-) diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in index b36069f07e9..18a5ef5f759 100644 --- a/gcc/rust/Make-lang.in +++ b/gcc/rust/Make-lang.in @@ -89,6 +89,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 80ff960db90..46430548c56 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 d52d1083ae3..592d9e810f9 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 46f765a3ea2..d593b480829 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 03cf5f5d2e8..06f3acbf904 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