diff options
Diffstat (limited to 'gcc')
| -rw-r--r-- | gcc/rust/Make-lang.in | 1 | ||||
| -rw-r--r-- | gcc/rust/hir/rust-ast-lower-base.h | 17 | ||||
| -rw-r--r-- | gcc/rust/hir/rust-ast-lower-item.h | 4 | ||||
| -rw-r--r-- | gcc/rust/hir/rust-ast-lower.cc | 64 | ||||
| -rw-r--r-- | gcc/rust/typecheck/rust-hir-trait-resolve.h | 25 | ||||
| -rw-r--r-- | gcc/rust/util/rust-attributes.cc | 61 | ||||
| -rw-r--r-- | gcc/rust/util/rust-attributes.h | 70 | ||||
| -rw-r--r-- | gcc/rust/util/rust-hir-map.h | 270 | ||||
| -rw-r--r-- | gcc/rust/util/rust-lang-item.h | 334 |
9 files changed, 551 insertions, 295 deletions
diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in index 739b27d..080b9dd 100644 --- a/gcc/rust/Make-lang.in +++ b/gcc/rust/Make-lang.in @@ -77,6 +77,7 @@ GRS_OBJS = \ rust/rust-macro-invoc-lexer.o \ rust/rust-hir-full-test.o \ rust/rust-hir-map.o \ + rust/rust-attributes.o \ rust/rust-abi.o \ rust/rust-ast-lower.o \ rust/rust-ast-lower-pattern.o \ diff --git a/gcc/rust/hir/rust-ast-lower-base.h b/gcc/rust/hir/rust-ast-lower-base.h index 5a54b30..9eb9300 100644 --- a/gcc/rust/hir/rust-ast-lower-base.h +++ b/gcc/rust/hir/rust-ast-lower-base.h @@ -24,6 +24,7 @@ #include "rust-ast-visitor.h" #include "rust-hir-map.h" #include "rust-hir-full.h" +#include "rust-attributes.h" namespace Rust { namespace HIR { @@ -230,9 +231,13 @@ public: virtual void visit (AST::BareFunctionType &type) {} protected: - ASTLoweringBase () : mappings (Analysis::Mappings::get ()) {} + ASTLoweringBase () + : mappings (Analysis::Mappings::get ()), + attr_mappings (Analysis::BuiltinAttributeMappings::get ()) + {} Analysis::Mappings *mappings; + Analysis::BuiltinAttributeMappings *attr_mappings; HIR::Lifetime lower_lifetime (AST::Lifetime &lifetime) { @@ -281,6 +286,16 @@ protected: HIR::FunctionQualifiers lower_qualifiers (const AST::FunctionQualifiers &qualifiers); + + void handle_outer_attributes (const HIR::Item &item); + + void handle_lang_item_attribute (const HIR::Item &item, + const AST::Attribute &attr); + + bool is_known_attribute (const std::string &attribute_path) const; + + bool + attribute_handled_in_another_pass (const std::string &attribute_path) const; }; } // namespace HIR diff --git a/gcc/rust/hir/rust-ast-lower-item.h b/gcc/rust/hir/rust-ast-lower-item.h index 30bd896..55c8e8a 100644 --- a/gcc/rust/hir/rust-ast-lower-item.h +++ b/gcc/rust/hir/rust-ast-lower-item.h @@ -44,6 +44,10 @@ public: { ASTLoweringItem resolver; item->accept_vis (resolver); + + if (resolver.translated != nullptr) + resolver.handle_outer_attributes (*resolver.translated); + return resolver.translated; } diff --git a/gcc/rust/hir/rust-ast-lower.cc b/gcc/rust/hir/rust-ast-lower.cc index aac6ee5..8062f2f 100644 --- a/gcc/rust/hir/rust-ast-lower.cc +++ b/gcc/rust/hir/rust-ast-lower.cc @@ -609,5 +609,69 @@ ASTLoweringBase::lower_qualifiers (const AST::FunctionQualifiers &qualifiers) has_extern, extern_abi); } +void +ASTLoweringBase::handle_outer_attributes (const HIR::Item &item) +{ + for (const auto &attr : item.get_outer_attrs ()) + { + const auto &str_path = attr.get_path ().as_string (); + if (!is_known_attribute (str_path)) + { + rust_error_at (attr.get_locus (), "unknown attribute"); + continue; + } + + bool is_lang_item = str_path.compare ("lang") == 0 + && attr.has_attr_input () + && attr.get_attr_input ().get_attr_input_type () + == AST::AttrInput::AttrInputType::LITERAL; + + if (is_lang_item) + handle_lang_item_attribute (item, attr); + else if (!attribute_handled_in_another_pass (str_path)) + { + rust_error_at (attr.get_locus (), "unhandled attribute: [%s]", + attr.get_path ().as_string ().c_str ()); + } + } +} + +void +ASTLoweringBase::handle_lang_item_attribute (const HIR::Item &item, + const AST::Attribute &attr) +{ + 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 ()); +} + +bool +ASTLoweringBase::is_known_attribute (const std::string &attribute_path) const +{ + const auto &lookup = attr_mappings->lookup_builtin (attribute_path); + return !lookup.is_error (); +} + +bool +ASTLoweringBase::attribute_handled_in_another_pass ( + const std::string &attribute_path) const +{ + const auto &lookup = attr_mappings->lookup_builtin (attribute_path); + if (lookup.is_error ()) + return false; + + if (lookup.handler == Analysis::CompilerPass::UNKNOWN) + return false; + + return lookup.handler != Analysis::CompilerPass::HIR_LOWERING; +} + } // namespace HIR } // namespace Rust diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.h b/gcc/rust/typecheck/rust-hir-trait-resolve.h index 7ab344e..d8df481 100644 --- a/gcc/rust/typecheck/rust-hir-trait-resolve.h +++ b/gcc/rust/typecheck/rust-hir-trait-resolve.h @@ -207,31 +207,6 @@ private: // loop of trying to resolve traits as required by the types tref->on_resolved (); - // does this have any lang-item attributes? - for (auto &attr : trait_reference->get_outer_attrs ()) - { - bool is_lang_item = attr.get_path ().as_string ().compare ("lang") == 0 - && attr.has_attr_input () - && attr.get_attr_input ().get_attr_input_type () - == AST::AttrInput::AttrInputType::LITERAL; - if (is_lang_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 tref; - } - mappings->insert_lang_item ( - lang_item_type, trait_reference->get_mappings ().get_defid ()); - } - } - return tref; } diff --git a/gcc/rust/util/rust-attributes.cc b/gcc/rust/util/rust-attributes.cc new file mode 100644 index 0000000..3809ad7 --- /dev/null +++ b/gcc/rust/util/rust-attributes.cc @@ -0,0 +1,61 @@ +// 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 +// <http://www.gnu.org/licenses/>. + +#include "rust-attributes.h" + +namespace Rust { +namespace Analysis { + +// https://doc.rust-lang.org/stable/nightly-rustc/src/rustc_feature/builtin_attrs.rs.html#256 +static const BuiltinAttrDefinition __definitions[] = { + {"inline", CODE_GENERATION}, {"cfg", EXPANSION}, {"cfg_attr", EXPANSION}, + {"allow", STATIC_ANALYSIS}, {"lang", HIR_LOWERING}, +}; + +BuiltinAttributeMappings * +BuiltinAttributeMappings::get () +{ + static BuiltinAttributeMappings *instance = nullptr; + if (instance == nullptr) + instance = new BuiltinAttributeMappings (); + + return instance; +} + +const BuiltinAttrDefinition & +BuiltinAttributeMappings::lookup_builtin (const std::string &attr_name) const +{ + auto it = mappings.find (attr_name); + if (it == mappings.end ()) + return BuiltinAttrDefinition::error_node (); + + return it->second; +} + +BuiltinAttributeMappings::BuiltinAttributeMappings () +{ + size_t ndefinitions = sizeof (__definitions) / sizeof (BuiltinAttrDefinition); + for (size_t i = 0; i < ndefinitions; i++) + { + const BuiltinAttrDefinition &def = __definitions[i]; + mappings.insert ({def.name, def}); + } +} + +} // namespace Analysis +} // namespace Rust diff --git a/gcc/rust/util/rust-attributes.h b/gcc/rust/util/rust-attributes.h new file mode 100644 index 0000000..6c2063c7 --- /dev/null +++ b/gcc/rust/util/rust-attributes.h @@ -0,0 +1,70 @@ +// 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 +// <http://www.gnu.org/licenses/>. + +#include "rust-system.h" + +namespace Rust { +namespace Analysis { + +enum CompilerPass +{ + UNKNOWN, + + EXPANSION, + NAME_RESOLUTION, + HIR_LOWERING, + TYPE_CHECK, + STATIC_ANALYSIS, + CODE_GENERATION +}; + +struct BuiltinAttrDefinition +{ + std::string name; + CompilerPass handler; + + static BuiltinAttrDefinition get_error () + { + return BuiltinAttrDefinition{"", UNKNOWN}; + } + + static BuiltinAttrDefinition &error_node () + { + static BuiltinAttrDefinition error_node = get_error (); + return error_node; + } + + bool is_error () const { return name.empty (); } +}; + +class BuiltinAttributeMappings +{ +public: + static BuiltinAttributeMappings *get (); + + const BuiltinAttrDefinition & + lookup_builtin (const std::string &attr_name) const; + +private: + BuiltinAttributeMappings (); + + std::map<std::string, const BuiltinAttrDefinition> mappings; +}; + +} // namespace Analysis +} // namespace Rust diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index 799351b..9bac328 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -25,279 +25,11 @@ #include "rust-canonical-path.h" #include "rust-ast-full-decls.h" #include "rust-hir-full-decls.h" -#include "operator.h" +#include "rust-lang-item.h" namespace Rust { namespace Analysis { -// https://github.com/rust-lang/rust/blob/master/library/core/src/ops/arith.rs -class RustLangItem -{ -public: - enum ItemType - { - ADD, - SUBTRACT, - MULTIPLY, - DIVIDE, - REMAINDER, - BITAND, - BITOR, - BITXOR, - SHL, - SHR, - - NEGATION, - NOT, - - ADD_ASSIGN, - SUB_ASSIGN, - MUL_ASSIGN, - DIV_ASSIGN, - REM_ASSIGN, - BITAND_ASSIGN, - BITOR_ASSIGN, - BITXOR_ASSIGN, - SHL_ASSIGN, - SHR_ASSIGN, - - DEREF, - DEREF_MUT, - - 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; - } - - 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 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 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; - } -}; - class NodeMapping { public: diff --git a/gcc/rust/util/rust-lang-item.h b/gcc/rust/util/rust-lang-item.h new file mode 100644 index 0000000..da200e7 --- /dev/null +++ b/gcc/rust/util/rust-lang-item.h @@ -0,0 +1,334 @@ +// 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 +// <http://www.gnu.org/licenses/>. + +#include "rust-system.h" +#include "operator.h" + +namespace Rust { +namespace Analysis { + +// https://github.com/rust-lang/rust/blob/master/library/core/src/ops/arith.rs +class RustLangItem +{ +public: + enum ItemType + { + ADD, + SUBTRACT, + MULTIPLY, + DIVIDE, + REMAINDER, + BITAND, + BITOR, + BITXOR, + SHL, + SHR, + + NEGATION, + NOT, + + ADD_ASSIGN, + SUB_ASSIGN, + MUL_ASSIGN, + DIV_ASSIGN, + REM_ASSIGN, + BITAND_ASSIGN, + BITOR_ASSIGN, + BITXOR_ASSIGN, + SHL_ASSIGN, + SHR_ASSIGN, + + DEREF, + DEREF_MUT, + + // https://github.com/rust-lang/rust/blob/master/library/core/src/ops/range.rs + RANGE_FULL, + RANGE, + RANGE_FROM, + RANGE_TO, + RANGE_INCLUSIVE, + RANGE_TO_INCLUSIVE, + + 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 ("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; + } + + 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 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 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 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; + } +}; + +} // namespace Analysis +} // namespace Rust |