public inbox for gcc-cvs@sourceware.org
help / color / mirror / Atom feed
* [gcc/devel/rust/master] Add mssing mappings to HIR::Pattern
@ 2022-06-08 11:57 Thomas Schwinge
0 siblings, 0 replies; only message in thread
From: Thomas Schwinge @ 2022-06-08 11:57 UTC (permalink / raw)
To: gcc-cvs
https://gcc.gnu.org/g:4d70990b838e3fbeedaf0918c2c87f46cdf0d689
commit 4d70990b838e3fbeedaf0918c2c87f46cdf0d689
Author: Philip Herron <philip.herron@embecosm.com>
Date: Thu Dec 16 10:53:26 2021 +0000
Add mssing mappings to HIR::Pattern
Diff:
---
gcc/rust/hir/rust-ast-lower-pattern.cc | 30 ++-
gcc/rust/hir/rust-ast-lower-pattern.h | 20 +-
gcc/rust/hir/tree/rust-hir-path.h | 10 +
gcc/rust/hir/tree/rust-hir-pattern.h | 250 +++++++++++++++++-----
gcc/rust/hir/tree/rust-hir.h | 2 +
gcc/rust/typecheck/rust-hir-type-check-implitem.h | 16 +-
gcc/rust/typecheck/rust-hir-type-check.cc | 9 +-
gcc/rust/util/rust-hir-map.cc | 23 ++
gcc/rust/util/rust-hir-map.h | 42 ++--
9 files changed, 325 insertions(+), 77 deletions(-)
diff --git a/gcc/rust/hir/rust-ast-lower-pattern.cc b/gcc/rust/hir/rust-ast-lower-pattern.cc
index 4ff61cd2a47..156f023281b 100644
--- a/gcc/rust/hir/rust-ast-lower-pattern.cc
+++ b/gcc/rust/hir/rust-ast-lower-pattern.cc
@@ -61,8 +61,13 @@ ASTLoweringPattern::visit (AST::TupleStructPattern &pattern)
break;
}
+ auto crate_num = mappings->get_current_crate ();
+ Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
+ mappings->get_next_hir_id (crate_num),
+ UNKNOWN_LOCAL_DEFID);
+
translated = new HIR::TupleStructPattern (
- *path, std::unique_ptr<HIR::TupleStructItems> (lowered));
+ mapping, *path, std::unique_ptr<HIR::TupleStructItems> (lowered));
}
void
@@ -96,19 +101,38 @@ ASTLoweringPattern::visit (AST::StructPattern &pattern)
AST::StructPatternFieldIdent &ident
= static_cast<AST::StructPatternFieldIdent &> (*field.get ());
+ auto crate_num = mappings->get_current_crate ();
+ Analysis::NodeMapping mapping (crate_num, ident.get_node_id (),
+ mappings->get_next_hir_id (
+ crate_num),
+ UNKNOWN_LOCAL_DEFID);
+
f = new HIR::StructPatternFieldIdent (
- ident.get_identifier (), ident.is_ref (),
+ mapping, ident.get_identifier (), ident.is_ref (),
ident.is_mut () ? Mutability::Mut : Mutability::Imm,
ident.get_outer_attrs (), ident.get_locus ());
}
break;
}
+ // insert the reverse mappings and locations
+ auto crate_num = f->get_mappings ().get_crate_num ();
+ auto field_id = f->get_mappings ().get_hirid ();
+ auto field_node_id = f->get_mappings ().get_nodeid ();
+ mappings->insert_location (crate_num, field_id, f->get_locus ());
+ mappings->insert_node_to_hir (crate_num, field_node_id, field_id);
+
+ // add it to the lowered fields list
fields.push_back (std::unique_ptr<HIR::StructPatternField> (f));
}
+ auto crate_num = mappings->get_current_crate ();
+ Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
+ mappings->get_next_hir_id (crate_num),
+ UNKNOWN_LOCAL_DEFID);
+
HIR::StructPatternElements elems (std::move (fields));
- translated = new HIR::StructPattern (*path, std::move (elems));
+ translated = new HIR::StructPattern (mapping, *path, std::move (elems));
}
} // namespace HIR
diff --git a/gcc/rust/hir/rust-ast-lower-pattern.h b/gcc/rust/hir/rust-ast-lower-pattern.h
index d8c03cef744..bd25b83741e 100644
--- a/gcc/rust/hir/rust-ast-lower-pattern.h
+++ b/gcc/rust/hir/rust-ast-lower-pattern.h
@@ -33,16 +33,32 @@ public:
{
ASTLoweringPattern resolver;
pattern->accept_vis (resolver);
+
rust_assert (resolver.translated != nullptr);
+
+ resolver.mappings->insert_hir_pattern (
+ resolver.translated->get_pattern_mappings ().get_crate_num (),
+ resolver.translated->get_pattern_mappings ().get_hirid (),
+ resolver.translated);
+ resolver.mappings->insert_location (
+ resolver.translated->get_pattern_mappings ().get_crate_num (),
+ resolver.translated->get_pattern_mappings ().get_hirid (),
+ pattern->get_locus ());
+
return resolver.translated;
}
void visit (AST::IdentifierPattern &pattern) override
{
+ auto crate_num = mappings->get_current_crate ();
+ Analysis::NodeMapping mapping (crate_num, pattern.get_node_id (),
+ mappings->get_next_hir_id (crate_num),
+ UNKNOWN_LOCAL_DEFID);
+
std::unique_ptr<Pattern> to_bind;
translated
- = new HIR::IdentifierPattern (pattern.get_ident (), pattern.get_locus (),
- pattern.get_is_ref (),
+ = new HIR::IdentifierPattern (mapping, pattern.get_ident (),
+ pattern.get_locus (), pattern.get_is_ref (),
pattern.get_is_mut () ? Mutability::Mut
: Mutability::Imm,
std::move (to_bind));
diff --git a/gcc/rust/hir/tree/rust-hir-path.h b/gcc/rust/hir/tree/rust-hir-path.h
index 4364fb47995..16e1be36181 100644
--- a/gcc/rust/hir/tree/rust-hir-path.h
+++ b/gcc/rust/hir/tree/rust-hir-path.h
@@ -330,6 +330,11 @@ public:
== 0;
}
+ Analysis::NodeMapping get_pattern_mappings () const override final
+ {
+ return get_mappings ();
+ }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -824,6 +829,11 @@ public:
Location get_locus () { return locus; }
+ Analysis::NodeMapping get_pattern_mappings () const override final
+ {
+ return get_mappings ();
+ }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
diff --git a/gcc/rust/hir/tree/rust-hir-pattern.h b/gcc/rust/hir/tree/rust-hir-pattern.h
index bdeeaed635e..fd4960fd233 100644
--- a/gcc/rust/hir/tree/rust-hir-pattern.h
+++ b/gcc/rust/hir/tree/rust-hir-pattern.h
@@ -24,38 +24,40 @@
namespace Rust {
namespace HIR {
+
// Literal pattern HIR node (comparing to a literal)
class LiteralPattern : public Pattern
{
Literal lit;
- /* make literal have a type given by enum, etc. rustc uses an extended form of
- * its literal token implementation */
- // TODO: literal representation - use LiteralExpr? or another thing?
-
- // Minus prefixed to literal (if integer or floating-point)
bool has_minus;
- // Actually, this might be a good place to use a template.
-
Location locus;
+ Analysis::NodeMapping mappings;
public:
std::string as_string () const override;
// Constructor for a literal pattern
- LiteralPattern (Literal lit, Location locus, bool has_minus = false)
- : lit (std::move (lit)), has_minus (has_minus), locus (locus)
+ LiteralPattern (Analysis::NodeMapping mappings, Literal lit, Location locus,
+ bool has_minus = false)
+ : lit (std::move (lit)), has_minus (has_minus), locus (locus),
+ mappings (mappings)
{}
- LiteralPattern (std::string val, Literal::LitType type, Location locus,
- bool has_minus = false)
+ LiteralPattern (Analysis::NodeMapping mappings, std::string val,
+ Literal::LitType type, Location locus, bool has_minus = false)
: lit (Literal (std::move (val), type, PrimitiveCoreType::CORETYPE_STR)),
- has_minus (has_minus), locus (locus)
+ has_minus (has_minus), locus (locus), mappings (mappings)
{}
Location get_locus () const { return locus; }
void accept_vis (HIRVisitor &vis) override;
+ Analysis::NodeMapping get_pattern_mappings () const override final
+ {
+ return mappings;
+ }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -73,6 +75,7 @@ class IdentifierPattern : public Pattern
Mutability mut;
std::unique_ptr<Pattern> to_bind;
Location locus;
+ Analysis::NodeMapping mappings;
public:
std::string as_string () const override;
@@ -81,17 +84,18 @@ public:
bool has_pattern_to_bind () const { return to_bind != nullptr; }
// Constructor
- IdentifierPattern (Identifier ident, Location locus, bool is_ref = false,
+ IdentifierPattern (Analysis::NodeMapping mappings, Identifier ident,
+ Location locus, bool is_ref = false,
Mutability mut = Mutability::Imm,
std::unique_ptr<Pattern> to_bind = nullptr)
: variable_ident (std::move (ident)), is_ref (is_ref), mut (mut),
- to_bind (std::move (to_bind)), locus (locus)
+ to_bind (std::move (to_bind)), locus (locus), mappings (mappings)
{}
// Copy constructor with clone
IdentifierPattern (IdentifierPattern const &other)
: variable_ident (other.variable_ident), is_ref (other.is_ref),
- mut (other.mut), locus (other.locus)
+ mut (other.mut), locus (other.locus), mappings (other.mappings)
{
// fix to get prevent null pointer dereference
if (other.to_bind != nullptr)
@@ -105,6 +109,7 @@ public:
is_ref = other.is_ref;
mut = other.mut;
locus = other.locus;
+ mappings = other.mappings;
// fix to get prevent null pointer dereference
if (other.to_bind != nullptr)
@@ -123,6 +128,11 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ Analysis::NodeMapping get_pattern_mappings () const override final
+ {
+ return mappings;
+ }
+
Identifier get_identifier () const { return variable_ident; }
protected:
@@ -138,16 +148,24 @@ protected:
class WildcardPattern : public Pattern
{
Location locus;
+ Analysis::NodeMapping mappings;
public:
std::string as_string () const override { return std::string (1, '_'); }
- WildcardPattern (Location locus) : locus (locus) {}
+ WildcardPattern (Analysis::NodeMapping mappings, Location locus)
+ : locus (locus), mappings (mappings)
+ {}
Location get_locus () const { return locus; }
void accept_vis (HIRVisitor &vis) override;
+ Analysis::NodeMapping get_pattern_mappings () const override final
+ {
+ return mappings;
+ }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -278,23 +296,27 @@ class RangePattern : public Pattern
/* location only stored to avoid a dereference - lower pattern should give
* correct location so maybe change in future */
Location locus;
+ Analysis::NodeMapping mappings;
public:
std::string as_string () const override;
// Constructor
- RangePattern (std::unique_ptr<RangePatternBound> lower,
+ RangePattern (Analysis::NodeMapping mappings,
+ std::unique_ptr<RangePatternBound> lower,
std::unique_ptr<RangePatternBound> upper, Location locus,
bool has_ellipsis_syntax = false)
: lower (std::move (lower)), upper (std::move (upper)),
- has_ellipsis_syntax (has_ellipsis_syntax), locus (locus)
+ has_ellipsis_syntax (has_ellipsis_syntax), locus (locus),
+ mappings (mappings)
{}
// Copy constructor with clone
RangePattern (RangePattern const &other)
: lower (other.lower->clone_range_pattern_bound ()),
upper (other.upper->clone_range_pattern_bound ()),
- has_ellipsis_syntax (other.has_ellipsis_syntax), locus (other.locus)
+ has_ellipsis_syntax (other.has_ellipsis_syntax), locus (other.locus),
+ mappings (other.mappings)
{}
// Overloaded assignment operator to clone
@@ -304,6 +326,7 @@ public:
upper = other.upper->clone_range_pattern_bound ();
has_ellipsis_syntax = other.has_ellipsis_syntax;
locus = other.locus;
+ mappings = other.mappings;
return *this;
}
@@ -316,6 +339,11 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ Analysis::NodeMapping get_pattern_mappings () const override final
+ {
+ return mappings;
+ }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -332,20 +360,23 @@ class ReferencePattern : public Pattern
Mutability mut;
std::unique_ptr<Pattern> pattern;
Location locus;
+ Analysis::NodeMapping mappings;
public:
std::string as_string () const override;
- ReferencePattern (std::unique_ptr<Pattern> pattern, Mutability reference_mut,
+ ReferencePattern (Analysis::NodeMapping mappings,
+ std::unique_ptr<Pattern> pattern, Mutability reference_mut,
bool ref_has_two_amps, Location locus)
: has_two_amps (ref_has_two_amps), mut (reference_mut),
- pattern (std::move (pattern)), locus (locus)
+ pattern (std::move (pattern)), locus (locus), mappings (mappings)
{}
// Copy constructor requires clone
ReferencePattern (ReferencePattern const &other)
: has_two_amps (other.has_two_amps), mut (other.mut),
- pattern (other.pattern->clone_pattern ()), locus (other.locus)
+ pattern (other.pattern->clone_pattern ()), locus (other.locus),
+ mappings (other.mappings)
{}
// Overload assignment operator to clone
@@ -355,6 +386,7 @@ public:
mut = other.mut;
has_two_amps = other.has_two_amps;
locus = other.locus;
+ mappings = other.mappings;
return *this;
}
@@ -367,6 +399,11 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ Analysis::NodeMapping get_pattern_mappings () const override final
+ {
+ return mappings;
+ }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -381,8 +418,16 @@ class StructPatternField
{
AST::AttrVec outer_attrs;
Location locus;
+ Analysis::NodeMapping mappings;
public:
+ enum ItemType
+ {
+ TUPLE_PAT,
+ IDENT_PAT,
+ IDENT
+ };
+
virtual ~StructPatternField () {}
// Unique pointer custom clone function
@@ -393,14 +438,17 @@ public:
}
virtual std::string as_string () const;
+ virtual void accept_vis (HIRVisitor &vis) = 0;
+ virtual ItemType get_item_type () const = 0;
Location get_locus () const { return locus; }
-
- virtual void accept_vis (HIRVisitor &vis) = 0;
+ Analysis::NodeMapping get_mappings () const { return mappings; };
protected:
- StructPatternField (AST::AttrVec outer_attribs, Location locus)
- : outer_attrs (std::move (outer_attribs)), locus (locus)
+ StructPatternField (Analysis::NodeMapping mappings,
+ AST::AttrVec outer_attribs, Location locus)
+ : outer_attrs (std::move (outer_attribs)), locus (locus),
+ mappings (mappings)
{}
// Clone function implementation as pure virtual method
@@ -414,11 +462,11 @@ class StructPatternFieldTuplePat : public StructPatternField
std::unique_ptr<Pattern> tuple_pattern;
public:
- StructPatternFieldTuplePat (TupleIndex index,
+ StructPatternFieldTuplePat (Analysis::NodeMapping mappings, TupleIndex index,
std::unique_ptr<Pattern> tuple_pattern,
AST::AttrVec outer_attribs, Location locus)
- : StructPatternField (std::move (outer_attribs), locus), index (index),
- tuple_pattern (std::move (tuple_pattern))
+ : StructPatternField (mappings, std::move (outer_attribs), locus),
+ index (index), tuple_pattern (std::move (tuple_pattern))
{}
// Copy constructor requires clone
@@ -448,6 +496,8 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ ItemType get_item_type () const override final { return ItemType::TUPLE_PAT; }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -464,10 +514,10 @@ class StructPatternFieldIdentPat : public StructPatternField
std::unique_ptr<Pattern> ident_pattern;
public:
- StructPatternFieldIdentPat (Identifier ident,
+ StructPatternFieldIdentPat (Analysis::NodeMapping mappings, Identifier ident,
std::unique_ptr<Pattern> ident_pattern,
AST::AttrVec outer_attrs, Location locus)
- : StructPatternField (std::move (outer_attrs), locus),
+ : StructPatternField (mappings, std::move (outer_attrs), locus),
ident (std::move (ident)), ident_pattern (std::move (ident_pattern))
{}
@@ -498,6 +548,8 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ ItemType get_item_type () const override final { return ItemType::IDENT_PAT; }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -515,10 +567,11 @@ class StructPatternFieldIdent : public StructPatternField
Identifier ident;
public:
- StructPatternFieldIdent (Identifier ident, bool is_ref, Mutability mut,
+ StructPatternFieldIdent (Analysis::NodeMapping mappings, Identifier ident,
+ bool is_ref, Mutability mut,
AST::AttrVec outer_attrs, Location locus)
- : StructPatternField (std::move (outer_attrs), locus), has_ref (is_ref),
- mut (mut), ident (std::move (ident))
+ : StructPatternField (mappings, std::move (outer_attrs), locus),
+ has_ref (is_ref), mut (mut), ident (std::move (ident))
{}
std::string as_string () const override;
@@ -527,6 +580,10 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ ItemType get_item_type () const override final { return ItemType::IDENT; }
+
+ Identifier get_identifier () const { return ident; };
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -586,6 +643,12 @@ public:
}
std::string as_string () const;
+
+ std::vector<std::unique_ptr<StructPatternField> > &
+ get_struct_pattern_fields ()
+ {
+ return fields;
+ }
};
// Struct pattern HIR node representation
@@ -593,12 +656,15 @@ class StructPattern : public Pattern
{
PathInExpression path;
StructPatternElements elems;
+ Analysis::NodeMapping mappings;
public:
std::string as_string () const override;
- StructPattern (PathInExpression struct_path, StructPatternElements elems)
- : path (std::move (struct_path)), elems (std::move (elems))
+ StructPattern (Analysis::NodeMapping mappings, PathInExpression struct_path,
+ StructPatternElements elems)
+ : path (std::move (struct_path)), elems (std::move (elems)),
+ mappings (mappings)
{}
bool has_struct_pattern_elems () const { return !elems.is_empty (); }
@@ -607,6 +673,14 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ PathInExpression &get_path () { return path; }
+ StructPatternElements &get_struct_pattern_elems () { return elems; }
+
+ Analysis::NodeMapping get_pattern_mappings () const override final
+ {
+ return mappings;
+ }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -620,6 +694,12 @@ protected:
class TupleStructItems
{
public:
+ enum ItemType
+ {
+ RANGE,
+ NO_RANGE
+ };
+
virtual ~TupleStructItems () {}
// TODO: should this store location data?
@@ -634,6 +714,8 @@ public:
virtual void accept_vis (HIRVisitor &vis) = 0;
+ virtual ItemType get_item_type () const = 0;
+
protected:
// pure virtual clone implementation
virtual TupleStructItems *clone_tuple_struct_items_impl () const = 0;
@@ -676,6 +758,14 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ std::vector<std::unique_ptr<Pattern> > &get_patterns () { return patterns; }
+ const std::vector<std::unique_ptr<Pattern> > &get_patterns () const
+ {
+ return patterns;
+ }
+
+ ItemType get_item_type () const override final { return ItemType::NO_RANGE; }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -732,6 +822,27 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ std::vector<std::unique_ptr<Pattern> > &get_lower_patterns ()
+ {
+ return lower_patterns;
+ }
+ const std::vector<std::unique_ptr<Pattern> > &get_lower_patterns () const
+ {
+ return lower_patterns;
+ }
+
+ // TODO: seems kinda dodgy. Think of better way.
+ std::vector<std::unique_ptr<Pattern> > &get_upper_patterns ()
+ {
+ return upper_patterns;
+ }
+ const std::vector<std::unique_ptr<Pattern> > &get_upper_patterns () const
+ {
+ return upper_patterns;
+ }
+
+ ItemType get_item_type () const override final { return ItemType::RANGE; }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -746,6 +857,7 @@ class TupleStructPattern : public Pattern
{
PathInExpression path;
std::unique_ptr<TupleStructItems> items;
+ Analysis::NodeMapping mappings;
/* TOOD: should this store location data? current accessor uses path location
* data */
@@ -753,14 +865,17 @@ class TupleStructPattern : public Pattern
public:
std::string as_string () const override;
- TupleStructPattern (PathInExpression tuple_struct_path,
+ TupleStructPattern (Analysis::NodeMapping mappings,
+ PathInExpression tuple_struct_path,
std::unique_ptr<TupleStructItems> items)
- : path (std::move (tuple_struct_path)), items (std::move (items))
+ : path (std::move (tuple_struct_path)), items (std::move (items)),
+ mappings (mappings)
{}
// Copy constructor required to clone
TupleStructPattern (TupleStructPattern const &other)
- : path (other.path), items (other.items->clone_tuple_struct_items ())
+ : path (other.path), items (other.items->clone_tuple_struct_items ()),
+ mappings (other.mappings)
{}
// Operator overload assignment operator to clone
@@ -768,6 +883,7 @@ public:
{
path = other.path;
items = other.items->clone_tuple_struct_items ();
+ mappings = other.mappings;
return *this;
}
@@ -780,6 +896,15 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ PathInExpression &get_path () { return path; }
+
+ std::unique_ptr<TupleStructItems> &get_items () { return items; }
+
+ Analysis::NodeMapping get_pattern_mappings () const override final
+ {
+ return mappings;
+ }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -955,10 +1080,9 @@ protected:
// HIR node representing a tuple pattern
class TuplePattern : public Pattern
{
- // bool has_tuple_pattern_items;
std::unique_ptr<TuplePatternItems> items;
-
Location locus;
+ Analysis::NodeMapping mappings;
public:
std::string as_string () const override;
@@ -966,13 +1090,15 @@ public:
// Returns true if the tuple pattern has items
bool has_tuple_pattern_items () const { return items != nullptr; }
- TuplePattern (std::unique_ptr<TuplePatternItems> items, Location locus)
- : items (std::move (items)), locus (locus)
+ TuplePattern (Analysis::NodeMapping mappings,
+ std::unique_ptr<TuplePatternItems> items, Location locus)
+ : items (std::move (items)), locus (locus), mappings (mappings)
{}
// Copy constructor requires clone
TuplePattern (TuplePattern const &other)
- : items (other.items->clone_tuple_pattern_items ()), locus (other.locus)
+ : items (other.items->clone_tuple_pattern_items ()), locus (other.locus),
+ mappings (other.mappings)
{}
// Overload assignment operator to clone
@@ -980,6 +1106,7 @@ public:
{
items = other.items->clone_tuple_pattern_items ();
locus = other.locus;
+ mappings = other.mappings;
return *this;
}
@@ -988,6 +1115,11 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ Analysis::NodeMapping get_pattern_mappings () const override final
+ {
+ return mappings;
+ }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -1002,6 +1134,7 @@ class GroupedPattern : public Pattern
{
std::unique_ptr<Pattern> pattern_in_parens;
Location locus;
+ Analysis::NodeMapping mappings;
public:
std::string as_string () const override
@@ -1009,14 +1142,16 @@ public:
return "(" + pattern_in_parens->as_string () + ")";
}
- GroupedPattern (std::unique_ptr<Pattern> pattern_in_parens, Location locus)
- : pattern_in_parens (std::move (pattern_in_parens)), locus (locus)
+ GroupedPattern (Analysis::NodeMapping mappings,
+ std::unique_ptr<Pattern> pattern_in_parens, Location locus)
+ : pattern_in_parens (std::move (pattern_in_parens)), locus (locus),
+ mappings (mappings)
{}
// Copy constructor uses clone
GroupedPattern (GroupedPattern const &other)
: pattern_in_parens (other.pattern_in_parens->clone_pattern ()),
- locus (other.locus)
+ locus (other.locus), mappings (other.mappings)
{}
// Overload assignment operator to clone
@@ -1024,6 +1159,7 @@ public:
{
pattern_in_parens = other.pattern_in_parens->clone_pattern ();
locus = other.locus;
+ mappings = other.mappings;
return *this;
}
@@ -1036,6 +1172,11 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ Analysis::NodeMapping get_pattern_mappings () const override final
+ {
+ return mappings;
+ }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
@@ -1050,16 +1191,19 @@ class SlicePattern : public Pattern
{
std::vector<std::unique_ptr<Pattern> > items;
Location locus;
+ Analysis::NodeMapping mappings;
public:
std::string as_string () const override;
- SlicePattern (std::vector<std::unique_ptr<Pattern> > items, Location locus)
- : items (std::move (items)), locus (locus)
+ SlicePattern (Analysis::NodeMapping mappings,
+ std::vector<std::unique_ptr<Pattern> > items, Location locus)
+ : items (std::move (items)), locus (locus), mappings (mappings)
{}
// Copy constructor with vector clone
- SlicePattern (SlicePattern const &other) : locus (other.locus)
+ SlicePattern (SlicePattern const &other)
+ : locus (other.locus), mappings (other.mappings)
{
items.reserve (other.items.size ());
for (const auto &e : other.items)
@@ -1070,6 +1214,7 @@ public:
SlicePattern &operator= (SlicePattern const &other)
{
locus = other.locus;
+ mappings = other.mappings;
items.reserve (other.items.size ());
for (const auto &e : other.items)
@@ -1086,6 +1231,11 @@ public:
void accept_vis (HIRVisitor &vis) override;
+ Analysis::NodeMapping get_pattern_mappings () const override final
+ {
+ return mappings;
+ }
+
protected:
/* Use covariance to implement clone function as returning this object rather
* than base */
diff --git a/gcc/rust/hir/tree/rust-hir.h b/gcc/rust/hir/tree/rust-hir.h
index e8345539b39..8b5f3bb2dea 100644
--- a/gcc/rust/hir/tree/rust-hir.h
+++ b/gcc/rust/hir/tree/rust-hir.h
@@ -328,6 +328,8 @@ public:
virtual void accept_vis (HIRVisitor &vis) = 0;
+ virtual Analysis::NodeMapping get_pattern_mappings () const = 0;
+
protected:
// Clone pattern implementation as pure virtual method
virtual Pattern *clone_pattern_impl () const = 0;
diff --git a/gcc/rust/typecheck/rust-hir-type-check-implitem.h b/gcc/rust/typecheck/rust-hir-type-check-implitem.h
index 64853f5d013..a8606084d9f 100644
--- a/gcc/rust/typecheck/rust-hir-type-check-implitem.h
+++ b/gcc/rust/typecheck/rust-hir-type-check-implitem.h
@@ -100,8 +100,14 @@ public:
// get the name as well required for later on
auto param_tyty = TypeCheckType::Resolve (param.get_type ().get ());
+ // these are implicit mappings and not used
+ auto crate_num = mappings->get_current_crate ();
+ Analysis::NodeMapping mapping (crate_num, mappings->get_next_node_id (),
+ mappings->get_next_hir_id (crate_num),
+ UNKNOWN_LOCAL_DEFID);
+
HIR::IdentifierPattern *param_pattern = new HIR::IdentifierPattern (
- param.get_param_name (), Location (), false, Mutability::Imm,
+ mapping, param.get_param_name (), Location (), false, Mutability::Imm,
std::unique_ptr<HIR::Pattern> (nullptr));
params.push_back (
@@ -223,12 +229,18 @@ public:
std::vector<std::pair<HIR::Pattern *, TyTy::BaseType *> > params;
if (function.is_method ())
{
+ // these are implicit mappings and not used
+ auto crate_num = mappings->get_current_crate ();
+ Analysis::NodeMapping mapping (crate_num, mappings->get_next_node_id (),
+ mappings->get_next_hir_id (crate_num),
+ UNKNOWN_LOCAL_DEFID);
+
// add the synthetic self param at the front, this is a placeholder for
// compilation to know parameter names. The types are ignored but we
// reuse the HIR identifier pattern which requires it
HIR::SelfParam &self_param = function.get_self_param ();
HIR::IdentifierPattern *self_pattern = new HIR::IdentifierPattern (
- "self", self_param.get_locus (), self_param.is_ref (),
+ mapping, "self", self_param.get_locus (), self_param.is_ref (),
self_param.get_mut (), std::unique_ptr<HIR::Pattern> (nullptr));
// might have a specified type
diff --git a/gcc/rust/typecheck/rust-hir-type-check.cc b/gcc/rust/typecheck/rust-hir-type-check.cc
index 4596973c2c1..d2da20eb52d 100644
--- a/gcc/rust/typecheck/rust-hir-type-check.cc
+++ b/gcc/rust/typecheck/rust-hir-type-check.cc
@@ -276,12 +276,19 @@ TraitItemReference::get_type_from_fn (/*const*/ HIR::TraitItemFunc &fn) const
std::vector<std::pair<HIR::Pattern *, TyTy::BaseType *> > params;
if (function.is_method ())
{
+ // these are implicit mappings and not used
+ auto mappings = Analysis::Mappings::get ();
+ auto crate_num = mappings->get_current_crate ();
+ Analysis::NodeMapping mapping (crate_num, mappings->get_next_node_id (),
+ mappings->get_next_hir_id (crate_num),
+ UNKNOWN_LOCAL_DEFID);
+
// add the synthetic self param at the front, this is a placeholder
// for compilation to know parameter names. The types are ignored
// but we reuse the HIR identifier pattern which requires it
HIR::SelfParam &self_param = function.get_self ();
HIR::IdentifierPattern *self_pattern
- = new HIR::IdentifierPattern ("self", self_param.get_locus (),
+ = new HIR::IdentifierPattern (mapping, "self", self_param.get_locus (),
self_param.is_ref (),
self_param.is_mut () ? Mutability::Mut
: Mutability::Imm,
diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc
index 9e5b5095178..4b713128b0f 100644
--- a/gcc/rust/util/rust-hir-map.cc
+++ b/gcc/rust/util/rust-hir-map.cc
@@ -565,6 +565,29 @@ Mappings::lookup_hir_struct_field (CrateNum crateNum, HirId id)
return iy->second;
}
+void
+Mappings::insert_hir_pattern (CrateNum crateNum, HirId id,
+ HIR::Pattern *pattern)
+{
+ hirPatternMappings[crateNum][id] = pattern;
+ nodeIdToHirMappings[crateNum][pattern->get_pattern_mappings ().get_nodeid ()]
+ = id;
+}
+
+HIR::Pattern *
+Mappings::lookup_hir_pattern (CrateNum crateNum, HirId id)
+{
+ auto it = hirPatternMappings.find (crateNum);
+ if (it == hirPatternMappings.end ())
+ return nullptr;
+
+ auto iy = it->second.find (id);
+ if (iy == it->second.end ())
+ return nullptr;
+
+ return iy->second;
+}
+
void
Mappings::insert_local_defid_mapping (CrateNum crateNum, LocalDefId id,
HIR::Item *item)
diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h
index 77a4cafb4df..f1f723bda46 100644
--- a/gcc/rust/util/rust-hir-map.h
+++ b/gcc/rust/util/rust-hir-map.h
@@ -347,6 +347,9 @@ public:
HIR::StructExprField *type);
HIR::StructExprField *lookup_hir_struct_field (CrateNum crateNum, HirId id);
+ void insert_hir_pattern (CrateNum crateNum, HirId id, HIR::Pattern *pattern);
+ HIR::Pattern *lookup_hir_pattern (CrateNum crateNum, HirId id);
+
void walk_local_defids_for_crate (CrateNum crateNum,
std::function<bool (HIR::Item *)> cb);
@@ -479,43 +482,44 @@ private:
std::map<CrateNum, HIR::Crate *> hirCrateMappings;
std::map<DefId, HIR::Item *> defIdMappings;
- std::map<CrateNum, std::map<LocalDefId, HIR::Item *> > localDefIdMappings;
- std::map<CrateNum, std::map<HirId, HIR::Module *> > hirModuleMappings;
- std::map<CrateNum, std::map<HirId, HIR::Item *> > hirItemMappings;
- std::map<CrateNum, std::map<HirId, HIR::Type *> > hirTypeMappings;
- std::map<CrateNum, std::map<HirId, HIR::Expr *> > hirExprMappings;
- std::map<CrateNum, std::map<HirId, HIR::Stmt *> > hirStmtMappings;
- std::map<CrateNum, std::map<HirId, HIR::FunctionParam *> > hirParamMappings;
- std::map<CrateNum, std::map<HirId, HIR::StructExprField *> >
+ std::map<CrateNum, std::map<LocalDefId, HIR::Item *>> localDefIdMappings;
+ std::map<CrateNum, std::map<HirId, HIR::Module *>> hirModuleMappings;
+ std::map<CrateNum, std::map<HirId, HIR::Item *>> hirItemMappings;
+ std::map<CrateNum, std::map<HirId, HIR::Type *>> hirTypeMappings;
+ std::map<CrateNum, std::map<HirId, HIR::Expr *>> hirExprMappings;
+ std::map<CrateNum, std::map<HirId, HIR::Stmt *>> hirStmtMappings;
+ std::map<CrateNum, std::map<HirId, HIR::FunctionParam *>> hirParamMappings;
+ std::map<CrateNum, std::map<HirId, HIR::StructExprField *>>
hirStructFieldMappings;
- std::map<CrateNum, std::map<HirId, std::pair<HirId, HIR::ImplItem *> > >
+ std::map<CrateNum, std::map<HirId, std::pair<HirId, HIR::ImplItem *>>>
hirImplItemMappings;
- std::map<CrateNum, std::map<HirId, HIR::SelfParam *> > hirSelfParamMappings;
+ std::map<CrateNum, std::map<HirId, HIR::SelfParam *>> hirSelfParamMappings;
std::map<HirId, HIR::ImplBlock *> hirImplItemsToImplMappings;
- std::map<CrateNum, std::map<HirId, HIR::ImplBlock *> > hirImplBlockMappings;
- std::map<CrateNum, std::map<HirId, HIR::TraitItem *> > hirTraitItemMappings;
- std::map<CrateNum, std::map<HirId, HIR::ExternalItem *> >
+ std::map<CrateNum, std::map<HirId, HIR::ImplBlock *>> hirImplBlockMappings;
+ std::map<CrateNum, std::map<HirId, HIR::TraitItem *>> hirTraitItemMappings;
+ std::map<CrateNum, std::map<HirId, HIR::ExternalItem *>>
hirExternItemMappings;
- std::map<CrateNum, std::map<HirId, HIR::PathExprSegment *> >
+ std::map<CrateNum, std::map<HirId, HIR::PathExprSegment *>>
hirPathSegMappings;
- std::map<CrateNum, std::map<HirId, HIR::GenericParam *> >
+ std::map<CrateNum, std::map<HirId, HIR::GenericParam *>>
hirGenericParamMappings;
std::map<HirId, HIR::Trait *> hirTraitItemsToTraitMappings;
+ std::map<CrateNum, std::map<HirId, HIR::Pattern *>> hirPatternMappings;
// this maps the lang=<item_type> to DefId mappings
std::map<RustLangItem::ItemType, DefId> lang_item_mappings;
// canonical paths
- std::map<CrateNum, std::map<NodeId, const Resolver::CanonicalPath> > paths;
+ std::map<CrateNum, std::map<NodeId, const Resolver::CanonicalPath>> paths;
// location info
- std::map<CrateNum, std::map<NodeId, Location> > locations;
+ std::map<CrateNum, std::map<NodeId, Location>> locations;
// reverse mappings
- std::map<CrateNum, std::map<NodeId, HirId> > nodeIdToHirMappings;
+ std::map<CrateNum, std::map<NodeId, HirId>> nodeIdToHirMappings;
// all hirid nodes
- std::map<CrateNum, std::set<HirId> > hirNodesWithinCrate;
+ std::map<CrateNum, std::set<HirId>> hirNodesWithinCrate;
// crate names
std::map<CrateNum, std::string> crate_names;
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2022-06-08 11:57 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-06-08 11:57 [gcc/devel/rust/master] Add mssing mappings to HIR::Pattern Thomas Schwinge
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).