From patchwork Thu Aug 1 14:56:19 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Arthur Cohen X-Patchwork-Id: 1967757 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@legolas.ozlabs.org Authentication-Results: legolas.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=embecosm.com header.i=@embecosm.com header.a=rsa-sha256 header.s=google header.b=MHOm3bJY; dkim-atps=neutral Authentication-Results: legolas.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=2620:52:3:1:0:246e:9693:128c; helo=server2.sourceware.org; envelope-from=gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=patchwork.ozlabs.org) Received: from server2.sourceware.org (server2.sourceware.org [IPv6:2620:52:3:1:0:246e:9693:128c]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (secp384r1) server-digest SHA384) (No client certificate requested) by legolas.ozlabs.org (Postfix) with ESMTPS id 4WZXZD0rhpz1ybV for ; Fri, 2 Aug 2024 01:14:44 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 59C3C384A472 for ; Thu, 1 Aug 2024 15:14:42 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-ed1-x52b.google.com (mail-ed1-x52b.google.com [IPv6:2a00:1450:4864:20::52b]) by sourceware.org (Postfix) with ESMTPS id C4D16385E45E for ; Thu, 1 Aug 2024 14:58:51 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org C4D16385E45E 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 C4D16385E45E Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::52b ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1722524348; cv=none; b=PCCaVFLPDxfffOm+/ApQnB2O3DkpLGmTtztUsuy5NjSAdmGdtWbz8yQ2EbUwcEvghZZBa7UOwa9MfZDPyOczuUOailMkj1C5ZNTFuQeuP+c2cNhZ6wwxH3eGqzNG/qBsEdweM5/Pd2VVbxqAEkI+0HfOhlMPMbY3TRS7I1q4qfg= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1722524348; c=relaxed/simple; bh=UMEM1Dd3mnQKGwJvvgHac304E1Za5C3Vxfhna9a7EeI=; h=DKIM-Signature:From:To:Subject:Date:Message-ID:MIME-Version; b=ZaS9Z/lLfULicQpOyFskqoBAeoRcGa3ZfRRAn3IRNn3KBnrL+nr/Dm1HSvaluaX211/BvHh2LWCpr7SqyARqxWc+LWv8sqJRgiDuRfL+pzVpvJB/g79zomBc2b8XJk1XsKae4ShMRrp+JoKCVwMmuHKZzkhqIMh9QTJPqDmepks= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-ed1-x52b.google.com with SMTP id 4fb4d7f45d1cf-5a156557029so11262091a12.2 for ; Thu, 01 Aug 2024 07:58:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=embecosm.com; s=google; t=1722524330; x=1723129130; 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=XlwZuihDbOZi91eNG9qINAIK1H2RNAkp3euxXc64MAk=; b=MHOm3bJY5miivYgCnRNR4Vc/g3UVEdxGJ279M+39yRAFO1CnzDVho25oB3xarL7rDJ k8ezEgBCgqP3hdH06Al20PnjllB4tllQT4IwlXQXC1+tRMT/cbY57B6/JFHZBGxusri1 jkdDhNbyd5DOZN1m284YfeQH1p3hYEmqxWddCetbGNGC6kuBUpPmMMjKrLLcD6fJrcYr mJPfZIwZuj+pQUJ2H9iF4esH4M+azefSdONUfT5JslxelLjgW16uUpPrQbdC13KfBxKC ztyCu0m4WylZcDQaR+JauK9lil7Sl1lOG0IKggdLdhImbYyT3vUHUkmE47lVmPaCYb1/ pVCQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1722524330; x=1723129130; 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=XlwZuihDbOZi91eNG9qINAIK1H2RNAkp3euxXc64MAk=; b=l3JJCG354/Ok1jKscN05qx6WFF1pDiAYVkJWmSf8P+Uv8WdpOcG+MNvzyRDxJQRLCN PqEj3JF5qdVaJS4qZIratoUHw1P/ns07nGVAOyCMNQiGGZhulp/LQdBLIb5LIyk0WW0p gExaCSMl7nPxsVAi4A8L6zeEbfR70UCytiiF+6xIqY1mWwMpolXHY1NEgBQNqq57SCKS xp16QDXcILqSK1r/OH6cceUmemZeJhkh9+tlMkRlQmgvnH7tSdUDHkzdqDEjkRaCRU0t CnvwiRaCWQJSwYqY+mzZxf3g7R+e1CT8xLAvqobgeYEHVL2HNjgMNW4DgHvmc8tBfVok 5tTg== X-Gm-Message-State: AOJu0Ywn5l6TuktigASt6TD3YqyhddHelo3fBr9KgiHZUP0NHmheB+Ad UiIfVmmvZTSXjploi4JPgdNs3QZXKeLh7zkGST3C1QcIma0/kvd6QmzmiS1UB4uGWuHy0PwqqBh 7MaJr X-Google-Smtp-Source: AGHT+IFfi4rECcTookecCEiWGW74PViMM058q1OKeBWIZHXVrrePovFxHSY3c3mVU6BfFcII014Ppw== X-Received: by 2002:aa7:d34e:0:b0:5a2:7f47:c729 with SMTP id 4fb4d7f45d1cf-5b7f3bcfee4mr472128a12.9.1722524329323; Thu, 01 Aug 2024 07:58:49 -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.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 01 Aug 2024 07:58:49 -0700 (PDT) From: Arthur Cohen To: gcc-patches@gcc.gnu.org Cc: gcc-rust@gcc.gnu.org, Arthur Cohen Subject: [PATCH 023/125] gccrs: lang-items: Make lang items enum stronger, rename class, cleanup ns. Date: Thu, 1 Aug 2024 16:56:19 +0200 Message-ID: <20240801145809.366388-25-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 X-Spam-Status: No, score=-13.9 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, T_FILL_THIS_FORM_SHORT autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces~incoming=patchwork.ozlabs.org@gcc.gnu.org gcc/rust/ChangeLog: * util/rust-lang-item.h (class RustLangItem): Renamed to... (class LangItem): ...this. Rename ItemType enum to Kind * util/rust-lang-item.cc: Rename methods to use new class name. * backend/rust-compile-expr.cc (CompileExpr::visit): Use new lang-item API. (CompileExpr::resolve_operator_overload): Likewise. * backend/rust-compile-expr.h: Likewise. * hir/rust-ast-lower-base.cc (ASTLoweringBase::handle_lang_item_attribute): Likewise. * typecheck/rust-autoderef.cc (Adjuster::try_deref_type): Likewise. (AutoderefCycle::cycle): Likewise. * typecheck/rust-autoderef.h: Likewise. * typecheck/rust-hir-type-bounds.h: Likewise. * typecheck/rust-hir-type-check-base.cc (TypeCheckBase::get_marker_predicate): Likewise. * typecheck/rust-hir-type-check-base.h: Likewise. * typecheck/rust-hir-type-check-expr.cc (TypeCheckExpr::visit): Likewise. * typecheck/rust-hir-type-check-expr.h: Likewise. * typecheck/rust-hir-type-check-type.cc (TypeResolveGenericParam::visit): Likewise. * typecheck/rust-tyty-bounds.cc (TypeBoundsProbe::assemble_sized_builtin): Likewise. (TypeBoundsProbe::assemble_builtin_candidate): Likewise. (TypeCheckBase::get_predicate_from_bound): Likewise. * typecheck/rust-tyty.cc (ClosureType::setup_fn_once_output): Likewise. * util/rust-hir-map.cc (Mappings::get_lang_item): Likewise. (Mappings::lookup_trait_item_lang_item): Likewise. * util/rust-hir-map.h: Likewise. --- gcc/rust/backend/rust-compile-expr.cc | 24 +- gcc/rust/backend/rust-compile-expr.h | 8 +- gcc/rust/hir/rust-ast-lower-base.cc | 2 +- gcc/rust/typecheck/rust-autoderef.cc | 22 +- gcc/rust/typecheck/rust-autoderef.h | 5 +- gcc/rust/typecheck/rust-hir-type-bounds.h | 2 +- .../typecheck/rust-hir-type-check-base.cc | 3 +- gcc/rust/typecheck/rust-hir-type-check-base.h | 5 +- .../typecheck/rust-hir-type-check-expr.cc | 72 +++--- gcc/rust/typecheck/rust-hir-type-check-expr.h | 7 +- .../typecheck/rust-hir-type-check-type.cc | 3 +- gcc/rust/typecheck/rust-tyty-bounds.cc | 12 +- gcc/rust/typecheck/rust-tyty.cc | 5 +- gcc/rust/util/rust-hir-map.cc | 7 +- gcc/rust/util/rust-hir-map.h | 13 +- gcc/rust/util/rust-lang-item.cc | 218 +++++++++--------- gcc/rust/util/rust-lang-item.h | 31 ++- 17 files changed, 213 insertions(+), 226 deletions(-) diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc index 596b848849e..65de24bf9d8 100644 --- a/gcc/rust/backend/rust-compile-expr.cc +++ b/gcc/rust/backend/rust-compile-expr.cc @@ -150,7 +150,7 @@ CompileExpr::visit (HIR::ArithmeticOrLogicalExpr &expr) if (is_op_overload) { auto lang_item_type - = Analysis::RustLangItem::OperatorToLangItem (expr.get_expr_type ()); + = LangItem::OperatorToLangItem (expr.get_expr_type ()); translated = resolve_operator_overload (lang_item_type, expr, lhs, rhs, expr.get_lhs ().get (), expr.get_rhs ().get ()); @@ -193,9 +193,8 @@ CompileExpr::visit (HIR::CompoundAssignmentExpr &expr) expr.get_mappings ().get_hirid (), &fntype); if (is_op_overload) { - auto lang_item_type - = Analysis::RustLangItem::CompoundAssignmentOperatorToLangItem ( - expr.get_expr_type ()); + auto lang_item_type = LangItem::CompoundAssignmentOperatorToLangItem ( + expr.get_expr_type ()); auto compound_assignment = resolve_operator_overload (lang_item_type, expr, lhs, rhs, expr.get_lhs ().get (), @@ -244,8 +243,7 @@ CompileExpr::visit (HIR::NegationExpr &expr) expr.get_mappings ().get_hirid (), &fntype); if (is_op_overload) { - auto lang_item_type - = Analysis::RustLangItem::NegationOperatorToLangItem (op); + auto lang_item_type = LangItem::NegationOperatorToLangItem (op); translated = resolve_operator_overload (lang_item_type, expr, negated_expr, nullptr, expr.get_expr ().get (), nullptr); @@ -836,7 +834,7 @@ CompileExpr::visit (HIR::DereferenceExpr &expr) expr.get_mappings ().get_hirid (), &fntype); if (is_op_overload) { - auto lang_item_type = Analysis::RustLangItem::ItemType::DEREF; + auto lang_item_type = LangItem::Kind::DEREF; tree operator_overload_call = resolve_operator_overload (lang_item_type, expr, main_expr, nullptr, expr.get_expr ().get (), nullptr); @@ -1423,9 +1421,10 @@ CompileExpr::get_receiver_from_dyn (const TyTy::DynamicObjectType *dyn, } tree -CompileExpr::resolve_operator_overload ( - Analysis::RustLangItem::ItemType lang_item_type, HIR::OperatorExprMeta expr, - tree lhs, tree rhs, HIR::Expr *lhs_expr, HIR::Expr *rhs_expr) +CompileExpr::resolve_operator_overload (LangItem::Kind lang_item_type, + HIR::OperatorExprMeta expr, tree lhs, + tree rhs, HIR::Expr *lhs_expr, + HIR::Expr *rhs_expr) { TyTy::FnType *fntype; bool is_op_overload = ctx->get_tyctx ()->lookup_operator_overload ( @@ -1446,8 +1445,7 @@ CompileExpr::resolve_operator_overload ( } // lookup compiled functions since it may have already been compiled - HIR::PathIdentSegment segment_name ( - Analysis::RustLangItem::ToString (lang_item_type)); + HIR::PathIdentSegment segment_name (LangItem::ToString (lang_item_type)); tree fn_expr = resolve_method_address (fntype, receiver, expr.get_locus ()); // lookup the autoderef mappings @@ -2120,7 +2118,7 @@ CompileExpr::visit (HIR::ArrayIndexExpr &expr) expr.get_mappings ().get_hirid (), &fntype); if (is_op_overload) { - auto lang_item_type = Analysis::RustLangItem::ItemType::INDEX; + auto lang_item_type = LangItem::Kind::INDEX; tree operator_overload_call = resolve_operator_overload (lang_item_type, expr, array_reference, index, expr.get_array_expr ().get (), diff --git a/gcc/rust/backend/rust-compile-expr.h b/gcc/rust/backend/rust-compile-expr.h index e947825c2a9..af2e1bca1ec 100644 --- a/gcc/rust/backend/rust-compile-expr.h +++ b/gcc/rust/backend/rust-compile-expr.h @@ -97,10 +97,10 @@ protected: TyTy::BaseType *receiver, TyTy::FnType *fntype, tree receiver_ref, location_t expr_locus); - tree - resolve_operator_overload (Analysis::RustLangItem::ItemType lang_item_type, - HIR::OperatorExprMeta expr, tree lhs, tree rhs, - HIR::Expr *lhs_expr, HIR::Expr *rhs_expr); + tree resolve_operator_overload (LangItem::Kind lang_item_type, + HIR::OperatorExprMeta expr, tree lhs, + tree rhs, HIR::Expr *lhs_expr, + HIR::Expr *rhs_expr); tree compile_bool_literal (const HIR::LiteralExpr &expr, const TyTy::BaseType *tyty); diff --git a/gcc/rust/hir/rust-ast-lower-base.cc b/gcc/rust/hir/rust-ast-lower-base.cc index 815b98f9f0a..bcc4797df77 100644 --- a/gcc/rust/hir/rust-ast-lower-base.cc +++ b/gcc/rust/hir/rust-ast-lower-base.cc @@ -788,7 +788,7 @@ 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); + auto lang_item_type = LangItem::Parse (lang_item_type_str); if (lang_item_type) mappings->insert_lang_item (*lang_item_type, diff --git a/gcc/rust/typecheck/rust-autoderef.cc b/gcc/rust/typecheck/rust-autoderef.cc index 9966c5469c5..232ee6130c9 100644 --- a/gcc/rust/typecheck/rust-autoderef.cc +++ b/gcc/rust/typecheck/rust-autoderef.cc @@ -28,8 +28,7 @@ namespace Resolver { static bool resolve_operator_overload_fn ( - Analysis::RustLangItem::ItemType lang_item_type, TyTy::BaseType *ty, - TyTy::FnType **resolved_fn, + LangItem::Kind lang_item_type, TyTy::BaseType *ty, TyTy::FnType **resolved_fn, Adjustment::AdjustmentType *requires_ref_adjustment); TyTy::BaseType * @@ -42,8 +41,7 @@ Adjuster::adjust_type (const std::vector &adjustments) } Adjustment -Adjuster::try_deref_type (TyTy::BaseType *ty, - Analysis::RustLangItem::ItemType deref_lang_item) +Adjuster::try_deref_type (TyTy::BaseType *ty, LangItem::Kind deref_lang_item) { TyTy::FnType *fn = nullptr; Adjustment::AdjustmentType requires_ref_adjustment @@ -68,11 +66,11 @@ Adjuster::try_deref_type (TyTy::BaseType *ty, = Adjustment::AdjustmentType::ERROR; switch (deref_lang_item) { - case Analysis::RustLangItem::ItemType::DEREF: + case LangItem::Kind::DEREF: adjustment_type = Adjustment::AdjustmentType::DEREF; break; - case Analysis::RustLangItem::ItemType::DEREF_MUT: + case LangItem::Kind::DEREF_MUT: adjustment_type = Adjustment::AdjustmentType::DEREF_MUT; break; @@ -122,7 +120,7 @@ Adjuster::try_unsize_type (TyTy::BaseType *ty) static bool resolve_operator_overload_fn ( - Analysis::RustLangItem::ItemType lang_item_type, TyTy::BaseType *lhs, + LangItem::Kind lang_item_type, TyTy::BaseType *lhs, TyTy::FnType **resolved_fn, Adjustment::AdjustmentType *requires_ref_adjustment) { @@ -130,8 +128,7 @@ resolve_operator_overload_fn ( auto mappings = Analysis::Mappings::get (); // look up lang item for arithmetic type - std::string associated_item_name - = Analysis::RustLangItem::ToString (lang_item_type); + std::string associated_item_name = LangItem::ToString (lang_item_type); DefId respective_lang_item_id = UNKNOWN_DEFID; bool lang_item_defined = mappings->lookup_lang_item (lang_item_type, &respective_lang_item_id); @@ -359,8 +356,7 @@ AutoderefCycle::cycle (TyTy::BaseType *receiver) return false; } - Adjustment deref - = Adjuster::try_deref_type (r, Analysis::RustLangItem::ItemType::DEREF); + Adjustment deref = Adjuster::try_deref_type (r, LangItem::Kind::DEREF); if (!deref.is_error ()) { auto deref_r = deref.get_expected (); @@ -374,8 +370,8 @@ AutoderefCycle::cycle (TyTy::BaseType *receiver) adjustments.pop_back (); } - Adjustment deref_mut = Adjuster::try_deref_type ( - r, Analysis::RustLangItem::ItemType::DEREF_MUT); + Adjustment deref_mut + = Adjuster::try_deref_type (r, LangItem::Kind::DEREF_MUT); if (!deref_mut.is_error ()) { auto deref_r = deref_mut.get_expected (); diff --git a/gcc/rust/typecheck/rust-autoderef.h b/gcc/rust/typecheck/rust-autoderef.h index f9c759b6f3c..1937b0c1f4c 100644 --- a/gcc/rust/typecheck/rust-autoderef.h +++ b/gcc/rust/typecheck/rust-autoderef.h @@ -132,9 +132,8 @@ public: TyTy::BaseType *adjust_type (const std::vector &adjustments); - static Adjustment - try_deref_type (TyTy::BaseType *ty, - Analysis::RustLangItem::ItemType deref_lang_item); + static Adjustment try_deref_type (TyTy::BaseType *ty, + LangItem::Kind deref_lang_item); static Adjustment try_raw_deref_type (TyTy::BaseType *ty); diff --git a/gcc/rust/typecheck/rust-hir-type-bounds.h b/gcc/rust/typecheck/rust-hir-type-bounds.h index 27fb32c7b43..4e781afd2a7 100644 --- a/gcc/rust/typecheck/rust-hir-type-bounds.h +++ b/gcc/rust/typecheck/rust-hir-type-bounds.h @@ -38,7 +38,7 @@ public: private: void scan (); void assemble_sized_builtin (); - void assemble_builtin_candidate (Analysis::RustLangItem::ItemType item); + void assemble_builtin_candidate (LangItem::Kind item); private: TypeBoundsProbe (const TyTy::BaseType *receiver); diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.cc b/gcc/rust/typecheck/rust-hir-type-check-base.cc index b9b4f91ac9f..f3edfef4e27 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-base.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-base.cc @@ -411,8 +411,7 @@ TypeCheckBase::resolve_generic_params ( } TyTy::TypeBoundPredicate -TypeCheckBase::get_marker_predicate (Analysis::RustLangItem::ItemType item_type, - location_t locus) +TypeCheckBase::get_marker_predicate (LangItem::Kind item_type, location_t locus) { DefId item_id = mappings->get_lang_item (item_type, locus); HIR::Item *item = mappings->lookup_defid (item_id); diff --git a/gcc/rust/typecheck/rust-hir-type-check-base.h b/gcc/rust/typecheck/rust-hir-type-check-base.h index 0491e0fe175..11a3a686df7 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-base.h +++ b/gcc/rust/typecheck/rust-hir-type-check-base.h @@ -58,9 +58,8 @@ protected: const std::vector > &generic_params, std::vector &substitutions); - TyTy::TypeBoundPredicate - get_marker_predicate (Analysis::RustLangItem::ItemType item_type, - location_t locus); + TyTy::TypeBoundPredicate get_marker_predicate (LangItem::Kind item_type, + location_t locus); Analysis::Mappings *mappings; Resolver *resolver; diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.cc b/gcc/rust/typecheck/rust-hir-type-check-expr.cc index 9f5042a4ece..224d2fff4b8 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.cc @@ -260,8 +260,7 @@ TypeCheckExpr::visit (HIR::CompoundAssignmentExpr &expr) expr.get_locus ()); auto lang_item_type - = Analysis::RustLangItem::CompoundAssignmentOperatorToLangItem ( - expr.get_expr_type ()); + = LangItem::CompoundAssignmentOperatorToLangItem (expr.get_expr_type ()); bool operator_overloaded = resolve_operator_overload (lang_item_type, expr, lhs, rhs); if (operator_overloaded) @@ -292,8 +291,7 @@ TypeCheckExpr::visit (HIR::ArithmeticOrLogicalExpr &expr) auto lhs = TypeCheckExpr::Resolve (expr.get_lhs ().get ()); auto rhs = TypeCheckExpr::Resolve (expr.get_rhs ().get ()); - auto lang_item_type - = Analysis::RustLangItem::OperatorToLangItem (expr.get_expr_type ()); + auto lang_item_type = LangItem::OperatorToLangItem (expr.get_expr_type ()); bool operator_overloaded = resolve_operator_overload (lang_item_type, expr, lhs, rhs); if (operator_overloaded) @@ -384,8 +382,8 @@ TypeCheckExpr::visit (HIR::NegationExpr &expr) auto negated_expr_ty = TypeCheckExpr::Resolve (expr.get_expr ().get ()); // check for operator overload - auto lang_item_type = Analysis::RustLangItem::NegationOperatorToLangItem ( - expr.get_expr_type ()); + auto lang_item_type + = LangItem::NegationOperatorToLangItem (expr.get_expr_type ()); bool operator_overloaded = resolve_operator_overload (lang_item_type, expr, negated_expr_ty, nullptr); @@ -628,7 +626,7 @@ TypeCheckExpr::visit (HIR::BlockExpr &expr) void TypeCheckExpr::visit (HIR::RangeFromToExpr &expr) { - auto lang_item_type = Analysis::RustLangItem::ItemType::RANGE; + auto lang_item_type = LangItem::Kind::RANGE; DefId respective_lang_item_id = UNKNOWN_DEFID; bool lang_item_defined @@ -637,9 +635,9 @@ TypeCheckExpr::visit (HIR::RangeFromToExpr &expr) // we need to have it maybe if (!lang_item_defined) { - rust_internal_error_at ( - expr.get_locus (), "unable to find relevant lang item: %s", - Analysis::RustLangItem::ToString (lang_item_type).c_str ()); + rust_internal_error_at (expr.get_locus (), + "unable to find relevant lang item: %s", + LangItem::ToString (lang_item_type).c_str ()); return; } @@ -683,7 +681,7 @@ TypeCheckExpr::visit (HIR::RangeFromToExpr &expr) void TypeCheckExpr::visit (HIR::RangeFromExpr &expr) { - auto lang_item_type = Analysis::RustLangItem::ItemType::RANGE_FROM; + auto lang_item_type = LangItem::Kind::RANGE_FROM; DefId respective_lang_item_id = UNKNOWN_DEFID; bool lang_item_defined @@ -692,9 +690,9 @@ TypeCheckExpr::visit (HIR::RangeFromExpr &expr) // we need to have it maybe if (!lang_item_defined) { - rust_internal_error_at ( - expr.get_locus (), "unable to find relevant lang item: %s", - Analysis::RustLangItem::ToString (lang_item_type).c_str ()); + rust_internal_error_at (expr.get_locus (), + "unable to find relevant lang item: %s", + LangItem::ToString (lang_item_type).c_str ()); return; } @@ -731,7 +729,7 @@ TypeCheckExpr::visit (HIR::RangeFromExpr &expr) void TypeCheckExpr::visit (HIR::RangeToExpr &expr) { - auto lang_item_type = Analysis::RustLangItem::ItemType::RANGE_TO; + auto lang_item_type = LangItem::Kind::RANGE_TO; DefId respective_lang_item_id = UNKNOWN_DEFID; bool lang_item_defined @@ -740,9 +738,9 @@ TypeCheckExpr::visit (HIR::RangeToExpr &expr) // we need to have it maybe if (!lang_item_defined) { - rust_internal_error_at ( - expr.get_locus (), "unable to find relevant lang item: %s", - Analysis::RustLangItem::ToString (lang_item_type).c_str ()); + rust_internal_error_at (expr.get_locus (), + "unable to find relevant lang item: %s", + LangItem::ToString (lang_item_type).c_str ()); return; } @@ -778,7 +776,7 @@ TypeCheckExpr::visit (HIR::RangeToExpr &expr) void TypeCheckExpr::visit (HIR::RangeFullExpr &expr) { - auto lang_item_type = Analysis::RustLangItem::ItemType::RANGE_FULL; + auto lang_item_type = LangItem::Kind::RANGE_FULL; DefId respective_lang_item_id = UNKNOWN_DEFID; bool lang_item_defined @@ -787,9 +785,9 @@ TypeCheckExpr::visit (HIR::RangeFullExpr &expr) // we need to have it maybe if (!lang_item_defined) { - rust_internal_error_at ( - expr.get_locus (), "unable to find relevant lang item: %s", - Analysis::RustLangItem::ToString (lang_item_type).c_str ()); + rust_internal_error_at (expr.get_locus (), + "unable to find relevant lang item: %s", + LangItem::ToString (lang_item_type).c_str ()); return; } @@ -809,7 +807,7 @@ TypeCheckExpr::visit (HIR::RangeFullExpr &expr) void TypeCheckExpr::visit (HIR::RangeFromToInclExpr &expr) { - auto lang_item_type = Analysis::RustLangItem::ItemType::RANGE_INCLUSIVE; + auto lang_item_type = LangItem::Kind::RANGE_INCLUSIVE; DefId respective_lang_item_id = UNKNOWN_DEFID; bool lang_item_defined @@ -818,9 +816,9 @@ TypeCheckExpr::visit (HIR::RangeFromToInclExpr &expr) // we need to have it maybe if (!lang_item_defined) { - rust_internal_error_at ( - expr.get_locus (), "unable to find relevant lang item: %s", - Analysis::RustLangItem::ToString (lang_item_type).c_str ()); + rust_internal_error_at (expr.get_locus (), + "unable to find relevant lang item: %s", + LangItem::ToString (lang_item_type).c_str ()); return; } @@ -903,7 +901,7 @@ TypeCheckExpr::visit (HIR::ArrayIndexExpr &expr) } // is this a case of core::ops::index? - auto lang_item_type = Analysis::RustLangItem::ItemType::INDEX; + auto lang_item_type = LangItem::Kind::INDEX; bool operator_overloaded = resolve_operator_overload (lang_item_type, expr, array_expr_ty, index_expr_ty); @@ -1412,7 +1410,7 @@ TypeCheckExpr::visit (HIR::DereferenceExpr &expr) = TypeCheckExpr::Resolve (expr.get_expr ().get ()); rust_debug_loc (expr.get_locus (), "attempting deref operator overload"); - auto lang_item_type = Analysis::RustLangItem::ItemType::DEREF; + auto lang_item_type = LangItem::Kind::DEREF; bool operator_overloaded = resolve_operator_overload (lang_item_type, expr, resolved_base, nullptr); if (operator_overloaded) @@ -1586,8 +1584,7 @@ TypeCheckExpr::visit (HIR::ClosureExpr &expr) // assume FnOnce for now. I think this is based on the return type of the // closure - Analysis::RustLangItem::ItemType lang_item_type - = Analysis::RustLangItem::ItemType::FN_ONCE; + LangItem::Kind lang_item_type = LangItem::Kind::FN_ONCE; DefId respective_lang_item_id = UNKNOWN_DEFID; bool lang_item_defined = mappings->lookup_lang_item (lang_item_type, &respective_lang_item_id); @@ -1596,9 +1593,8 @@ TypeCheckExpr::visit (HIR::ClosureExpr &expr) // FIXME // we need to have a unified way or error'ing when we are missing lang // items that is useful - rust_fatal_error ( - expr.get_locus (), "unable to find lang item: %<%s%>", - Analysis::RustLangItem::ToString (lang_item_type).c_str ()); + rust_fatal_error (expr.get_locus (), "unable to find lang item: %<%s%>", + LangItem::ToString (lang_item_type).c_str ()); } rust_assert (lang_item_defined); @@ -1637,13 +1633,13 @@ TypeCheckExpr::visit (HIR::ClosureExpr &expr) } bool -TypeCheckExpr::resolve_operator_overload ( - Analysis::RustLangItem::ItemType lang_item_type, HIR::OperatorExprMeta expr, - TyTy::BaseType *lhs, TyTy::BaseType *rhs) +TypeCheckExpr::resolve_operator_overload (LangItem::Kind lang_item_type, + HIR::OperatorExprMeta expr, + TyTy::BaseType *lhs, + TyTy::BaseType *rhs) { // look up lang item for arithmetic type - std::string associated_item_name - = Analysis::RustLangItem::ToString (lang_item_type); + std::string associated_item_name = LangItem::ToString (lang_item_type); DefId respective_lang_item_id = UNKNOWN_DEFID; bool lang_item_defined = mappings->lookup_lang_item (lang_item_type, &respective_lang_item_id); diff --git a/gcc/rust/typecheck/rust-hir-type-check-expr.h b/gcc/rust/typecheck/rust-hir-type-check-expr.h index c9df24e2dbe..9ea4dc6e59c 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-expr.h +++ b/gcc/rust/typecheck/rust-hir-type-check-expr.h @@ -96,10 +96,9 @@ public: } protected: - bool - resolve_operator_overload (Analysis::RustLangItem::ItemType lang_item_type, - HIR::OperatorExprMeta expr, TyTy::BaseType *lhs, - TyTy::BaseType *rhs); + bool resolve_operator_overload (LangItem::Kind lang_item_type, + HIR::OperatorExprMeta expr, + TyTy::BaseType *lhs, TyTy::BaseType *rhs); bool resolve_fn_trait_call (HIR::CallExpr &expr, TyTy::BaseType *function_tyty, diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index 74a12c4b011..a132b386a96 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -794,8 +794,7 @@ TypeResolveGenericParam::visit (HIR::TypeParam ¶m) if (apply_sized) { TyTy::TypeBoundPredicate sized_predicate - = get_marker_predicate (Analysis::RustLangItem::ItemType::SIZED, - param.get_locus ()); + = get_marker_predicate (LangItem::Kind::SIZED, param.get_locus ()); predicates[sized_predicate.get_id ()] = {sized_predicate}; } diff --git a/gcc/rust/typecheck/rust-tyty-bounds.cc b/gcc/rust/typecheck/rust-tyty-bounds.cc index f37cf50d53c..6e4c3458118 100644 --- a/gcc/rust/typecheck/rust-tyty-bounds.cc +++ b/gcc/rust/typecheck/rust-tyty-bounds.cc @@ -131,7 +131,7 @@ TypeBoundsProbe::assemble_sized_builtin () case TyTy::NEVER: case TyTy::PLACEHOLDER: case TyTy::PROJECTION: - assemble_builtin_candidate (Analysis::RustLangItem::SIZED); + assemble_builtin_candidate (LangItem::Kind::SIZED); break; // FIXME str and slice need to be moved and test cases updated @@ -140,7 +140,7 @@ TypeBoundsProbe::assemble_sized_builtin () case TyTy::ADT: case TyTy::TUPLE: // FIXME add extra checks - assemble_builtin_candidate (Analysis::RustLangItem::SIZED); + assemble_builtin_candidate (LangItem::Kind::SIZED); break; case TyTy::DYNAMIC: @@ -150,8 +150,7 @@ TypeBoundsProbe::assemble_sized_builtin () } void -TypeBoundsProbe::assemble_builtin_candidate ( - Analysis::RustLangItem::ItemType lang_item) +TypeBoundsProbe::assemble_builtin_candidate (LangItem::Kind lang_item) { DefId id; bool found_lang_item = mappings->lookup_lang_item (lang_item, &id); @@ -171,7 +170,7 @@ TypeBoundsProbe::assemble_builtin_candidate ( trait_references.push_back ({trait_ref, mappings->lookup_builtin_marker ()}); rust_debug ("Added builtin lang_item: %s for %s", - Analysis::RustLangItem::ToString (lang_item).c_str (), + LangItem::ToString (lang_item).c_str (), raw->get_name ().c_str ()); } @@ -246,8 +245,7 @@ TypeCheckBase::get_predicate_from_bound (HIR::TypePath &type_path, TypeCheckType::Resolve (fn.get_return_type ().get ()); HIR::TraitItem *trait_item = mappings->lookup_trait_item_lang_item ( - Analysis::RustLangItem::ItemType::FN_ONCE_OUTPUT, - final_seg->get_locus ()); + LangItem::Kind::FN_ONCE_OUTPUT, final_seg->get_locus ()); std::vector bindings; location_t output_locus = fn.get_return_type ()->get_locus (); diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index d81311eed6e..51960efa406 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -2215,9 +2215,8 @@ void ClosureType::setup_fn_once_output () const { // lookup the lang items - auto fn_once_lang_item = Analysis::RustLangItem::ItemType::FN_ONCE; - auto fn_once_output_lang_item - = Analysis::RustLangItem::ItemType::FN_ONCE_OUTPUT; + auto fn_once_lang_item = LangItem::Kind::FN_ONCE; + auto fn_once_output_lang_item = LangItem::Kind::FN_ONCE_OUTPUT; DefId trait_id = UNKNOWN_DEFID; bool trait_lang_item_defined diff --git a/gcc/rust/util/rust-hir-map.cc b/gcc/rust/util/rust-hir-map.cc index 91fa2562c39..1f7cb4d2c48 100644 --- a/gcc/rust/util/rust-hir-map.cc +++ b/gcc/rust/util/rust-hir-map.cc @@ -1252,20 +1252,19 @@ Mappings::lookup_builtin_marker () } DefId -Mappings::get_lang_item (RustLangItem::ItemType item_type, location_t locus) +Mappings::get_lang_item (LangItem::Kind item_type, location_t locus) { DefId item = UNKNOWN_DEFID; bool ok = lookup_lang_item (item_type, &item); if (!ok) rust_fatal_error (locus, "failed to find lang item %s", - RustLangItem::ToString (item_type).c_str ()); + LangItem::ToString (item_type).c_str ()); return item; } HIR::TraitItem * -Mappings::lookup_trait_item_lang_item (Analysis::RustLangItem::ItemType item, - location_t locus) +Mappings::lookup_trait_item_lang_item (LangItem::Kind item, location_t locus) { DefId trait_item_id = get_lang_item (item, locus); return lookup_trait_item_defid (trait_item_id); diff --git a/gcc/rust/util/rust-hir-map.h b/gcc/rust/util/rust-hir-map.h index a663bfe4a56..927c01251db 100644 --- a/gcc/rust/util/rust-hir-map.h +++ b/gcc/rust/util/rust-hir-map.h @@ -255,7 +255,7 @@ public: return true; } - void insert_lang_item (RustLangItem::ItemType item_type, DefId id) + void insert_lang_item (LangItem::Kind item_type, DefId id) { auto it = lang_item_mappings.find (item_type); rust_assert (it == lang_item_mappings.end ()); @@ -263,7 +263,7 @@ public: lang_item_mappings[item_type] = id; } - bool lookup_lang_item (RustLangItem::ItemType item_type, DefId *id) + bool lookup_lang_item (LangItem::Kind item_type, DefId *id) { auto it = lang_item_mappings.find (item_type); if (it == lang_item_mappings.end ()) @@ -274,7 +274,7 @@ public: } // This will fatal_error when this lang item does not exist - DefId get_lang_item (RustLangItem::ItemType item_type, location_t locus); + DefId get_lang_item (LangItem::Kind item_type, location_t locus); void insert_macro_def (AST::MacroRulesDefinition *macro); @@ -347,9 +347,8 @@ public: HIR::ImplBlock *lookup_builtin_marker (); - HIR::TraitItem * - lookup_trait_item_lang_item (Analysis::RustLangItem::ItemType item, - location_t locus); + HIR::TraitItem *lookup_trait_item_lang_item (LangItem::Kind item, + location_t locus); private: Mappings (); @@ -388,7 +387,7 @@ private: std::map hirGenericParamMappings; std::map hirTraitItemsToTraitMappings; std::map hirPatternMappings; - std::map lang_item_mappings; + std::map lang_item_mappings; std::map paths; std::map locations; std::map nodeIdToHirMappings; diff --git a/gcc/rust/util/rust-lang-item.cc b/gcc/rust/util/rust-lang-item.cc index 9fe212d412d..38df90f29a1 100644 --- a/gcc/rust/util/rust-lang-item.cc +++ b/gcc/rust/util/rust-lang-item.cc @@ -20,172 +20,168 @@ #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) + +const BiMap Rust::LangItem::lang_items = {{ + {"add", Kind::ADD}, + {"sub", Kind::SUBTRACT}, + {"mul", Kind::MULTIPLY}, + {"div", Kind::DIVIDE}, + {"rem", Kind::REMAINDER}, + {"bitand", Kind::BITAND}, + {"bitor", Kind::BITOR}, + {"bitxor", Kind::BITXOR}, + {"shl", Kind::SHL}, + {"shr", Kind::SHR}, + {"neg", Kind::NEGATION}, + {"not", Kind::NOT}, + {"add_assign", Kind::ADD_ASSIGN}, + {"sub_assign", Kind::SUB_ASSIGN}, + {"mul_assign", Kind::MUL_ASSIGN}, + {"div_assign", Kind::DIV_ASSIGN}, + {"rem_assign", Kind::REM_ASSIGN}, + {"bitand_assign", Kind::BITAND_ASSIGN}, + {"bitor_assign", Kind::BITOR_ASSIGN}, + {"bitxor_assign", Kind::BITXOR_ASSIGN}, + {"shl_assign", Kind::SHL_ASSIGN}, + {"shr_assign", Kind::SHR_ASSIGN}, + {"deref", Kind::DEREF}, + {"deref_mut", Kind::DEREF_MUT}, + {"index", Kind::INDEX}, + {"index_mut", Kind::INDEX_MUT}, + {"RangeFull", Kind::RANGE_FULL}, + {"Range", Kind::RANGE}, + {"RangeFrom", Kind::RANGE_FROM}, + {"RangeTo", Kind::RANGE_TO}, + {"RangeInclusive", Kind::RANGE_INCLUSIVE}, + {"RangeToInclusive", Kind::RANGE_TO_INCLUSIVE}, + {"phantom_data", Kind::PHANTOM_DATA}, + {"fn", Kind::FN}, + {"fn_mut", Kind::FN_MUT}, + {"fn_once", Kind::FN_ONCE}, + {"fn_once_output", Kind::FN_ONCE_OUTPUT}, + {"copy", Kind::COPY}, + {"clone", Kind::CLONE}, + {"sized", Kind::SIZED}, + {"slice_alloc", Kind::SLICE_ALLOC}, + {"slice_u8_alloc", Kind::SLICE_U8_ALLOC}, + {"str_alloc", Kind::STR_ALLOC}, + {"array", Kind::ARRAY}, + {"bool", Kind::BOOL}, + {"char", Kind::CHAR}, + {"f32", Kind::F32}, + {"f64", Kind::F64}, + {"i8", Kind::I8}, + {"i16", Kind::I16}, + {"i32", Kind::I32}, + {"i64", Kind::I64}, + {"i128", Kind::I128}, + {"isize", Kind::ISIZE}, + {"u8", Kind::U8}, + {"u16", Kind::U16}, + {"u32", Kind::U32}, + {"u64", Kind::U64}, + {"u128", Kind::U128}, + {"usize", Kind::USIZE}, + {"const_ptr", Kind::CONST_PTR}, + {"const_slice_ptr", Kind::CONST_SLICE_PTR}, + {"mut_ptr", Kind::MUT_PTR}, + {"mut_slice_ptr", Kind::MUT_SLICE_PTR}, + {"slice_u8", Kind::SLICE_U8}, + {"slice", Kind::SLICE}, + {"str", Kind::STR}, + {"f32_runtime", Kind::F32_RUNTIME}, + {"f64_runtime", Kind::F64_RUNTIME}, +}}; + +tl::optional +LangItem::Parse (const std::string &item) { - auto lang_item = RustLangItem::lang_items.lookup (item); - if (!RustLangItem::lang_items.is_iter_ok (lang_item)) + auto lang_item = LangItem::lang_items.lookup (item); + if (!LangItem::lang_items.is_iter_ok (lang_item)) return tl::nullopt; return lang_item->second; } std::string -RustLangItem::ToString (RustLangItem::ItemType type) +LangItem::ToString (LangItem::Kind type) { - auto str = RustLangItem::lang_items.lookup (type); + auto str = LangItem::lang_items.lookup (type); return str->second; } -RustLangItem::ItemType -RustLangItem::OperatorToLangItem (ArithmeticOrLogicalOperator op) +LangItem::Kind +LangItem::OperatorToLangItem (ArithmeticOrLogicalOperator op) { switch (op) { case ArithmeticOrLogicalOperator::ADD: - return RustLangItem::ItemType::ADD; + return LangItem::Kind::ADD; case ArithmeticOrLogicalOperator::SUBTRACT: - return RustLangItem::ItemType::SUBTRACT; + return LangItem::Kind::SUBTRACT; case ArithmeticOrLogicalOperator::MULTIPLY: - return RustLangItem::ItemType::MULTIPLY; + return LangItem::Kind::MULTIPLY; case ArithmeticOrLogicalOperator::DIVIDE: - return RustLangItem::ItemType::DIVIDE; + return LangItem::Kind::DIVIDE; case ArithmeticOrLogicalOperator::MODULUS: - return RustLangItem::ItemType::REMAINDER; + return LangItem::Kind::REMAINDER; case ArithmeticOrLogicalOperator::BITWISE_AND: - return RustLangItem::ItemType::BITAND; + return LangItem::Kind::BITAND; case ArithmeticOrLogicalOperator::BITWISE_OR: - return RustLangItem::ItemType::BITOR; + return LangItem::Kind::BITOR; case ArithmeticOrLogicalOperator::BITWISE_XOR: - return RustLangItem::ItemType::BITXOR; + return LangItem::Kind::BITXOR; case ArithmeticOrLogicalOperator::LEFT_SHIFT: - return RustLangItem::ItemType::SHL; + return LangItem::Kind::SHL; case ArithmeticOrLogicalOperator::RIGHT_SHIFT: - return RustLangItem::ItemType::SHR; + return LangItem::Kind::SHR; } rust_unreachable (); } -RustLangItem::ItemType -RustLangItem::CompoundAssignmentOperatorToLangItem ( - ArithmeticOrLogicalOperator op) +LangItem::Kind +LangItem::CompoundAssignmentOperatorToLangItem (ArithmeticOrLogicalOperator op) { switch (op) { case ArithmeticOrLogicalOperator::ADD: - return RustLangItem::ItemType::ADD_ASSIGN; + return LangItem::Kind::ADD_ASSIGN; case ArithmeticOrLogicalOperator::SUBTRACT: - return RustLangItem::ItemType::SUB_ASSIGN; + return LangItem::Kind::SUB_ASSIGN; case ArithmeticOrLogicalOperator::MULTIPLY: - return RustLangItem::ItemType::MUL_ASSIGN; + return LangItem::Kind::MUL_ASSIGN; case ArithmeticOrLogicalOperator::DIVIDE: - return RustLangItem::ItemType::DIV_ASSIGN; + return LangItem::Kind::DIV_ASSIGN; case ArithmeticOrLogicalOperator::MODULUS: - return RustLangItem::ItemType::REM_ASSIGN; + return LangItem::Kind::REM_ASSIGN; case ArithmeticOrLogicalOperator::BITWISE_AND: - return RustLangItem::ItemType::BITAND_ASSIGN; + return LangItem::Kind::BITAND_ASSIGN; case ArithmeticOrLogicalOperator::BITWISE_OR: - return RustLangItem::ItemType::BITOR_ASSIGN; + return LangItem::Kind::BITOR_ASSIGN; case ArithmeticOrLogicalOperator::BITWISE_XOR: - return RustLangItem::ItemType::BITXOR_ASSIGN; + return LangItem::Kind::BITXOR_ASSIGN; case ArithmeticOrLogicalOperator::LEFT_SHIFT: - return RustLangItem::ItemType::SHL_ASSIGN; + return LangItem::Kind::SHL_ASSIGN; case ArithmeticOrLogicalOperator::RIGHT_SHIFT: - return RustLangItem::ItemType::SHR_ASSIGN; + return LangItem::Kind::SHR_ASSIGN; } rust_unreachable (); } -RustLangItem::ItemType -RustLangItem::NegationOperatorToLangItem (NegationOperator op) +LangItem::Kind +LangItem::NegationOperatorToLangItem (NegationOperator op) { switch (op) { case NegationOperator::NEGATE: - return RustLangItem::ItemType::NEGATION; + return LangItem::Kind::NEGATION; case NegationOperator::NOT: - return RustLangItem::ItemType::NOT; + return LangItem::Kind::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 3447e3680c8..414436f0c96 100644 --- a/gcc/rust/util/rust-lang-item.h +++ b/gcc/rust/util/rust-lang-item.h @@ -22,13 +22,12 @@ #include "bi-map.h" namespace Rust { -namespace Analysis { // https://github.com/rust-lang/rust/blob/master/library/core/src/ops/arith.rs -class RustLangItem +class LangItem { public: - enum ItemType + enum class Kind { ADD, SUBTRACT, @@ -119,15 +118,27 @@ public: F64_RUNTIME, }; - static const BiMap lang_items; + 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 + static tl::optional Parse (const std::string &item); + static std::string ToString (Kind type); + static Kind OperatorToLangItem (ArithmeticOrLogicalOperator op); + static Kind CompoundAssignmentOperatorToLangItem (ArithmeticOrLogicalOperator op); - static ItemType NegationOperatorToLangItem (NegationOperator op); + static Kind NegationOperatorToLangItem (NegationOperator op); }; -} // namespace Analysis } // namespace Rust + +// GCC 4.8 needs us to manually implement hashing for enum classes +namespace std { +template <> struct hash +{ + size_t operator() (const Rust::LangItem::Kind &lang_item) const noexcept + { + return hash::type> () ( + static_cast::type> ( + lang_item)); + } +}; +} // namespace std