@@ -8,12 +8,8 @@ use syntax::ast::{self, HasVisibility};
8
8
use triomphe:: Arc ;
9
9
10
10
use crate :: {
11
- ConstId , FunctionId , HasModule , ItemContainerId , LocalFieldId , LocalModuleId , ModuleId ,
12
- TraitId , TypeAliasId , VariantId ,
13
- db:: DefDatabase ,
14
- nameres:: DefMap ,
15
- resolver:: { HasResolver , Resolver } ,
16
- src:: HasSource ,
11
+ AssocItemId , HasModule , ItemContainerId , LocalFieldId , LocalModuleId , ModuleId , TraitId ,
12
+ VariantId , db:: DefDatabase , nameres:: DefMap , resolver:: HasResolver , src:: HasSource ,
17
13
} ;
18
14
19
15
pub use crate :: item_tree:: { RawVisibility , VisibilityExplicitness } ;
@@ -225,63 +221,56 @@ pub(crate) fn field_visibilities_query(
225
221
226
222
pub fn visibility_from_ast (
227
223
db : & dyn DefDatabase ,
228
- resolver : & Resolver < ' _ > ,
224
+ has_resolver : impl HasResolver ,
229
225
ast_vis : InFile < Option < ast:: Visibility > > ,
230
226
) -> Visibility {
231
227
let mut span_map = None ;
232
228
let raw_vis = crate :: item_tree:: visibility_from_ast ( db, ast_vis. value , & mut |range| {
233
229
span_map. get_or_insert_with ( || db. span_map ( ast_vis. file_id ) ) . span_for_range ( range) . ctx
234
230
} ) ;
235
- Visibility :: resolve ( db, resolver, & raw_vis)
236
- }
237
-
238
- fn trait_item_visibility (
239
- db : & dyn DefDatabase ,
240
- resolver : & Resolver < ' _ > ,
241
- container : ItemContainerId ,
242
- ) -> Option < Visibility > {
243
- match container {
244
- ItemContainerId :: TraitId ( trait_) => Some ( trait_visibility ( db, resolver, trait_) ) ,
245
- _ => None ,
231
+ if raw_vis == RawVisibility :: Public {
232
+ return Visibility :: Public ;
246
233
}
247
- }
248
234
249
- /// Resolve visibility of a function.
250
- pub ( crate ) fn function_visibility_query ( db : & dyn DefDatabase , def : FunctionId ) -> Visibility {
251
- let loc = def. lookup ( db) ;
252
- let resolver = def. resolver ( db) ;
253
- trait_item_visibility ( db, & resolver, loc. container ) . unwrap_or_else ( || {
254
- let source = loc. source ( db) ;
255
- visibility_from_ast ( db, & resolver, source. map ( |src| src. visibility ( ) ) )
256
- } )
235
+ Visibility :: resolve ( db, & has_resolver. resolver ( db) , & raw_vis)
257
236
}
258
237
259
- /// Resolve visibility of a const.
260
- pub ( crate ) fn const_visibility_query ( db : & dyn DefDatabase , def : ConstId ) -> Visibility {
261
- let loc = def. lookup ( db) ;
262
- let resolver = def. resolver ( db) ;
263
- trait_item_visibility ( db, & resolver, loc. container ) . unwrap_or_else ( || {
264
- let source = loc. source ( db) ;
265
- visibility_from_ast ( db, & resolver, source. map ( |src| src. visibility ( ) ) )
266
- } )
238
+ /// Resolve visibility of a type alias.
239
+ pub ( crate ) fn assoc_visibility_query ( db : & dyn DefDatabase , def : AssocItemId ) -> Visibility {
240
+ match def {
241
+ AssocItemId :: FunctionId ( function_id) => {
242
+ let loc = function_id. lookup ( db) ;
243
+ trait_item_visibility ( db, loc. container ) . unwrap_or_else ( || {
244
+ let source = loc. source ( db) ;
245
+ visibility_from_ast ( db, function_id, source. map ( |src| src. visibility ( ) ) )
246
+ } )
247
+ }
248
+ AssocItemId :: ConstId ( const_id) => {
249
+ let loc = const_id. lookup ( db) ;
250
+ trait_item_visibility ( db, loc. container ) . unwrap_or_else ( || {
251
+ let source = loc. source ( db) ;
252
+ visibility_from_ast ( db, const_id, source. map ( |src| src. visibility ( ) ) )
253
+ } )
254
+ }
255
+ AssocItemId :: TypeAliasId ( type_alias_id) => {
256
+ let loc = type_alias_id. lookup ( db) ;
257
+ trait_item_visibility ( db, loc. container ) . unwrap_or_else ( || {
258
+ let source = loc. source ( db) ;
259
+ visibility_from_ast ( db, type_alias_id, source. map ( |src| src. visibility ( ) ) )
260
+ } )
261
+ }
262
+ }
267
263
}
268
264
269
- /// Resolve visibility of a type alias.
270
- pub ( crate ) fn type_alias_visibility_query ( db : & dyn DefDatabase , def : TypeAliasId ) -> Visibility {
271
- let loc = def. lookup ( db) ;
272
- let resolver = def. resolver ( db) ;
273
- trait_item_visibility ( db, & resolver, loc. container ) . unwrap_or_else ( || {
274
- let source = loc. source ( db) ;
275
- visibility_from_ast ( db, & resolver, source. map ( |src| src. visibility ( ) ) )
276
- } )
265
+ fn trait_item_visibility ( db : & dyn DefDatabase , container : ItemContainerId ) -> Option < Visibility > {
266
+ match container {
267
+ ItemContainerId :: TraitId ( trait_) => Some ( trait_visibility ( db, trait_) ) ,
268
+ _ => None ,
269
+ }
277
270
}
278
271
279
- pub ( crate ) fn trait_visibility (
280
- db : & dyn DefDatabase ,
281
- resolver : & Resolver < ' _ > ,
282
- def : TraitId ,
283
- ) -> Visibility {
272
+ fn trait_visibility ( db : & dyn DefDatabase , def : TraitId ) -> Visibility {
284
273
let loc = def. lookup ( db) ;
285
274
let source = loc. source ( db) ;
286
- visibility_from_ast ( db, resolver , source. map ( |src| src. visibility ( ) ) )
275
+ visibility_from_ast ( db, def , source. map ( |src| src. visibility ( ) ) )
287
276
}
0 commit comments