Lrc -> Arc

Author: nbdd0121

src/attribute.rs

@@ -2,9 +2,10 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
+use std::sync::Arc;
+
 use rustc_ast::tokenstream::{self, TokenTree};
 use rustc_ast::{token, DelimArgs};
-use rustc_data_structures::sync::Lrc;
 use rustc_errors::{Diag, ErrorGuaranteed};
 use rustc_hir::{AttrArgs, AttrItem, AttrKind, Attribute, HirId};
 use rustc_middle::ty::TyCtxt;
@@ -460,14 +461,14 @@ memoize!(
     pub fn klint_attributes<'tcx>(
         cx: &AnalysisCtxt<'tcx>,
         hir_id: HirId,
-    ) -> Lrc<Vec<KlintAttribute>> {
+    ) -> Arc<Vec<KlintAttribute>> {
         let mut v = Vec::new();
         for attr in cx.hir().attrs(hir_id) {
             let Some(attr) = crate::attribute::parse_klint_attribute(cx.tcx, hir_id, attr) else {
                 continue;
             };
             v.push(attr);
         }
-        Lrc::new(v)
+        Arc::new(v)
     }
 );

src/ctxt.rs

@@ -8,7 +8,6 @@ use std::sync::Arc;
 
 use rusqlite::{Connection, OptionalExtension};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_data_structures::sync::Lrc;
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
 use rustc_middle::ty::TyCtxt;
 use rustc_serialize::{Decodable, Encodable};
@@ -52,10 +51,10 @@ pub(crate) trait PersistentQuery: QueryValueDecodable {
 pub struct AnalysisCtxt<'tcx> {
     pub tcx: TyCtxt<'tcx>,
     pub local_conn: Connection,
-    pub sql_conn: RefCell<FxHashMap<CrateNum, Option<Lrc<Connection>>>>,
+    pub sql_conn: RefCell<FxHashMap<CrateNum, Option<Arc<Connection>>>>,
 
     pub call_stack: RefCell<Vec<UseSite<'tcx>>>,
-    pub query_cache: RefCell<FxHashMap<TypeId, Lrc<dyn Any>>>,
+    pub query_cache: RefCell<FxHashMap<TypeId, Arc<dyn Any>>>,
 }
 
 impl<'tcx> std::ops::Deref for AnalysisCtxt<'tcx> {
@@ -128,13 +127,13 @@ impl ArcDowncast for Arc<dyn Any> {
 impl<'tcx> AnalysisCtxt<'tcx> {
     pub(crate) fn query_cache<Q: Query>(
         &self,
-    ) -> Lrc<RefCell<FxHashMap<Q::Key<'tcx>, Q::Value<'tcx>>>> {
+    ) -> Arc<RefCell<FxHashMap<Q::Key<'tcx>, Q::Value<'tcx>>>> {
         let key = TypeId::of::<Q>();
         let mut guard = self.query_cache.borrow_mut();
         let cache = guard
             .entry(key)
             .or_insert_with(|| {
-                let cache = Lrc::new(RefCell::new(
+                let cache = Arc::new(RefCell::new(
                     FxHashMap::<Q::Key<'static>, Q::Value<'static>>::default(),
                 ));
                 cache
@@ -147,7 +146,7 @@ impl<'tcx> AnalysisCtxt<'tcx> {
         unsafe { std::mem::transmute(cache) }
     }
 
-    pub(crate) fn sql_connection(&self, cnum: CrateNum) -> Option<Lrc<Connection>> {
+    pub(crate) fn sql_connection(&self, cnum: CrateNum) -> Option<Arc<Connection>> {
         if let Some(v) = self.sql_conn.borrow().get(&cnum) {
             return v.clone();
         }
@@ -188,7 +187,7 @@ impl<'tcx> AnalysisCtxt<'tcx> {
                     );
                 }
 
-                result = Some(Lrc::new(conn));
+                result = Some(Arc::new(conn));
                 break;
             }
         }

src/serde.rs

@@ -2,8 +2,9 @@
 //
 // SPDX-License-Identifier: MIT OR Apache-2.0
 
+use std::sync::Arc;
+
 use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
-use rustc_data_structures::sync::Lrc;
 use rustc_middle::mir::interpret::{self, AllocDecodingState, AllocId};
 use rustc_middle::ty::{self, Ty, TyCtxt, TyDecoder, TyEncoder};
 use rustc_serialize::opaque::{MemDecoder, MAGIC_END_BYTES};
@@ -113,7 +114,7 @@ pub struct EncodeContext<'tcx> {
     type_shorthands: FxHashMap<Ty<'tcx>, usize>,
     predicate_shorthands: FxHashMap<ty::PredicateKind<'tcx>, usize>,
     interpret_allocs: FxIndexSet<AllocId>,
-    relative_file: Lrc<SourceFile>,
+    relative_file: Arc<SourceFile>,
 }
 
 impl<'tcx> EncodeContext<'tcx> {
@@ -239,7 +240,7 @@ impl<'tcx> SpanEncoder for EncodeContext<'tcx> {
             return TAG_PARTIAL_SPAN.encode(self);
         }
 
-        if Lrc::ptr_eq(&pos.sf, &self.relative_file) {
+        if Arc::ptr_eq(&pos.sf, &self.relative_file) {
             TAG_RELATIVE_SPAN.encode(self);
             (span.lo - self.relative_file.start_pos).encode(self);
             (span.hi - self.relative_file.start_pos).encode(self);
@@ -274,9 +275,9 @@ pub struct DecodeContext<'a, 'tcx> {
     decoder: MemDecoder<'a>,
     tcx: TyCtxt<'tcx>,
     type_shorthands: FxHashMap<usize, Ty<'tcx>>,
-    alloc_decoding_state: Lrc<AllocDecodingState>,
+    alloc_decoding_state: Arc<AllocDecodingState>,
     replacement_span: Span,
-    relative_file: Lrc<SourceFile>,
+    relative_file: Arc<SourceFile>,
 }
 
 impl<'a, 'tcx> DecodeContext<'a, 'tcx> {
@@ -289,7 +290,7 @@ impl<'a, 'tcx> DecodeContext<'a, 'tcx> {
         let mut decoder = MemDecoder::new(bytes, vec_position).unwrap();
         let interpret_alloc_index = Vec::<u64>::decode(&mut decoder);
         let alloc_decoding_state =
-            Lrc::new(interpret::AllocDecodingState::new(interpret_alloc_index));
+            Arc::new(interpret::AllocDecodingState::new(interpret_alloc_index));
 
         Self {
             decoder: MemDecoder::new(bytes, 0).unwrap(),