From: Arthur Cohen <arthur.cohen@embecosm.com>
To: gcc-patches@gcc.gnu.org
Cc: gcc-rust@gcc.gnu.org, Arthur Cohen <arthur.cohen@embecosm.com>
Subject: [PATCH 022/125] gccrs: lang-items: Cleanup parsing and lookups of lang items.
Date: Thu, 1 Aug 2024 16:56:18 +0200 [thread overview]
Message-ID: <20240801145809.366388-24-arthur.cohen@embecosm.com> (raw)
In-Reply-To: <20240801145809.366388-2-arthur.cohen@embecosm.com>
gcc/rust/ChangeLog:
* Make-lang.in: Compile new rust-lang-item.o.
* util/rust-lang-item.h: Split into header and source.
* util/rust-lang-item.cc: Cleanup parsing of lang items by using a hashmap
and returning optional values, cleanup handling of exhaustive lang item
lookups.
* hir/rust-ast-lower-base.cc (ASTLoweringBase::handle_lang_item_attribute): Use
new optional API.
---
gcc/rust/Make-lang.in | 1 +
gcc/rust/hir/rust-ast-lower-base.cc | 13 +-
gcc/rust/util/rust-lang-item.cc | 191 +++++++++++
gcc/rust/util/rust-lang-item.h | 508 +---------------------------
4 files changed, 206 insertions(+), 507 deletions(-)
create mode 100644 gcc/rust/util/rust-lang-item.cc
diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in
index baf55161d78..af5d775a3a6 100644
--- a/gcc/rust/Make-lang.in
+++ b/gcc/rust/Make-lang.in
@@ -203,6 +203,7 @@ GRS_OBJS = \
rust/rust-dir-owner.o \
rust/rust-unicode.o \
rust/rust-punycode.o \
+ rust/rust-lang-item.o \
$(END)
# removed object files from here
diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc
index 3ff0f52e0c6..815b98f9f0a 100644
--- a/gcc/rust/hir/rust-ast-lower-base.cc
+++ b/gcc/rust/hir/rust-ast-lower-base.cc
@@ -789,13 +789,12 @@ ASTLoweringBase::handle_lang_item_attribute (const ItemWrapper &item,
auto &literal = static_cast<AST::AttrInputLiteral &> (attr.get_attr_input ());
const auto &lang_item_type_str = literal.get_literal ().as_string ();
auto lang_item_type = Analysis::RustLangItem::Parse (lang_item_type_str);
- if (lang_item_type == Analysis::RustLangItem::ItemType::UNKNOWN)
- {
- rust_error_at (attr.get_locus (), "unknown lang item");
- return;
- }
- mappings->insert_lang_item (lang_item_type,
- item.get_mappings ().get_defid ());
+
+ if (lang_item_type)
+ mappings->insert_lang_item (*lang_item_type,
+ item.get_mappings ().get_defid ());
+ else
+ rust_error_at (attr.get_locus (), "unknown lang item");
}
bool
diff --git a/gcc/rust/util/rust-lang-item.cc b/gcc/rust/util/rust-lang-item.cc
new file mode 100644
index 00000000000..9fe212d412d
--- /dev/null
+++ b/gcc/rust/util/rust-lang-item.cc
@@ -0,0 +1,191 @@
+// Copyright (C) 2020-2024 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
+// <http://www.gnu.org/licenses/>.
+
+#include "rust-lang-item.h"
+#include "rust-system.h"
+
+namespace Rust {
+namespace Analysis {
+
+const BiMap<std::string, RustLangItem::ItemType>
+ Rust::Analysis::RustLangItem::lang_items = {{
+ {"add", ADD},
+ {"sub", SUBTRACT},
+ {"mul", MULTIPLY},
+ {"div", DIVIDE},
+ {"rem", REMAINDER},
+ {"bitand", BITAND},
+ {"bitor", BITOR},
+ {"bitxor", BITXOR},
+ {"shl", SHL},
+ {"shr", SHR},
+ {"neg", NEGATION},
+ {"not", NOT},
+ {"add_assign", ADD_ASSIGN},
+ {"sub_assign", SUB_ASSIGN},
+ {"mul_assign", MUL_ASSIGN},
+ {"div_assign", DIV_ASSIGN},
+ {"rem_assign", REM_ASSIGN},
+ {"bitand_assign", BITAND_ASSIGN},
+ {"bitor_assign", BITOR_ASSIGN},
+ {"bitxor_assign", BITXOR_ASSIGN},
+ {"shl_assign", SHL_ASSIGN},
+ {"shr_assign", SHR_ASSIGN},
+ {"deref", DEREF},
+ {"deref_mut", DEREF_MUT},
+ {"index", INDEX},
+ {"index_mut", INDEX_MUT},
+ {"RangeFull", RANGE_FULL},
+ {"Range", RANGE},
+ {"RangeFrom", RANGE_FROM},
+ {"RangeTo", RANGE_TO},
+ {"RangeInclusive", RANGE_INCLUSIVE},
+ {"RangeToInclusive", RANGE_TO_INCLUSIVE},
+ {"phantom_data", PHANTOM_DATA},
+ {"fn", FN},
+ {"fn_mut", FN_MUT},
+ {"fn_once", FN_ONCE},
+ {"fn_once_output", FN_ONCE_OUTPUT},
+ {"copy", COPY},
+ {"clone", CLONE},
+ {"sized", SIZED},
+ {"slice_alloc", SLICE_ALLOC},
+ {"slice_u8_alloc", SLICE_U8_ALLOC},
+ {"str_alloc", STR_ALLOC},
+ {"array", ARRAY},
+ {"bool", BOOL},
+ {"char", CHAR},
+ {"f32", F32},
+ {"f64", F64},
+ {"i8", I8},
+ {"i16", I16},
+ {"i32", I32},
+ {"i64", I64},
+ {"i128", I128},
+ {"isize", ISIZE},
+ {"u8", U8},
+ {"u16", U16},
+ {"u32", U32},
+ {"u64", U64},
+ {"u128", U128},
+ {"usize", USIZE},
+ {"const_ptr", CONST_PTR},
+ {"const_slice_ptr", CONST_SLICE_PTR},
+ {"mut_ptr", MUT_PTR},
+ {"mut_slice_ptr", MUT_SLICE_PTR},
+ {"slice_u8", SLICE_U8},
+ {"slice", SLICE},
+ {"str", STR},
+ {"f32_runtime", F32_RUNTIME},
+ {"f64_runtime", F64_RUNTIME},
+ }};
+
+tl::optional<RustLangItem::ItemType>
+RustLangItem::Parse (const std::string &item)
+{
+ auto lang_item = RustLangItem::lang_items.lookup (item);
+ if (!RustLangItem::lang_items.is_iter_ok (lang_item))
+ return tl::nullopt;
+
+ return lang_item->second;
+}
+
+std::string
+RustLangItem::ToString (RustLangItem::ItemType type)
+{
+ auto str = RustLangItem::lang_items.lookup (type);
+ return str->second;
+}
+
+RustLangItem::ItemType
+RustLangItem::OperatorToLangItem (ArithmeticOrLogicalOperator op)
+{
+ switch (op)
+ {
+ case ArithmeticOrLogicalOperator::ADD:
+ return RustLangItem::ItemType::ADD;
+ case ArithmeticOrLogicalOperator::SUBTRACT:
+ return RustLangItem::ItemType::SUBTRACT;
+ case ArithmeticOrLogicalOperator::MULTIPLY:
+ return RustLangItem::ItemType::MULTIPLY;
+ case ArithmeticOrLogicalOperator::DIVIDE:
+ return RustLangItem::ItemType::DIVIDE;
+ case ArithmeticOrLogicalOperator::MODULUS:
+ return RustLangItem::ItemType::REMAINDER;
+ case ArithmeticOrLogicalOperator::BITWISE_AND:
+ return RustLangItem::ItemType::BITAND;
+ case ArithmeticOrLogicalOperator::BITWISE_OR:
+ return RustLangItem::ItemType::BITOR;
+ case ArithmeticOrLogicalOperator::BITWISE_XOR:
+ return RustLangItem::ItemType::BITXOR;
+ case ArithmeticOrLogicalOperator::LEFT_SHIFT:
+ return RustLangItem::ItemType::SHL;
+ case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
+ return RustLangItem::ItemType::SHR;
+ }
+
+ rust_unreachable ();
+}
+
+RustLangItem::ItemType
+RustLangItem::CompoundAssignmentOperatorToLangItem (
+ ArithmeticOrLogicalOperator op)
+{
+ switch (op)
+ {
+ case ArithmeticOrLogicalOperator::ADD:
+ return RustLangItem::ItemType::ADD_ASSIGN;
+ case ArithmeticOrLogicalOperator::SUBTRACT:
+ return RustLangItem::ItemType::SUB_ASSIGN;
+ case ArithmeticOrLogicalOperator::MULTIPLY:
+ return RustLangItem::ItemType::MUL_ASSIGN;
+ case ArithmeticOrLogicalOperator::DIVIDE:
+ return RustLangItem::ItemType::DIV_ASSIGN;
+ case ArithmeticOrLogicalOperator::MODULUS:
+ return RustLangItem::ItemType::REM_ASSIGN;
+ case ArithmeticOrLogicalOperator::BITWISE_AND:
+ return RustLangItem::ItemType::BITAND_ASSIGN;
+ case ArithmeticOrLogicalOperator::BITWISE_OR:
+ return RustLangItem::ItemType::BITOR_ASSIGN;
+ case ArithmeticOrLogicalOperator::BITWISE_XOR:
+ return RustLangItem::ItemType::BITXOR_ASSIGN;
+ case ArithmeticOrLogicalOperator::LEFT_SHIFT:
+ return RustLangItem::ItemType::SHL_ASSIGN;
+ case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
+ return RustLangItem::ItemType::SHR_ASSIGN;
+ }
+
+ rust_unreachable ();
+}
+
+RustLangItem::ItemType
+RustLangItem::NegationOperatorToLangItem (NegationOperator op)
+{
+ switch (op)
+ {
+ case NegationOperator::NEGATE:
+ return RustLangItem::ItemType::NEGATION;
+ case NegationOperator::NOT:
+ return RustLangItem::ItemType::NOT;
+ }
+
+ rust_unreachable ();
+}
+
+} // namespace Analysis
+} // namespace Rust
diff --git a/gcc/rust/util/rust-lang-item.h b/gcc/rust/util/rust-lang-item.h
index 86323d9e267..3447e3680c8 100644
--- a/gcc/rust/util/rust-lang-item.h
+++ b/gcc/rust/util/rust-lang-item.h
@@ -18,6 +18,8 @@
#include "rust-system.h"
#include "rust-operators.h"
+#include "optional.h"
+#include "bi-map.h"
namespace Rust {
namespace Analysis {
@@ -115,510 +117,16 @@ public:
STR,
F32_RUNTIME,
F64_RUNTIME,
-
- // delimiter
- UNKNOWN,
};
- static ItemType Parse (const std::string &item)
- {
- if (item.compare ("add") == 0)
- {
- return ItemType::ADD;
- }
- else if (item.compare ("sub") == 0)
- {
- return ItemType::SUBTRACT;
- }
- else if (item.compare ("mul") == 0)
- {
- return ItemType::MULTIPLY;
- }
- else if (item.compare ("div") == 0)
- {
- return ItemType::DIVIDE;
- }
- else if (item.compare ("rem") == 0)
- {
- return ItemType::REMAINDER;
- }
- else if (item.compare ("bitand") == 0)
- {
- return ItemType::BITAND;
- }
- else if (item.compare ("bitor") == 0)
- {
- return ItemType::BITOR;
- }
- else if (item.compare ("bitxor") == 0)
- {
- return ItemType::BITXOR;
- }
- else if (item.compare ("shl") == 0)
- {
- return ItemType::SHL;
- }
- else if (item.compare ("shr") == 0)
- {
- return ItemType::SHR;
- }
- else if (item.compare ("neg") == 0)
- {
- return ItemType::NEGATION;
- }
- else if (item.compare ("not") == 0)
- {
- return ItemType::NOT;
- }
- else if (item.compare ("add_assign") == 0)
- {
- return ItemType::ADD_ASSIGN;
- }
- else if (item.compare ("sub_assign") == 0)
- {
- return ItemType::SUB_ASSIGN;
- }
- else if (item.compare ("mul_assign") == 0)
- {
- return ItemType::MUL_ASSIGN;
- }
- else if (item.compare ("div_assign") == 0)
- {
- return ItemType::DIV_ASSIGN;
- }
- else if (item.compare ("rem_assign") == 0)
- {
- return ItemType::REM_ASSIGN;
- }
- else if (item.compare ("bitand_assign") == 0)
- {
- return ItemType::BITAND_ASSIGN;
- }
- else if (item.compare ("bitor_assign") == 0)
- {
- return ItemType::BITOR_ASSIGN;
- }
- else if (item.compare ("bitxor_assign") == 0)
- {
- return ItemType::BITXOR_ASSIGN;
- }
- else if (item.compare ("shl_assign") == 0)
- {
- return ItemType::SHL_ASSIGN;
- }
- else if (item.compare ("shr_assign") == 0)
- {
- return ItemType::SHR_ASSIGN;
- }
- else if (item.compare ("deref") == 0)
- {
- return ItemType::DEREF;
- }
- else if (item.compare ("deref_mut") == 0)
- {
- return ItemType::DEREF_MUT;
- }
- else if (item.compare ("index") == 0)
- {
- return ItemType::INDEX;
- }
- else if (item.compare ("index_mut") == 0)
- {
- return ItemType::INDEX_MUT;
- }
- else if (item.compare ("RangeFull") == 0)
- {
- return ItemType::RANGE_FULL;
- }
- else if (item.compare ("Range") == 0)
- {
- return ItemType::RANGE;
- }
- else if (item.compare ("RangeFrom") == 0)
- {
- return ItemType::RANGE_FROM;
- }
- else if (item.compare ("RangeTo") == 0)
- {
- return ItemType::RANGE_TO;
- }
- else if (item.compare ("RangeInclusive") == 0)
- {
- return ItemType::RANGE_INCLUSIVE;
- }
- else if (item.compare ("RangeToInclusive") == 0)
- {
- return ItemType::RANGE_TO_INCLUSIVE;
- }
- else if (item.compare ("phantom_data") == 0)
- {
- return ItemType::PHANTOM_DATA;
- }
- else if (item.compare ("fn") == 0)
- {
- return ItemType::FN;
- }
- else if (item.compare ("fn_mut") == 0)
- {
- return ItemType::FN_MUT;
- }
- else if (item.compare ("fn_once") == 0)
- {
- return ItemType::FN_ONCE;
- }
- else if (item.compare ("fn_once_output") == 0)
- {
- return ItemType::FN_ONCE_OUTPUT;
- }
- else if (item.compare ("copy") == 0)
- {
- return ItemType::COPY;
- }
- else if (item.compare ("clone") == 0)
- {
- return ItemType::CLONE;
- }
- else if (item.compare ("sized") == 0)
- {
- return ItemType::SIZED;
- }
- else if (item.compare ("slice_alloc") == 0)
- {
- return ItemType::SLICE_ALLOC;
- }
- else if (item.compare ("slice_u8_alloc") == 0)
- {
- return ItemType::SLICE_U8_ALLOC;
- }
- else if (item.compare ("str_alloc") == 0)
- {
- return ItemType::STR_ALLOC;
- }
- else if (item.compare ("array") == 0)
- {
- return ItemType::ARRAY;
- }
- else if (item.compare ("bool") == 0)
- {
- return ItemType::BOOL;
- }
- else if (item.compare ("char") == 0)
- {
- return ItemType::CHAR;
- }
- else if (item.compare ("f32") == 0)
- {
- return ItemType::F32;
- }
- else if (item.compare ("f64") == 0)
- {
- return ItemType::F64;
- }
- else if (item.compare ("i8") == 0)
- {
- return ItemType::I8;
- }
- else if (item.compare ("i16") == 0)
- {
- return ItemType::I16;
- }
- else if (item.compare ("i32") == 0)
- {
- return ItemType::I32;
- }
- else if (item.compare ("i64") == 0)
- {
- return ItemType::I64;
- }
- else if (item.compare ("i128") == 0)
- {
- return ItemType::I128;
- }
- else if (item.compare ("isize") == 0)
- {
- return ItemType::ISIZE;
- }
- else if (item.compare ("u8") == 0)
- {
- return ItemType::U8;
- }
- else if (item.compare ("u16") == 0)
- {
- return ItemType::U16;
- }
- else if (item.compare ("u32") == 0)
- {
- return ItemType::U32;
- }
- else if (item.compare ("u64") == 0)
- {
- return ItemType::U64;
- }
- else if (item.compare ("u128") == 0)
- {
- return ItemType::U128;
- }
- else if (item.compare ("usize") == 0)
- {
- return ItemType::USIZE;
- }
- else if (item.compare ("const_ptr") == 0)
- {
- return ItemType::CONST_PTR;
- }
- else if (item.compare ("const_slice_ptr") == 0)
- {
- return ItemType::CONST_SLICE_PTR;
- }
- else if (item.compare ("mut_ptr") == 0)
- {
- return ItemType::MUT_PTR;
- }
- else if (item.compare ("mut_slice_ptr") == 0)
- {
- return ItemType::MUT_SLICE_PTR;
- }
- else if (item.compare ("slice_u8") == 0)
- {
- return ItemType::SLICE_U8;
- }
- else if (item.compare ("slice") == 0)
- {
- return ItemType::SLICE;
- }
- else if (item.compare ("str") == 0)
- {
- return ItemType::STR;
- }
- else if (item.compare ("f32_runtime") == 0)
- {
- return ItemType::F32_RUNTIME;
- }
- else if (item.compare ("f64_runtime") == 0)
- {
- return ItemType::F64_RUNTIME;
- }
-
- return ItemType::UNKNOWN;
- }
-
- static std::string ToString (ItemType type)
- {
- switch (type)
- {
- case ADD:
- return "add";
- case SUBTRACT:
- return "sub";
- case MULTIPLY:
- return "mul";
- case DIVIDE:
- return "div";
- case REMAINDER:
- return "rem";
- case BITAND:
- return "bitand";
- case BITOR:
- return "bitor";
- case BITXOR:
- return "bitxor";
- case SHL:
- return "shl";
- case SHR:
- return "shr";
- case NEGATION:
- return "neg";
- case NOT:
- return "not";
- case ADD_ASSIGN:
- return "add_assign";
- case SUB_ASSIGN:
- return "sub_assign";
- case MUL_ASSIGN:
- return "mul_assign";
- case DIV_ASSIGN:
- return "div_assign";
- case REM_ASSIGN:
- return "rem_assign";
- case BITAND_ASSIGN:
- return "bitand_assign";
- case BITOR_ASSIGN:
- return "bitor_assign";
- case BITXOR_ASSIGN:
- return "bitxor_assign";
- case SHL_ASSIGN:
- return "shl_assign";
- case SHR_ASSIGN:
- return "shr_assign";
- case DEREF:
- return "deref";
- case DEREF_MUT:
- return "deref_mut";
- case INDEX:
- return "index";
- case INDEX_MUT:
- return "index_mut";
- case RANGE_FULL:
- return "RangeFull";
- case RANGE:
- return "Range";
- case RANGE_FROM:
- return "RangeFrom";
- case RANGE_TO:
- return "RangeTo";
- case RANGE_INCLUSIVE:
- return "RangeInclusive";
- case RANGE_TO_INCLUSIVE:
- return "RangeToInclusive";
- case PHANTOM_DATA:
- return "phantom_data";
- case FN:
- return "fn";
- case FN_MUT:
- return "fn_mut";
- case FN_ONCE:
- return "fn_once";
- case FN_ONCE_OUTPUT:
- return "fn_once_output";
- case COPY:
- return "copy";
- case CLONE:
- return "clone";
- case SIZED:
- return "sized";
- case SLICE_ALLOC:
- return "slice_alloc";
- case SLICE_U8_ALLOC:
- return "slice_u8_alloc";
- case STR_ALLOC:
- return "str_alloc";
- case ARRAY:
- return "array";
- case BOOL:
- return "bool";
- case CHAR:
- return "char";
- case F32:
- return "f32";
- case F64:
- return "f64";
- case I8:
- return "i8";
- case I16:
- return "i16";
- case I32:
- return "i32";
- case I64:
- return "i64";
- case I128:
- return "i128";
- case ISIZE:
- return "isize";
- case U8:
- return "u8";
- case U16:
- return "u16";
- case U32:
- return "u32";
- case U64:
- return "u64";
- case U128:
- return "u128";
- case USIZE:
- return "usize";
- case CONST_PTR:
- return "const_ptr";
- case CONST_SLICE_PTR:
- return "const_slice_ptr";
- case MUT_PTR:
- return "mut_ptr";
- case MUT_SLICE_PTR:
- return "mut_slice_ptr";
- case SLICE_U8:
- return "slice_u8";
- case SLICE:
- return "slice";
- case STR:
- return "str";
- case F32_RUNTIME:
- return "f32_runtime";
- case F64_RUNTIME:
- return "f64_runtime";
-
- case UNKNOWN:
- return "<UNKNOWN>";
- }
- return "<UNKNOWN>";
- }
-
- static ItemType OperatorToLangItem (ArithmeticOrLogicalOperator op)
- {
- switch (op)
- {
- case ArithmeticOrLogicalOperator::ADD:
- return ItemType::ADD;
- case ArithmeticOrLogicalOperator::SUBTRACT:
- return ItemType::SUBTRACT;
- case ArithmeticOrLogicalOperator::MULTIPLY:
- return ItemType::MULTIPLY;
- case ArithmeticOrLogicalOperator::DIVIDE:
- return ItemType::DIVIDE;
- case ArithmeticOrLogicalOperator::MODULUS:
- return ItemType::REMAINDER;
- case ArithmeticOrLogicalOperator::BITWISE_AND:
- return ItemType::BITAND;
- case ArithmeticOrLogicalOperator::BITWISE_OR:
- return ItemType::BITOR;
- case ArithmeticOrLogicalOperator::BITWISE_XOR:
- return ItemType::BITXOR;
- case ArithmeticOrLogicalOperator::LEFT_SHIFT:
- return ItemType::SHL;
- case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
- return ItemType::SHR;
- }
- return ItemType::UNKNOWN;
- }
+ static const BiMap<std::string, ItemType> lang_items;
+ static tl::optional<ItemType> Parse (const std::string &item);
+ static std::string ToString (ItemType type);
+ static ItemType OperatorToLangItem (ArithmeticOrLogicalOperator op);
static ItemType
- CompoundAssignmentOperatorToLangItem (ArithmeticOrLogicalOperator op)
- {
- switch (op)
- {
- case ArithmeticOrLogicalOperator::ADD:
- return ItemType::ADD_ASSIGN;
- case ArithmeticOrLogicalOperator::SUBTRACT:
- return ItemType::SUB_ASSIGN;
- case ArithmeticOrLogicalOperator::MULTIPLY:
- return ItemType::MUL_ASSIGN;
- case ArithmeticOrLogicalOperator::DIVIDE:
- return ItemType::DIV_ASSIGN;
- case ArithmeticOrLogicalOperator::MODULUS:
- return ItemType::REM_ASSIGN;
- case ArithmeticOrLogicalOperator::BITWISE_AND:
- return ItemType::BITAND_ASSIGN;
- case ArithmeticOrLogicalOperator::BITWISE_OR:
- return ItemType::BITOR_ASSIGN;
- case ArithmeticOrLogicalOperator::BITWISE_XOR:
- return ItemType::BITXOR_ASSIGN;
- case ArithmeticOrLogicalOperator::LEFT_SHIFT:
- return ItemType::SHL_ASSIGN;
- case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
- return ItemType::SHR_ASSIGN;
- }
- return ItemType::UNKNOWN;
- }
-
- static ItemType NegationOperatorToLangItem (NegationOperator op)
- {
- switch (op)
- {
- case NegationOperator::NEGATE:
- return ItemType::NEGATION;
- case NegationOperator::NOT:
- return ItemType::NOT;
- }
- return ItemType::UNKNOWN;
- }
+ CompoundAssignmentOperatorToLangItem (ArithmeticOrLogicalOperator op);
+ static ItemType NegationOperatorToLangItem (NegationOperator op);
};
} // namespace Analysis
--
2.45.2
next prev parent reply other threads:[~2024-08-01 14:58 UTC|newest]
Thread overview: 130+ messages / expand[flat|nested] mbox.gz Atom feed top
2024-08-01 14:55 [PATCH 001/125] Rust: Make 'tree'-level 'MAIN_NAME_P' work Arthur Cohen
2024-08-01 14:55 ` [PATCH 002/125] gccrs: Fix false positive for top-level AltPattern Arthur Cohen
2024-08-01 14:55 ` [PATCH 003/125] gccrs: minor cleanup in langhook.type_for_mode Arthur Cohen
2024-08-01 14:56 ` [PATCH 004/125] gccrs: fmt: Start working on format_args!() parser Arthur Cohen
2024-08-01 14:56 ` [PATCH 005/125] gccrs: libgrust: Add format_parser library Arthur Cohen
2024-08-05 8:18 ` Don't override 'LIBS' if '--enable-languages=rust'; use 'CRAB1_LIBS' (was: [PATCH 005/125] gccrs: libgrust: Add format_parser library) Thomas Schwinge
2024-11-23 20:09 ` Rust: Work around 'error[E0658]: `let...else` statements are unstable' " Thomas Schwinge
2024-11-25 10:24 ` Rust: Work around 'error[E0658]: `let...else` statements are unstable' Arthur Cohen
2024-08-01 14:56 ` [PATCH 006/125] gccrs: Add 'gcc/rust/Make-lang.in:LIBFORMAT_PARSER' Arthur Cohen
2024-08-05 8:45 ` Inline 'gcc/rust/Make-lang.in:RUST_LIBDEPS' (was: [PATCH 006/125] gccrs: Add 'gcc/rust/Make-lang.in:LIBFORMAT_PARSER') Thomas Schwinge
2024-08-01 14:56 ` [PATCH 007/125] gccrs: libgrust: Vendor Rust dependencies Arthur Cohen
2024-08-01 14:56 ` [PATCH 008/125] Rust: Don't cache 'libformat_parser.a' Arthur Cohen
2024-08-01 14:56 ` [PATCH 009/125] Rust: Move 'libformat_parser' build into the GCC build directory Arthur Cohen
2024-08-01 14:56 ` [PATCH 010/125] Rust: Move 'libformat_parser' build into libgrust Arthur Cohen
2024-08-01 14:56 ` [PATCH 011/125] gccrs: libformat_parser: Add FFI safe interface Arthur Cohen
2024-08-01 14:56 ` [PATCH 012/125] gccrs: libformat_parser: Start experimenting with cbindgen Arthur Cohen
2024-08-01 14:56 ` [PATCH 013/125] gccrs: libformat_parser: Update header and remove old interface Arthur Cohen
2024-08-01 14:56 ` [PATCH 014/125] gccrs: libformat_parser: Send boxed values across FFI properly Arthur Cohen
2024-08-01 14:56 ` [PATCH 015/125] gccrs: format_args: Parse format string properly Arthur Cohen
2024-08-01 14:56 ` [PATCH 016/125] gccrs: format_args: Parse entire token invocation Arthur Cohen
2024-08-01 14:56 ` [PATCH 017/125] gccrs: rust-fmt: Store parsed string in Pieces struct Arthur Cohen
2024-08-01 14:56 ` [PATCH 018/125] gccrs: libformat_parser: Fix Rust warnings Arthur Cohen
2024-08-01 14:56 ` [PATCH 019/125] gccrs: format-parser: Add `is_some_and` method for Option<T> Arthur Cohen
2024-08-01 14:56 ` [PATCH 020/125] gccrs: Adjust error checks to match name resolution 2.0 Arthur Cohen
2024-08-01 14:56 ` [PATCH 021/125] gccrs: Fix small FixMe task in rust macro builtins Arthur Cohen
2024-08-01 14:56 ` Arthur Cohen [this message]
2024-08-01 14:56 ` [PATCH 023/125] gccrs: lang-items: Make lang items enum stronger, rename class, cleanup ns Arthur Cohen
2024-08-01 14:56 ` [PATCH 024/125] gccrs: extern-types: Declare external types in name resolver Arthur Cohen
2024-08-01 14:56 ` [PATCH 025/125] gccrs: hir: Add ExternalTypeItem node Arthur Cohen
2024-08-01 14:56 ` [PATCH 026/125] gccrs: extern-types: Lower to HIR::ExternalTypeItem properly Arthur Cohen
2024-08-01 14:56 ` [PATCH 027/125] gccrs: Make DefaultResolver visit more of the AST Arthur Cohen
2024-08-01 14:56 ` [PATCH 028/125] gccrs: ast: Add base nodes for FormatArgs Arthur Cohen
2024-08-01 14:56 ` [PATCH 029/125] gccrs: macro-builtins: Add newline generic format_args!() handler Arthur Cohen
2024-08-01 14:56 ` [PATCH 030/125] gccrs: parser: Add peek(n) method to parser Arthur Cohen
2024-08-01 14:56 ` [PATCH 031/125] gccrs: format-args: Fix Rust interface and add input parsing Arthur Cohen
2024-08-01 14:56 ` [PATCH 032/125] gccrs: lower: Add base for lowering FormatArgs nodes Arthur Cohen
2024-08-01 14:56 ` [PATCH 033/125] gccrs: format-args: Add documentation for future expansion of function Arthur Cohen
2024-08-01 14:56 ` [PATCH 034/125] gccrs: Add error emitting when we can't resolve id expr Arthur Cohen
2024-08-01 14:56 ` [PATCH 035/125] gccrs: Add curly brackets, formatted clang Arthur Cohen
2024-08-01 14:56 ` [PATCH 036/125] gccrs: Ensure TupleStructPattern and TuplePattern have items Arthur Cohen
2024-08-01 14:56 ` [PATCH 037/125] gccrs: Clean BiMap to use tl::optional for lookups Arthur Cohen
2024-08-01 14:56 ` [PATCH 038/125] gccrs: Add support for external functions Arthur Cohen
2024-08-01 14:56 ` [PATCH 039/125] gccrs: Add get_pattern_kind to Pattern Arthur Cohen
2024-08-01 14:56 ` [PATCH 040/125] gccrs: Unify ASTValidation::visit for ExternalFunctionItem and Function Arthur Cohen
2024-08-01 14:56 ` [PATCH 041/125] gccrs: Update resolver to use `AST::Function` instead of `AST::ExternalFunctionItem` Arthur Cohen
2024-08-01 14:56 ` [PATCH 042/125] gccrs: Remove dead code associated with `AST::ExternalFunctionItem` Arthur Cohen
2024-08-01 14:56 ` [PATCH 043/125] gccrs: Placate clang-format re 'gcc/rust/backend/rust-tree.cc' Arthur Cohen
2024-08-01 14:56 ` [PATCH 044/125] gccrs: Replace reference to unique pointer with reference Arthur Cohen
2024-08-01 14:56 ` [PATCH 045/125] gccrs: Replace unique_ptr references with references Arthur Cohen
2024-08-01 14:56 ` [PATCH 046/125] gccrs: macro: Use MacroInvocation's node_id in ExternalItem constructor Arthur Cohen
2024-08-01 14:56 ` [PATCH 047/125] gccrs: format-args: Add base for expanding FormatArgs nodes Arthur Cohen
2024-08-01 14:56 ` [PATCH 048/125] gccrs: format-args: Start storing string in Rust memory Arthur Cohen
2024-11-23 20:17 ` Rust: Work around 'error[E0599]: no method named `leak` found for struct `std::string::String` in the current scope' (was: [PATCH 048/125] gccrs: format-args: Start storing string in Rust memory) Thomas Schwinge
2024-08-01 14:56 ` [PATCH 049/125] gccrs: format-args: Add basic expansion of unnamed Display::fmt arguments Arthur Cohen
2024-08-01 14:56 ` [PATCH 050/125] gccrs: format-args: Add basic test case Arthur Cohen
2024-08-01 14:56 ` [PATCH 051/125] gccrs: format-args: Only pass the format string to the parser Arthur Cohen
2024-08-01 14:56 ` [PATCH 052/125] gccrs: TyTy: add common SubstitutionRef API Arthur Cohen
2024-08-01 14:56 ` [PATCH 053/125] gccrs: TyTy: Variance analysis module Arthur Cohen
2024-08-01 14:56 ` [PATCH 054/125] gccrs: TyTy: Collect variance info from types Arthur Cohen
2024-08-01 14:56 ` [PATCH 055/125] gccrs: Store visibility properly in ExternalTypeItem Arthur Cohen
2024-08-01 14:56 ` [PATCH 056/125] gccrs: Fix typo Arthur Cohen
2024-08-01 14:56 ` [PATCH 057/125] gccrs: Split up rust-macro-builtins.cc Arthur Cohen
2024-08-01 14:56 ` [PATCH 058/125] gccrs: Placate clang-format re 'gcc/rust/lex/rust-lex.cc' Arthur Cohen
2024-08-01 14:56 ` [PATCH 059/125] gccrs: nr2.0: Add new ImmutableNameResolutionCtx class Arthur Cohen
2024-08-01 14:56 ` [PATCH 060/125] gccrs: sesh: Add late name resolution 2.0 Arthur Cohen
2024-08-01 14:56 ` [PATCH 061/125] gccrs: session-manager: Dump name resolution pass Arthur Cohen
2024-08-01 14:56 ` [PATCH 062/125] gccrs: session manager: Init Immutable name resolver Arthur Cohen
2024-08-01 14:56 ` [PATCH 063/125] gccrs: nr2.0: Add lookup of resolved nodes Arthur Cohen
2024-08-01 14:57 ` [PATCH 064/125] gccrs: typecheck: Start using nr2.0 properly Arthur Cohen
2024-08-01 14:57 ` [PATCH 065/125] gccrs: backend: Use new name resolver where necessary Arthur Cohen
2024-08-01 14:57 ` [PATCH 066/125] gccrs: nr2.0: Start using newtype pattern for Usage and Declaration Arthur Cohen
2024-08-01 14:57 ` [PATCH 067/125] gccrs: late: Setup builtin types properly, change Rib API Arthur Cohen
2024-08-01 14:57 ` [PATCH 068/125] gccrs: Fix duplicate detection Arthur Cohen
2024-08-01 14:57 ` [PATCH 069/125] gccrs: Emit error on identical use declarations Arthur Cohen
2024-08-01 14:57 ` [PATCH 070/125] gccrs: Change error message on unresolved import Arthur Cohen
2024-08-01 14:57 ` [PATCH 071/125] gccrs: Prevent error emission on resolver reentry Arthur Cohen
2024-08-01 14:57 ` [PATCH 072/125] gccrs: late: Add bool builtin type Arthur Cohen
2024-08-01 14:57 ` [PATCH 073/125] gccrs: Add modules to type namespace Arthur Cohen
2024-08-01 14:57 ` [PATCH 074/125] gccrs: Add name resolution for on globbing use decl Arthur Cohen
2024-08-01 14:57 ` [PATCH 075/125] gccrs: Shape up name resolver for normal direct calls Arthur Cohen
2024-08-01 14:57 ` [PATCH 076/125] gccrs: Add call to globbing visitor Arthur Cohen
2024-08-01 14:57 ` [PATCH 077/125] gccrs: Make globbing definition shadowable by default Arthur Cohen
2024-08-01 14:57 ` [PATCH 078/125] gccrs: Add support for ambiguous use declarations Arthur Cohen
2024-08-01 14:57 ` [PATCH 079/125] gccrs: Add tuple struct constructor to value namespace Arthur Cohen
2024-08-01 14:57 ` [PATCH 080/125] gccrs: Change error message to match test Arthur Cohen
2024-08-01 14:57 ` [PATCH 081/125] gccrs: Visit function return type in default resolver Arthur Cohen
2024-08-01 14:57 ` [PATCH 082/125] gccrs: Visit constant item " Arthur Cohen
2024-08-01 14:57 ` [PATCH 083/125] gccrs: Raw pointer type visitor didn't require overload Arthur Cohen
2024-08-01 14:57 ` [PATCH 084/125] gccrs: Values shall be inserted in the value namespace Arthur Cohen
2024-08-01 14:57 ` [PATCH 085/125] gccrs: Unit struct constructor shall be resolved Arthur Cohen
2024-08-01 14:57 ` [PATCH 086/125] gccrs: Add tuple struct to the type namespace Arthur Cohen
2024-08-01 14:57 ` [PATCH 087/125] gccrs: Change enum namespace from value to type Arthur Cohen
2024-08-01 14:57 ` [PATCH 088/125] gccrs: Struct are types, not values Arthur Cohen
2024-08-01 14:57 ` [PATCH 089/125] gccrs: Add constant identifiers to the value namespace Arthur Cohen
2024-08-01 14:57 ` [PATCH 090/125] gccrs: Remove extern block scoping Arthur Cohen
2024-08-01 14:57 ` [PATCH 091/125] gccrs: Remove unsafe block empty visit function Arthur Cohen
2024-08-01 14:57 ` [PATCH 092/125] gccrs: Use new name resolver to compile constant items Arthur Cohen
2024-08-01 14:57 ` [PATCH 093/125] gccrs: Reinject Self parameter in new resolver Arthur Cohen
2024-08-01 14:57 ` [PATCH 094/125] gccrs: Update assignment operator with cratenum Arthur Cohen
2024-08-01 14:57 ` [PATCH 095/125] gccrs: Prevent getting immutable context with classic nr Arthur Cohen
2024-08-01 14:57 ` [PATCH 096/125] gccrs: Fix quoted string format Arthur Cohen
2024-08-01 14:57 ` [PATCH 097/125] gccrs: Add mappings for struct base and struct fields Arthur Cohen
2024-08-01 14:57 ` [PATCH 098/125] gccrs: Fix use rebind name resolution Arthur Cohen
2024-08-01 14:57 ` [PATCH 099/125] gccrs: compile: resolve-path-ref: properly resolve nodeId with nr2.0 Arthur Cohen
2024-08-01 14:57 ` [PATCH 100/125] gccrs: nr2.0: Add new test cases Arthur Cohen
2024-08-01 14:57 ` [PATCH 101/125] gccrs: Add globbing name resolution 2.0 test Arthur Cohen
2024-08-01 14:57 ` [PATCH 102/125] gccrs: Change dfs function return type to support gcc 4.8 Arthur Cohen
2024-08-01 14:57 ` [PATCH 103/125] gccrs: Improve parsing of raw byte string literals Arthur Cohen
2024-08-01 14:57 ` [PATCH 104/125] gccrs: Recognize rustc_deprecated as a builtin attribute Arthur Cohen
2024-08-01 14:57 ` [PATCH 105/125] gccrs: Recognize unstable " Arthur Cohen
2024-08-01 14:57 ` [PATCH 106/125] gccrs: Avoid parsing const unsafe/extern functions as async Arthur Cohen
2024-08-01 14:57 ` [PATCH 107/125] gccrs: Improve parsing of raw string literals Arthur Cohen
2024-08-01 14:57 ` [PATCH 108/125] gccrs: raw-strings: Remove dg-excess-error directive Arthur Cohen
2024-08-01 14:57 ` [PATCH 109/125] gccrs: unify: Always coerce `!` to the target type Arthur Cohen
2024-08-01 14:57 ` [PATCH 110/125] gccrs: borrowck: Use rust-system.h Arthur Cohen
2024-08-01 14:57 ` [PATCH 111/125] gccrs: borrowck: Unify BIR terminilogy (node->statement) Arthur Cohen
2024-08-01 14:57 ` [PATCH 112/125] gccrs: borrowck: BIR: use callable API Arthur Cohen
2024-08-01 14:57 ` [PATCH 113/125] gccrs: borrowck: BIR: Place tree traverse API Arthur Cohen
2024-08-01 14:57 ` [PATCH 114/125] gccrs: borrowck: BIR: scope handling Arthur Cohen
2024-08-01 14:57 ` [PATCH 115/125] gccrs: borrowck: BIR: emit moves Arthur Cohen
2024-08-01 14:57 ` [PATCH 116/125] gccrs: borrowck: BIR: make BIR visitor const Arthur Cohen
2024-08-01 14:57 ` [PATCH 117/125] gccrs: borrowck: Polonius FFI Arthur Cohen
2024-08-01 14:57 ` [PATCH 118/125] gccrs: borrowck: Free region representation Arthur Cohen
2024-08-01 14:57 ` [PATCH 119/125] gccrs: borrowck: extract regions from types using VA Arthur Cohen
2024-08-01 14:57 ` [PATCH 120/125] gccrs: borrowck: Regions in BIR Arthur Cohen
2024-08-01 14:57 ` [PATCH 121/125] gccrs: borrowck: Fact collector Arthur Cohen
2024-08-01 14:57 ` [PATCH 122/125] gccrs: borrowck: Remove block braces to satisfy GNU style Arthur Cohen
2024-08-01 14:57 ` [PATCH 123/125] gccrs: borrowck: Bump copyright notice Arthur Cohen
2024-08-01 14:58 ` [PATCH 124/125] gccrs: Visit type during resolution of inherent impl Arthur Cohen
2024-08-01 14:58 ` [PATCH 125/125] gccrs: Add a test for inherent impl type name resolve Arthur Cohen
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20240801145809.366388-24-arthur.cohen@embecosm.com \
--to=arthur.cohen@embecosm.com \
--cc=gcc-patches@gcc.gnu.org \
--cc=gcc-rust@gcc.gnu.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
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).