From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-lf1-x133.google.com (mail-lf1-x133.google.com [IPv6:2a00:1450:4864:20::133]) by sourceware.org (Postfix) with ESMTPS id C4CB8385DDFE for ; Thu, 1 Aug 2024 14:58:50 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org C4CB8385DDFE Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=embecosm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=embecosm.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org C4CB8385DDFE Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::133 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1722524345; cv=none; b=UyJif6EzSv6Xt3U8DEtRwl0KBBRhUQyjcTOFmoEjsSO5MvZJfir9RE6wTKOs8niefu4/3G4/f+wkK2f/EuAR7vZymvxsIEzgee3GE4LmVJmU3wNhaV6nR7kgaFr33oaiYhQWsuUDjCw0E+1LYCDPDDe9GS8JqwklxAkUjrL8KvY= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1722524345; c=relaxed/simple; bh=GVAYo4EOX9Nm7Y+uTpUOgboAMRnQRSTYWei2apMvuKo=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=YKMMNeO1n988y3tPzSLGHyGPdLg473shLTLJvTpK4sOFV2MclAxioeH4MuLuaWEY0lj2hzHQyk1UHfgvK8ewfVmdQcWlg3pcTvzWR690G0UW1s6PkRH5WUIJl6+1VqlRPEncRP1Hex+Ltp98AYYTNYHcZ4ioaQgGCP6p/e3i5nA= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-lf1-x133.google.com with SMTP id 2adb3069b0e04-52efc89dbedso8924117e87.3 for ; Thu, 01 Aug 2024 07:58:50 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=embecosm.com; s=google; t=1722524329; x=1723129129; darn=gcc.gnu.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=kqMBrJRj6KbUNSPS4xF+ng9QhAkogqksZgmg4y4Rr3c=; b=KhmZDMmHNmFk0e/8YUGoALCpKt9mBb0CzdkG71eT0GVAFt0Pe5Q+fhxyXMezdbFFv6 znUZgzZ5W2k5KUKfeY9Pgl8gBLp5oC/749lscqBagll5xnk30lt8aOGFthPHj79LB394 3/ISTEeMJU+QuSEbKp20f4080+dalLabm5wiwYH2NhE+7zGS4ufcN1rxeoEcW0HIybzP FMyihn5zLs20J7vyC6N/B7obdh2JeuG1sUIT5WKqL10X+s2FfT9ct63s7M9+SV575HVn WuCYTLJ8gLrjs7J4v7yzzANHMBD90SEhNDzyQkV8vYMBRshBPMzDct5e8e/uxr/nWjN+ 60ng== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1722524329; x=1723129129; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=kqMBrJRj6KbUNSPS4xF+ng9QhAkogqksZgmg4y4Rr3c=; b=cOM9LR67XRblIvPyrKcWTFbym9sLge1NWmUPNvAAduRqGa8GOAg+7BcqSR4++Mcrg6 D8OhMi3S2EDK5jR2+xQ3qh2x5qfax+pVfiOHac0VEBa6JgwXMushpJwBukofY7Slwl42 zLsVyETYoTZoBk36uxQAuulkRdA50Y3UT1UjAU3T4bbEMloVWqECC4koNmFPQW7IsqRW ckpY+2wxmnVn/CepENulQ34KbI0loqwmXX1MRxW7jI2WIqoT/t2j5YMM+MXHCSidDcV1 7sqCCAEBKcD3T5dvMOSsQx7k6NBGa7AZpEloJ5XlLuSaxk9N619isQjq4G6m90hqigXc Crtw== X-Gm-Message-State: AOJu0Yy2kR3S0Rc1g69E1zi8eNJf/rMiF7mGtjXYSyhTdUnPmxy3EGje AyPhkfWAj1rxQ8MCL1wUB3++mt6/cx0LQmkRKUfVR1t3CmEgyaR3bLPkdjHp/gBYqexI4iajZ+x b1uFM X-Google-Smtp-Source: AGHT+IH65J3dboyi2QKAtPaEIywmfMDRIWWd+QlkadGV6xBq9PBvf+ADd2D/nh0TOLwDOgSMT64ygw== X-Received: by 2002:a05:6512:6c8:b0:52f:3ba9:3bfb with SMTP id 2adb3069b0e04-530bb36b7efmr128566e87.6.1722524328541; Thu, 01 Aug 2024 07:58:48 -0700 (PDT) Received: from platypus.lan ([2a04:cec2:9:dc84:3622:6733:ff49:ee91]) by smtp.gmail.com with ESMTPSA id 4fb4d7f45d1cf-5ac63590592sm10252456a12.25.2024.08.01.07.58.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 01 Aug 2024 07:58:48 -0700 (PDT) From: Arthur Cohen To: gcc-patches@gcc.gnu.org Cc: gcc-rust@gcc.gnu.org, Arthur Cohen Subject: [PATCH 022/125] gccrs: lang-items: Cleanup parsing and lookups of lang items. Date: Thu, 1 Aug 2024 16:56:18 +0200 Message-ID: <20240801145809.366388-24-arthur.cohen@embecosm.com> X-Mailer: git-send-email 2.45.2 In-Reply-To: <20240801145809.366388-2-arthur.cohen@embecosm.com> References: <20240801145809.366388-2-arthur.cohen@embecosm.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Spam-Status: No, score=-14.0 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: 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 (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 +// . + +#include "rust-lang-item.h" +#include "rust-system.h" + +namespace Rust { +namespace Analysis { + +const BiMap + 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::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 ""; - } - return ""; - } - - 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 lang_items; + static tl::optional 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