src/librustc_privacy/lib.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 #![crate_name = "rustc_privacy"]
  12 #![unstable(feature = "rustc_private", issue = "27812")]
  13 #![crate_type = "dylib"]
  14 #![crate_type = "rlib"]
  15 #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
  16       html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
  17       html_root_url = "https://doc.rust-lang.org/nightly/")]
  18 #![cfg_attr(not(stage0), deny(warnings))]
  19
  20 #![feature(rustc_diagnostic_macros)]
  21 #![feature(rustc_private)]
  22 #![feature(staged_api)]
  23
  24 #[macro_use] extern crate log;
  25 #[macro_use] extern crate syntax;
  26
  27 extern crate rustc;
  28 extern crate rustc_front;
  29
  30 use self::PrivacyResult::*;
  31 use self::FieldName::*;
  32
  33 use std::cmp;
  34 use std::mem::replace;
  35
  36 use rustc_front::hir::{self, PatKind};
  37 use rustc_front::intravisit::{self, Visitor};
  38
  39 use rustc::dep_graph::DepNode;
  40 use rustc::lint;
  41 use rustc::middle::def::{self, Def};
  42 use rustc::middle::def_id::DefId;
  43 use rustc::middle::privacy::{AccessLevel, AccessLevels};
  44 use rustc::middle::privacy::ExternalExports;
  45 use rustc::middle::ty::{self, TyCtxt};
  46 use rustc::util::nodemap::{NodeMap, NodeSet};
  47 use rustc::front::map as ast_map;
  48
  49 use syntax::ast;
  50 use syntax::codemap::Span;
  51
  52 pub mod diagnostics;
  53
  54 type Context<'a, 'tcx> = (&'a ty::MethodMap<'tcx>, &'a def::ExportMap);
  55
  56 /// Result of a checking operation - None => no errors were found. Some => an
  57 /// error and contains the span and message for reporting that error and
  58 /// optionally the same for a note about the error.
  59 type CheckResult = Option<(Span, String, Option<(Span, String)>)>;
  60
  61 ////////////////////////////////////////////////////////////////////////////////
  62 /// The parent visitor, used to determine what's the parent of what (node-wise)
  63 ////////////////////////////////////////////////////////////////////////////////
  64
  65 struct ParentVisitor<'a, 'tcx:'a> {
  66     tcx: &'a TyCtxt<'tcx>,
  67     parents: NodeMap<ast::NodeId>,
  68     curparent: ast::NodeId,
  69 }
  70
  71 impl<'a, 'tcx, 'v> Visitor<'v> for ParentVisitor<'a, 'tcx> {
  72     /// We want to visit items in the context of their containing
  73     /// module and so forth, so supply a crate for doing a deep walk.
  74     fn visit_nested_item(&mut self, item: hir::ItemId) {
  75         self.visit_item(self.tcx.map.expect_item(item.id))
  76     }
  77     fn visit_item(&mut self, item: &hir::Item) {
  78         self.parents.insert(item.id, self.curparent);
  79
  80         let prev = self.curparent;
  81         match item.node {
  82             hir::ItemMod(..) => { self.curparent = item.id; }
  83             // Enum variants are parented to the enum definition itself because
  84             // they inherit privacy
  85             hir::ItemEnum(ref def, _) => {
  86                 for variant in &def.variants {
  87                     // The parent is considered the enclosing enum because the
  88                     // enum will dictate the privacy visibility of this variant
  89                     // instead.
  90                     self.parents.insert(variant.node.data.id(), item.id);
  91                 }
  92             }
  93
  94             // Trait methods are always considered "public", but if the trait is
  95             // private then we need some private item in the chain from the
  96             // method to the root. In this case, if the trait is private, then
  97             // parent all the methods to the trait to indicate that they're
  98             // private.
  99             hir::ItemTrait(_, _, _, ref trait_items) if item.vis != hir::Public => {
 100                 for trait_item in trait_items {
 101                     self.parents.insert(trait_item.id, item.id);
 102                 }
 103             }
 104
 105             _ => {}
 106         }
 107         intravisit::walk_item(self, item);
 108         self.curparent = prev;
 109     }
 110
 111     fn visit_foreign_item(&mut self, a: &hir::ForeignItem) {
 112         self.parents.insert(a.id, self.curparent);
 113         intravisit::walk_foreign_item(self, a);
 114     }
 115
 116     fn visit_fn(&mut self, a: intravisit::FnKind<'v>, b: &'v hir::FnDecl,
 117                 c: &'v hir::Block, d: Span, id: ast::NodeId) {
 118         // We already took care of some trait methods above, otherwise things
 119         // like impl methods and pub trait methods are parented to the
 120         // containing module, not the containing trait.
 121         if !self.parents.contains_key(&id) {
 122             self.parents.insert(id, self.curparent);
 123         }
 124         intravisit::walk_fn(self, a, b, c, d);
 125     }
 126
 127     fn visit_impl_item(&mut self, ii: &'v hir::ImplItem) {
 128         // visit_fn handles methods, but associated consts have to be handled
 129         // here.
 130         if !self.parents.contains_key(&ii.id) {
 131             self.parents.insert(ii.id, self.curparent);
 132         }
 133         intravisit::walk_impl_item(self, ii);
 134     }
 135
 136     fn visit_variant_data(&mut self, s: &hir::VariantData, _: ast::Name,
 137                         _: &'v hir::Generics, item_id: ast::NodeId, _: Span) {
 138         // Struct constructors are parented to their struct definitions because
 139         // they essentially are the struct definitions.
 140         if !s.is_struct() {
 141             self.parents.insert(s.id(), item_id);
 142         }
 143
 144         // While we have the id of the struct definition, go ahead and parent
 145         // all the fields.
 146         for field in s.fields() {
 147             self.parents.insert(field.id, self.curparent);
 148         }
 149         intravisit::walk_struct_def(self, s)
 150     }
 151 }
 152
 153 ////////////////////////////////////////////////////////////////////////////////
 154 /// The embargo visitor, used to determine the exports of the ast
 155 ////////////////////////////////////////////////////////////////////////////////
 156
 157 struct EmbargoVisitor<'a, 'tcx: 'a> {
 158     tcx: &'a TyCtxt<'tcx>,
 159     export_map: &'a def::ExportMap,
 160
 161     // Accessibility levels for reachable nodes
 162     access_levels: AccessLevels,
 163     // Previous accessibility level, None means unreachable
 164     prev_level: Option<AccessLevel>,
 165     // Have something changed in the level map?
 166     changed: bool,
 167 }
 168
 169 struct ReachEverythingInTheInterfaceVisitor<'b, 'a: 'b, 'tcx: 'a> {
 170     ev: &'b mut EmbargoVisitor<'a, 'tcx>,
 171 }
 172
 173 impl<'a, 'tcx> EmbargoVisitor<'a, 'tcx> {
 174     fn ty_level(&self, ty: &hir::Ty) -> Option<AccessLevel> {
 175         if let hir::TyPath(..) = ty.node {
 176             match self.tcx.def_map.borrow().get(&ty.id).unwrap().full_def() {
 177                 Def::PrimTy(..) | Def::SelfTy(..) | Def::TyParam(..) => {
 178                     Some(AccessLevel::Public)
 179                 }
 180                 def => {
 181                     if let Some(node_id) = self.tcx.map.as_local_node_id(def.def_id()) {
 182                         self.get(node_id)
 183                     } else {
 184                         Some(AccessLevel::Public)
 185                     }
 186                 }
 187             }
 188         } else {
 189             Some(AccessLevel::Public)
 190         }
 191     }
 192
 193     fn trait_level(&self, trait_ref: &hir::TraitRef) -> Option<AccessLevel> {
 194         let did = self.tcx.trait_ref_to_def_id(trait_ref);
 195         if let Some(node_id) = self.tcx.map.as_local_node_id(did) {
 196             self.get(node_id)
 197         } else {
 198             Some(AccessLevel::Public)
 199         }
 200     }
 201
 202     fn get(&self, id: ast::NodeId) -> Option<AccessLevel> {
 203         self.access_levels.map.get(&id).cloned()
 204     }
 205
 206     // Updates node level and returns the updated level
 207     fn update(&mut self, id: ast::NodeId, level: Option<AccessLevel>) -> Option<AccessLevel> {
 208         let old_level = self.get(id);
 209         // Accessibility levels can only grow
 210         if level > old_level {
 211             self.access_levels.map.insert(id, level.unwrap());
 212             self.changed = true;
 213             level
 214         } else {
 215             old_level
 216         }
 217     }
 218
 219     fn reach<'b>(&'b mut self) -> ReachEverythingInTheInterfaceVisitor<'b, 'a, 'tcx> {
 220         ReachEverythingInTheInterfaceVisitor { ev: self }
 221     }
 222 }
 223
 224 impl<'a, 'tcx, 'v> Visitor<'v> for EmbargoVisitor<'a, 'tcx> {
 225     /// We want to visit items in the context of their containing
 226     /// module and so forth, so supply a crate for doing a deep walk.
 227     fn visit_nested_item(&mut self, item: hir::ItemId) {
 228         self.visit_item(self.tcx.map.expect_item(item.id))
 229     }
 230
 231     fn visit_item(&mut self, item: &hir::Item) {
 232         let inherited_item_level = match item.node {
 233             // Impls inherit level from their types and traits
 234             hir::ItemImpl(_, _, _, None, ref ty, _) => {
 235                 self.ty_level(&ty)
 236             }
 237             hir::ItemImpl(_, _, _, Some(ref trait_ref), ref ty, _) => {
 238                 cmp::min(self.ty_level(&ty), self.trait_level(trait_ref))
 239             }
 240             hir::ItemDefaultImpl(_, ref trait_ref) => {
 241                 self.trait_level(trait_ref)
 242             }
 243             // Foreign mods inherit level from parents
 244             hir::ItemForeignMod(..) => {
 245                 self.prev_level
 246             }
 247             // Other `pub` items inherit levels from parents
 248             _ => {
 249                 if item.vis == hir::Public { self.prev_level } else { None }
 250             }
 251         };
 252
 253         // Update level of the item itself
 254         let item_level = self.update(item.id, inherited_item_level);
 255
 256         // Update levels of nested things
 257         match item.node {
 258             hir::ItemEnum(ref def, _) => {
 259                 for variant in &def.variants {
 260                     let variant_level = self.update(variant.node.data.id(), item_level);
 261                     for field in variant.node.data.fields() {
 262                         self.update(field.id, variant_level);
 263                     }
 264                 }
 265             }
 266             hir::ItemImpl(_, _, _, None, _, ref impl_items) => {
 267                 for impl_item in impl_items {
 268                     if impl_item.vis == hir::Public {
 269                         self.update(impl_item.id, item_level);
 270                     }
 271                 }
 272             }
 273             hir::ItemImpl(_, _, _, Some(_), _, ref impl_items) => {
 274                 for impl_item in impl_items {
 275                     self.update(impl_item.id, item_level);
 276                 }
 277             }
 278             hir::ItemTrait(_, _, _, ref trait_items) => {
 279                 for trait_item in trait_items {
 280                     self.update(trait_item.id, item_level);
 281                 }
 282             }
 283             hir::ItemStruct(ref def, _) => {
 284                 if !def.is_struct() {
 285                     self.update(def.id(), item_level);
 286                 }
 287                 for field in def.fields() {
 288                     if field.vis == hir::Public {
 289                         self.update(field.id, item_level);
 290                     }
 291                 }
 292             }
 293             hir::ItemForeignMod(ref foreign_mod) => {
 294                 for foreign_item in &foreign_mod.items {
 295                     if foreign_item.vis == hir::Public {
 296                         self.update(foreign_item.id, item_level);
 297                     }
 298                 }
 299             }
 300             _ => {}
 301         }
 302
 303         // Mark all items in interfaces of reachable items as reachable
 304         match item.node {
 305             // The interface is empty
 306             hir::ItemExternCrate(..) => {}
 307             // All nested items are checked by visit_item
 308             hir::ItemMod(..) => {}
 309             // Reexports are handled in visit_mod
 310             hir::ItemUse(..) => {}
 311             // Visit everything
 312             hir::ItemConst(..) | hir::ItemStatic(..) | hir::ItemFn(..) |
 313             hir::ItemTrait(..) | hir::ItemTy(..) | hir::ItemImpl(_, _, _, Some(..), _, _) => {
 314                 if item_level.is_some() {
 315                     self.reach().visit_item(item);
 316                 }
 317             }
 318             // Visit everything, but enum variants have their own levels
 319             hir::ItemEnum(ref def, ref generics) => {
 320                 if item_level.is_some() {
 321                     self.reach().visit_generics(generics);
 322                 }
 323                 for variant in &def.variants {
 324                     if self.get(variant.node.data.id()).is_some() {
 325                         for field in variant.node.data.fields() {
 326                             self.reach().visit_struct_field(field);
 327                         }
 328                         // Corner case: if the variant is reachable, but its
 329                         // enum is not, make the enum reachable as well.
 330                         self.update(item.id, Some(AccessLevel::Reachable));
 331                     }
 332                 }
 333             }
 334             // Visit everything, but foreign items have their own levels
 335             hir::ItemForeignMod(ref foreign_mod) => {
 336                 for foreign_item in &foreign_mod.items {
 337                     if self.get(foreign_item.id).is_some() {
 338                         self.reach().visit_foreign_item(foreign_item);
 339                     }
 340                 }
 341             }
 342             // Visit everything except for private fields
 343             hir::ItemStruct(ref struct_def, ref generics) => {
 344                 if item_level.is_some() {
 345                     self.reach().visit_generics(generics);
 346                     for field in struct_def.fields() {
 347                         if self.get(field.id).is_some() {
 348                             self.reach().visit_struct_field(field);
 349                         }
 350                     }
 351                 }
 352             }
 353             // The interface is empty
 354             hir::ItemDefaultImpl(..) => {}
 355             // Visit everything except for private impl items
 356             hir::ItemImpl(_, _, ref generics, None, _, ref impl_items) => {
 357                 if item_level.is_some() {
 358                     self.reach().visit_generics(generics);
 359                     for impl_item in impl_items {
 360                         if self.get(impl_item.id).is_some() {
 361                             self.reach().visit_impl_item(impl_item);
 362                         }
 363                     }
 364                 }
 365             }
 366         }
 367
 368         let orig_level = self.prev_level;
 369         self.prev_level = item_level;
 370
 371         intravisit::walk_item(self, item);
 372
 373         self.prev_level = orig_level;
 374     }
 375
 376     fn visit_block(&mut self, b: &'v hir::Block) {
 377         let orig_level = replace(&mut self.prev_level, None);
 378
 379         // Blocks can have public items, for example impls, but they always
 380         // start as completely private regardless of publicity of a function,
 381         // constant, type, field, etc. in which this block resides
 382         intravisit::walk_block(self, b);
 383
 384         self.prev_level = orig_level;
 385     }
 386
 387     fn visit_mod(&mut self, m: &hir::Mod, _sp: Span, id: ast::NodeId) {
 388         // This code is here instead of in visit_item so that the
 389         // crate module gets processed as well.
 390         if self.prev_level.is_some() {
 391             if let Some(exports) = self.export_map.get(&id) {
 392                 for export in exports {
 393                     if let Some(node_id) = self.tcx.map.as_local_node_id(export.def_id) {
 394                         self.update(node_id, Some(AccessLevel::Exported));
 395                     }
 396                 }
 397             }
 398         }
 399
 400         intravisit::walk_mod(self, m);
 401     }
 402
 403     fn visit_macro_def(&mut self, md: &'v hir::MacroDef) {
 404         self.update(md.id, Some(AccessLevel::Public));
 405     }
 406 }
 407
 408 impl<'b, 'a, 'tcx: 'a> ReachEverythingInTheInterfaceVisitor<'b, 'a, 'tcx> {
 409     // Make the type hidden under a type alias reachable
 410     fn reach_aliased_type(&mut self, item: &hir::Item, path: &hir::Path) {
 411         if let hir::ItemTy(ref ty, ref generics) = item.node {
 412             // See `fn is_public_type_alias` for details
 413             self.visit_ty(ty);
 414             let provided_params = path.segments.last().unwrap().parameters.types().len();
 415             for ty_param in &generics.ty_params[provided_params..] {
 416                 if let Some(ref default_ty) = ty_param.default {
 417                     self.visit_ty(default_ty);
 418                 }
 419             }
 420         }
 421     }
 422 }
 423
 424 impl<'b, 'a, 'tcx: 'a, 'v> Visitor<'v> for ReachEverythingInTheInterfaceVisitor<'b, 'a, 'tcx> {
 425     fn visit_ty(&mut self, ty: &hir::Ty) {
 426         if let hir::TyPath(_, ref path) = ty.node {
 427             let def = self.ev.tcx.def_map.borrow().get(&ty.id).unwrap().full_def();
 428             match def {
 429                 Def::Struct(def_id) | Def::Enum(def_id) | Def::TyAlias(def_id) |
 430                 Def::Trait(def_id) | Def::AssociatedTy(def_id, _) => {
 431                     if let Some(node_id) = self.ev.tcx.map.as_local_node_id(def_id) {
 432                         let item = self.ev.tcx.map.expect_item(node_id);
 433                         if let Def::TyAlias(..) = def {
 434                             // Type aliases are substituted. Associated type aliases are not
 435                             // substituted yet, but ideally they should be.
 436                             if self.ev.get(item.id).is_none() {
 437                                 self.reach_aliased_type(item, path);
 438                             }
 439                         } else {
 440                             self.ev.update(item.id, Some(AccessLevel::Reachable));
 441                         }
 442                     }
 443                 }
 444
 445                 _ => {}
 446             }
 447         }
 448
 449         intravisit::walk_ty(self, ty);
 450     }
 451
 452     fn visit_trait_ref(&mut self, trait_ref: &hir::TraitRef) {
 453         let def_id = self.ev.tcx.trait_ref_to_def_id(trait_ref);
 454         if let Some(node_id) = self.ev.tcx.map.as_local_node_id(def_id) {
 455             let item = self.ev.tcx.map.expect_item(node_id);
 456             self.ev.update(item.id, Some(AccessLevel::Reachable));
 457         }
 458
 459         intravisit::walk_trait_ref(self, trait_ref);
 460     }
 461
 462     // Don't recurse into function bodies
 463     fn visit_block(&mut self, _: &hir::Block) {}
 464     // Don't recurse into expressions in array sizes or const initializers
 465     fn visit_expr(&mut self, _: &hir::Expr) {}
 466     // Don't recurse into patterns in function arguments
 467     fn visit_pat(&mut self, _: &hir::Pat) {}
 468 }
 469
 470 ////////////////////////////////////////////////////////////////////////////////
 471 /// The privacy visitor, where privacy checks take place (violations reported)
 472 ////////////////////////////////////////////////////////////////////////////////
 473
 474 struct PrivacyVisitor<'a, 'tcx: 'a> {
 475     tcx: &'a TyCtxt<'tcx>,
 476     curitem: ast::NodeId,
 477     in_foreign: bool,
 478     parents: NodeMap<ast::NodeId>,
 479     external_exports: ExternalExports,
 480 }
 481
 482 #[derive(Debug)]
 483 enum PrivacyResult {
 484     Allowable,
 485     ExternallyDenied,
 486     DisallowedBy(ast::NodeId),
 487 }
 488
 489 enum FieldName {
 490     UnnamedField(usize), // index
 491     NamedField(ast::Name),
 492 }
 493
 494 impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
 495     // used when debugging
 496     fn nodestr(&self, id: ast::NodeId) -> String {
 497         self.tcx.map.node_to_string(id).to_string()
 498     }
 499
 500     // Determines whether the given definition is public from the point of view
 501     // of the current item.
 502     fn def_privacy(&self, did: DefId) -> PrivacyResult {
 503         let node_id = if let Some(node_id) = self.tcx.map.as_local_node_id(did) {
 504             node_id
 505         } else {
 506             if self.external_exports.contains(&did) {
 507                 debug!("privacy - {:?} was externally exported", did);
 508                 return Allowable;
 509             }
 510             debug!("privacy - is {:?} a public method", did);
 511
 512             return match self.tcx.impl_or_trait_items.borrow().get(&did) {
 513                 Some(&ty::ConstTraitItem(ref ac)) => {
 514                     debug!("privacy - it's a const: {:?}", *ac);
 515                     match ac.container {
 516                         ty::TraitContainer(id) => {
 517                             debug!("privacy - recursing on trait {:?}", id);
 518                             self.def_privacy(id)
 519                         }
 520                         ty::ImplContainer(id) => {
 521                             match self.tcx.impl_trait_ref(id) {
 522                                 Some(t) => {
 523                                     debug!("privacy - impl of trait {:?}", id);
 524                                     self.def_privacy(t.def_id)
 525                                 }
 526                                 None => {
 527                                     debug!("privacy - found inherent \
 528                                             associated constant {:?}",
 529                                             ac.vis);
 530                                     if ac.vis == hir::Public {
 531                                         Allowable
 532                                     } else {
 533                                         ExternallyDenied
 534                                     }
 535                                 }
 536                             }
 537                         }
 538                     }
 539                 }
 540                 Some(&ty::MethodTraitItem(ref meth)) => {
 541                     debug!("privacy - well at least it's a method: {:?}",
 542                            *meth);
 543                     match meth.container {
 544                         ty::TraitContainer(id) => {
 545                             debug!("privacy - recursing on trait {:?}", id);
 546                             self.def_privacy(id)
 547                         }
 548                         ty::ImplContainer(id) => {
 549                             match self.tcx.impl_trait_ref(id) {
 550                                 Some(t) => {
 551                                     debug!("privacy - impl of trait {:?}", id);
 552                                     self.def_privacy(t.def_id)
 553                                 }
 554                                 None => {
 555                                     debug!("privacy - found a method {:?}",
 556                                             meth.vis);
 557                                     if meth.vis == hir::Public {
 558                                         Allowable
 559                                     } else {
 560                                         ExternallyDenied
 561                                     }
 562                                 }
 563                             }
 564                         }
 565                     }
 566                 }
 567                 Some(&ty::TypeTraitItem(ref typedef)) => {
 568                     match typedef.container {
 569                         ty::TraitContainer(id) => {
 570                             debug!("privacy - recursing on trait {:?}", id);
 571                             self.def_privacy(id)
 572                         }
 573                         ty::ImplContainer(id) => {
 574                             match self.tcx.impl_trait_ref(id) {
 575                                 Some(t) => {
 576                                     debug!("privacy - impl of trait {:?}", id);
 577                                     self.def_privacy(t.def_id)
 578                                 }
 579                                 None => {
 580                                     debug!("privacy - found a typedef {:?}",
 581                                             typedef.vis);
 582                                     if typedef.vis == hir::Public {
 583                                         Allowable
 584                                     } else {
 585                                         ExternallyDenied
 586                                     }
 587                                 }
 588                             }
 589                         }
 590                     }
 591                 }
 592                 None => {
 593                     debug!("privacy - nope, not even a method");
 594                     ExternallyDenied
 595                 }
 596             };
 597         };
 598
 599         debug!("privacy - local {} not public all the way down",
 600                self.tcx.map.node_to_string(node_id));
 601         // return quickly for things in the same module
 602         if self.parents.get(&node_id) == self.parents.get(&self.curitem) {
 603             debug!("privacy - same parent, we're done here");
 604             return Allowable;
 605         }
 606
 607         // We now know that there is at least one private member between the
 608         // destination and the root.
 609         let mut closest_private_id = node_id;
 610         loop {
 611             debug!("privacy - examining {}", self.nodestr(closest_private_id));
 612             let vis = match self.tcx.map.find(closest_private_id) {
 613                 // If this item is a method, then we know for sure that it's an
 614                 // actual method and not a static method. The reason for this is
 615                 // that these cases are only hit in the ExprMethodCall
 616                 // expression, and ExprCall will have its path checked later
 617                 // (the path of the trait/impl) if it's a static method.
 618                 //
 619                 // With this information, then we can completely ignore all
 620                 // trait methods. The privacy violation would be if the trait
 621                 // couldn't get imported, not if the method couldn't be used
 622                 // (all trait methods are public).
 623                 //
 624                 // However, if this is an impl method, then we dictate this
 625                 // decision solely based on the privacy of the method
 626                 // invocation.
 627                 // FIXME(#10573) is this the right behavior? Why not consider
 628                 //               where the method was defined?
 629                 Some(ast_map::NodeImplItem(ii)) => {
 630                     match ii.node {
 631                         hir::ImplItemKind::Const(..) |
 632                         hir::ImplItemKind::Method(..) => {
 633                             let imp = self.tcx.map
 634                                           .get_parent_did(closest_private_id);
 635                             match self.tcx.impl_trait_ref(imp) {
 636                                 Some(..) => return Allowable,
 637                                 _ if ii.vis == hir::Public => {
 638                                     return Allowable
 639                                 }
 640                                 _ => ii.vis
 641                             }
 642                         }
 643                         hir::ImplItemKind::Type(_) => return Allowable,
 644                     }
 645                 }
 646                 Some(ast_map::NodeTraitItem(_)) => {
 647                     return Allowable;
 648                 }
 649
 650                 // This is not a method call, extract the visibility as one
 651                 // would normally look at it
 652                 Some(ast_map::NodeItem(it)) => it.vis,
 653                 Some(ast_map::NodeForeignItem(_)) => {
 654                     self.tcx.map.get_foreign_vis(closest_private_id)
 655                 }
 656                 Some(ast_map::NodeVariant(..)) => {
 657                     hir::Public // need to move up a level (to the enum)
 658                 }
 659                 _ => hir::Public,
 660             };
 661             if vis != hir::Public { break }
 662             // if we've reached the root, then everything was allowable and this
 663             // access is public.
 664             if closest_private_id == ast::CRATE_NODE_ID { return Allowable }
 665             closest_private_id = *self.parents.get(&closest_private_id).unwrap();
 666
 667             // If we reached the top, then we were public all the way down and
 668             // we can allow this access.
 669             if closest_private_id == ast::DUMMY_NODE_ID { return Allowable }
 670         }
 671         debug!("privacy - closest priv {}", self.nodestr(closest_private_id));
 672         if self.private_accessible(closest_private_id) {
 673             Allowable
 674         } else {
 675             DisallowedBy(closest_private_id)
 676         }
 677     }
 678
 679     /// True if `id` is both local and private-accessible
 680     fn local_private_accessible(&self, did: DefId) -> bool {
 681         if let Some(node_id) = self.tcx.map.as_local_node_id(did) {
 682             self.private_accessible(node_id)
 683         } else {
 684             false
 685         }
 686     }
 687
 688     /// For a local private node in the AST, this function will determine
 689     /// whether the node is accessible by the current module that iteration is
 690     /// inside.
 691     fn private_accessible(&self, id: ast::NodeId) -> bool {
 692         self.tcx.map.private_item_is_visible_from(id, self.curitem)
 693     }
 694
 695     fn report_error(&self, result: CheckResult) -> bool {
 696         match result {
 697             None => true,
 698             Some((span, msg, note)) => {
 699                 let mut err = self.tcx.sess.struct_span_err(span, &msg[..]);
 700                 if let Some((span, msg)) = note {
 701                     err.span_note(span, &msg[..]);
 702                 }
 703                 err.emit();
 704                 false
 705             },
 706         }
 707     }
 708
 709     /// Guarantee that a particular definition is public. Returns a CheckResult
 710     /// which contains any errors found. These can be reported using `report_error`.
 711     /// If the result is `None`, no errors were found.
 712     fn ensure_public(&self,
 713                      span: Span,
 714                      to_check: DefId,
 715                      source_did: Option<DefId>,
 716                      msg: &str)
 717                      -> CheckResult {
 718         debug!("ensure_public(span={:?}, to_check={:?}, source_did={:?}, msg={:?})",
 719                span, to_check, source_did, msg);
 720         let def_privacy = self.def_privacy(to_check);
 721         debug!("ensure_public: def_privacy={:?}", def_privacy);
 722         let id = match def_privacy {
 723             ExternallyDenied => {
 724                 return Some((span, format!("{} is private", msg), None))
 725             }
 726             Allowable => return None,
 727             DisallowedBy(id) => id,
 728         };
 729
 730         // If we're disallowed by a particular id, then we attempt to
 731         // give a nice error message to say why it was disallowed. It
 732         // was either because the item itself is private or because
 733         // its parent is private and its parent isn't in our
 734         // ancestry. (Both the item being checked and its parent must
 735         // be local.)
 736         let def_id = source_did.unwrap_or(to_check);
 737         let node_id = self.tcx.map.as_local_node_id(def_id);
 738
 739         let (err_span, err_msg) = if Some(id) == node_id {
 740             return Some((span, format!("{} is private", msg), None));
 741         } else {
 742             (span, format!("{} is inaccessible", msg))
 743         };
 744         let item = match self.tcx.map.find(id) {
 745             Some(ast_map::NodeItem(item)) => {
 746                 match item.node {
 747                     // If an impl disallowed this item, then this is resolve's
 748                     // way of saying that a struct/enum's static method was
 749                     // invoked, and the struct/enum itself is private. Crawl
 750                     // back up the chains to find the relevant struct/enum that
 751                     // was private.
 752                     hir::ItemImpl(_, _, _, _, ref ty, _) => {
 753                         match ty.node {
 754                             hir::TyPath(..) => {}
 755                             _ => return Some((err_span, err_msg, None)),
 756                         };
 757                         let def = self.tcx.def_map.borrow().get(&ty.id).unwrap().full_def();
 758                         let did = def.def_id();
 759                         let node_id = self.tcx.map.as_local_node_id(did).unwrap();
 760                         match self.tcx.map.get(node_id) {
 761                             ast_map::NodeItem(item) => item,
 762                             _ => self.tcx.sess.span_bug(item.span,
 763                                                         "path is not an item")
 764                         }
 765                     }
 766                     _ => item
 767                 }
 768             }
 769             Some(..) | None => return Some((err_span, err_msg, None)),
 770         };
 771         let desc = match item.node {
 772             hir::ItemMod(..) => "module",
 773             hir::ItemTrait(..) => "trait",
 774             hir::ItemStruct(..) => "struct",
 775             hir::ItemEnum(..) => "enum",
 776             _ => return Some((err_span, err_msg, None))
 777         };
 778         let msg = format!("{} `{}` is private", desc, item.name);
 779         Some((err_span, err_msg, Some((span, msg))))
 780     }
 781
 782     // Checks that a field is in scope.
 783     fn check_field(&mut self,
 784                    span: Span,
 785                    def: ty::AdtDef<'tcx>,
 786                    v: ty::VariantDef<'tcx>,
 787                    name: FieldName) {
 788         let field = match name {
 789             NamedField(f_name) => {
 790                 debug!("privacy - check named field {} in struct {:?}", f_name, def);
 791                 v.field_named(f_name)
 792             }
 793             UnnamedField(idx) => &v.fields[idx]
 794         };
 795         if field.vis == hir::Public || self.local_private_accessible(def.did) {
 796             return;
 797         }
 798
 799         let struct_desc = match def.adt_kind() {
 800             ty::AdtKind::Struct =>
 801                 format!("struct `{}`", self.tcx.item_path_str(def.did)),
 802             // struct variant fields have inherited visibility
 803             ty::AdtKind::Enum => return
 804         };
 805         let msg = match name {
 806             NamedField(name) => format!("field `{}` of {} is private",
 807                                         name, struct_desc),
 808             UnnamedField(idx) => format!("field #{} of {} is private",
 809                                          idx, struct_desc),
 810         };
 811         span_err!(self.tcx.sess, span, E0451,
 812                   "{}", &msg[..]);
 813     }
 814
 815     // Given the ID of a method, checks to ensure it's in scope.
 816     fn check_static_method(&mut self,
 817                            span: Span,
 818                            method_id: DefId,
 819                            name: ast::Name) {
 820         self.report_error(self.ensure_public(span,
 821                                              method_id,
 822                                              None,
 823                                              &format!("method `{}`",
 824                                                      name)));
 825     }
 826
 827     // Checks that a method is in scope.
 828     fn check_method(&mut self, span: Span, method_def_id: DefId,
 829                     name: ast::Name) {
 830         match self.tcx.impl_or_trait_item(method_def_id).container() {
 831             ty::ImplContainer(_) => {
 832                 self.check_static_method(span, method_def_id, name)
 833             }
 834             // Trait methods are always all public. The only controlling factor
 835             // is whether the trait itself is accessible or not.
 836             ty::TraitContainer(trait_def_id) => {
 837                 self.report_error(self.ensure_public(span, trait_def_id,
 838                                                      None, "source trait"));
 839             }
 840         }
 841     }
 842 }
 843
 844 impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> {
 845     /// We want to visit items in the context of their containing
 846     /// module and so forth, so supply a crate for doing a deep walk.
 847     fn visit_nested_item(&mut self, item: hir::ItemId) {
 848         self.visit_item(self.tcx.map.expect_item(item.id))
 849     }
 850
 851     fn visit_item(&mut self, item: &hir::Item) {
 852         let orig_curitem = replace(&mut self.curitem, item.id);
 853         intravisit::walk_item(self, item);
 854         self.curitem = orig_curitem;
 855     }
 856
 857     fn visit_expr(&mut self, expr: &hir::Expr) {
 858         match expr.node {
 859             hir::ExprField(ref base, name) => {
 860                 if let ty::TyStruct(def, _) = self.tcx.expr_ty_adjusted(&base).sty {
 861                     self.check_field(expr.span,
 862                                      def,
 863                                      def.struct_variant(),
 864                                      NamedField(name.node));
 865                 }
 866             }
 867             hir::ExprTupField(ref base, idx) => {
 868                 if let ty::TyStruct(def, _) = self.tcx.expr_ty_adjusted(&base).sty {
 869                     self.check_field(expr.span,
 870                                      def,
 871                                      def.struct_variant(),
 872                                      UnnamedField(idx.node));
 873                 }
 874             }
 875             hir::ExprMethodCall(name, _, _) => {
 876                 let method_call = ty::MethodCall::expr(expr.id);
 877                 let method = self.tcx.tables.borrow().method_map[&method_call];
 878                 debug!("(privacy checking) checking impl method");
 879                 self.check_method(expr.span, method.def_id, name.node);
 880             }
 881             hir::ExprStruct(..) => {
 882                 let adt = self.tcx.expr_ty(expr).ty_adt_def().unwrap();
 883                 let variant = adt.variant_of_def(self.tcx.resolve_expr(expr));
 884                 // RFC 736: ensure all unmentioned fields are visible.
 885                 // Rather than computing the set of unmentioned fields
 886                 // (i.e. `all_fields - fields`), just check them all.
 887                 for field in &variant.fields {
 888                     self.check_field(expr.span, adt, variant, NamedField(field.name));
 889                 }
 890             }
 891             hir::ExprPath(..) => {
 892
 893                 if let Def::Struct(..) = self.tcx.resolve_expr(expr) {
 894                     let expr_ty = self.tcx.expr_ty(expr);
 895                     let def = match expr_ty.sty {
 896                         ty::TyBareFn(_, &ty::BareFnTy { sig: ty::Binder(ty::FnSig {
 897                             output: ty::FnConverging(ty), ..
 898                         }), ..}) => ty,
 899                         _ => expr_ty
 900                     }.ty_adt_def().unwrap();
 901                     let any_priv = def.struct_variant().fields.iter().any(|f| {
 902                         f.vis != hir::Public && !self.local_private_accessible(def.did)
 903                     });
 904                     if any_priv {
 905                         span_err!(self.tcx.sess, expr.span, E0450,
 906                                   "cannot invoke tuple struct constructor with private \
 907                                    fields");
 908                     }
 909                 }
 910             }
 911             _ => {}
 912         }
 913
 914         intravisit::walk_expr(self, expr);
 915     }
 916
 917     fn visit_pat(&mut self, pattern: &hir::Pat) {
 918         // Foreign functions do not have their patterns mapped in the def_map,
 919         // and there's nothing really relevant there anyway, so don't bother
 920         // checking privacy. If you can name the type then you can pass it to an
 921         // external C function anyway.
 922         if self.in_foreign { return }
 923
 924         match pattern.node {
 925             PatKind::Struct(_, ref fields, _) => {
 926                 let adt = self.tcx.pat_ty(pattern).ty_adt_def().unwrap();
 927                 let def = self.tcx.def_map.borrow().get(&pattern.id).unwrap().full_def();
 928                 let variant = adt.variant_of_def(def);
 929                 for field in fields {
 930                     self.check_field(pattern.span, adt, variant,
 931                                      NamedField(field.node.name));
 932                 }
 933             }
 934
 935             // Patterns which bind no fields are allowable (the path is check
 936             // elsewhere).
 937             PatKind::TupleStruct(_, Some(ref fields)) => {
 938                 match self.tcx.pat_ty(pattern).sty {
 939                     ty::TyStruct(def, _) => {
 940                         for (i, field) in fields.iter().enumerate() {
 941                             if let PatKind::Wild = field.node {
 942                                 continue
 943                             }
 944                             self.check_field(field.span,
 945                                              def,
 946                                              def.struct_variant(),
 947                                              UnnamedField(i));
 948                         }
 949                     }
 950                     ty::TyEnum(..) => {
 951                         // enum fields have no privacy at this time
 952                     }
 953                     _ => {}
 954                 }
 955
 956             }
 957             _ => {}
 958         }
 959
 960         intravisit::walk_pat(self, pattern);
 961     }
 962
 963     fn visit_foreign_item(&mut self, fi: &hir::ForeignItem) {
 964         self.in_foreign = true;
 965         intravisit::walk_foreign_item(self, fi);
 966         self.in_foreign = false;
 967     }
 968 }
 969
 970 ////////////////////////////////////////////////////////////////////////////////
 971 /// The privacy sanity check visitor, ensures unnecessary visibility isn't here
 972 ////////////////////////////////////////////////////////////////////////////////
 973
 974 struct SanePrivacyVisitor<'a, 'tcx: 'a> {
 975     tcx: &'a TyCtxt<'tcx>,
 976 }
 977
 978 impl<'a, 'tcx, 'v> Visitor<'v> for SanePrivacyVisitor<'a, 'tcx> {
 979     fn visit_item(&mut self, item: &hir::Item) {
 980         self.check_sane_privacy(item);
 981         intravisit::walk_item(self, item);
 982     }
 983 }
 984
 985 impl<'a, 'tcx> SanePrivacyVisitor<'a, 'tcx> {
 986     /// Validate that items that shouldn't have visibility qualifiers don't have them.
 987     /// Such qualifiers can be set by syntax extensions even if the parser doesn't allow them,
 988     /// so we check things like variant fields too.
 989     fn check_sane_privacy(&self, item: &hir::Item) {
 990         let check_inherited = |sp, vis, note: &str| {
 991             if vis != hir::Inherited {
 992                 let mut err = struct_span_err!(self.tcx.sess, sp, E0449,
 993                                                "unnecessary visibility qualifier");
 994                 if !note.is_empty() {
 995                     err.span_note(sp, note);
 996                 }
 997                 err.emit();
 998             }
 999         };
1000
1001         match item.node {
1002             hir::ItemImpl(_, _, _, Some(..), _, ref impl_items) => {
1003                 check_inherited(item.span, item.vis,
1004                                 "visibility qualifiers have no effect on trait impls");
1005                 for impl_item in impl_items {
1006                     check_inherited(impl_item.span, impl_item.vis,
1007                                     "visibility qualifiers have no effect on trait impl items");
1008                 }
1009             }
1010             hir::ItemImpl(_, _, _, None, _, _) => {
1011                 check_inherited(item.span, item.vis,
1012                                 "place qualifiers on individual methods instead");
1013             }
1014             hir::ItemDefaultImpl(..) => {
1015                 check_inherited(item.span, item.vis,
1016                                 "visibility qualifiers have no effect on trait impls");
1017             }
1018             hir::ItemForeignMod(..) => {
1019                 check_inherited(item.span, item.vis,
1020                                 "place qualifiers on individual functions instead");
1021             }
1022             hir::ItemEnum(ref def, _) => {
1023                 for variant in &def.variants {
1024                     for field in variant.node.data.fields() {
1025                         check_inherited(field.span, field.vis,
1026                                         "visibility qualifiers have no effect on variant fields");
1027                     }
1028                 }
1029             }
1030             hir::ItemStruct(..) | hir::ItemTrait(..) |
1031             hir::ItemConst(..) | hir::ItemStatic(..) | hir::ItemFn(..) |
1032             hir::ItemMod(..) | hir::ItemExternCrate(..) |
1033             hir::ItemUse(..) | hir::ItemTy(..) => {}
1034         }
1035     }
1036 }
1037
1038 ///////////////////////////////////////////////////////////////////////////////
1039 /// Obsolete visitors for checking for private items in public interfaces.
1040 /// These visitors are supposed to be kept in frozen state and produce an
1041 /// "old error node set". For backward compatibility the new visitor reports
1042 /// warnings instead of hard errors when the erroneous node is not in this old set.
1043 ///////////////////////////////////////////////////////////////////////////////
1044
1045 struct ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx: 'a> {
1046     tcx: &'a TyCtxt<'tcx>,
1047     access_levels: &'a AccessLevels,
1048     in_variant: bool,
1049     // set of errors produced by this obsolete visitor
1050     old_error_set: NodeSet,
1051 }
1052
1053 struct ObsoleteCheckTypeForPrivatenessVisitor<'a, 'b: 'a, 'tcx: 'b> {
1054     inner: &'a ObsoleteVisiblePrivateTypesVisitor<'b, 'tcx>,
1055     /// whether the type refers to private types.
1056     contains_private: bool,
1057     /// whether we've recurred at all (i.e. if we're pointing at the
1058     /// first type on which visit_ty was called).
1059     at_outer_type: bool,
1060     // whether that first type is a public path.
1061     outer_type_is_public_path: bool,
1062 }
1063
1064 impl<'a, 'tcx> ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> {
1065     fn path_is_private_type(&self, path_id: ast::NodeId) -> bool {
1066         let did = match self.tcx.def_map.borrow().get(&path_id).map(|d| d.full_def()) {
1067             // `int` etc. (None doesn't seem to occur.)
1068             None | Some(Def::PrimTy(..)) | Some(Def::SelfTy(..)) => return false,
1069             Some(def) => def.def_id(),
1070         };
1071
1072         // A path can only be private if:
1073         // it's in this crate...
1074         if let Some(node_id) = self.tcx.map.as_local_node_id(did) {
1075             // .. and it corresponds to a private type in the AST (this returns
1076             // None for type parameters)
1077             match self.tcx.map.find(node_id) {
1078                 Some(ast_map::NodeItem(ref item)) => item.vis != hir::Public,
1079                 Some(_) | None => false,
1080             }
1081         } else {
1082             return false
1083         }
1084     }
1085
1086     fn trait_is_public(&self, trait_id: ast::NodeId) -> bool {
1087         // FIXME: this would preferably be using `exported_items`, but all
1088         // traits are exported currently (see `EmbargoVisitor.exported_trait`)
1089         self.access_levels.is_public(trait_id)
1090     }
1091
1092     fn check_ty_param_bound(&mut self,
1093                             ty_param_bound: &hir::TyParamBound) {
1094         if let hir::TraitTyParamBound(ref trait_ref, _) = *ty_param_bound {
1095             if self.path_is_private_type(trait_ref.trait_ref.ref_id) {
1096                 self.old_error_set.insert(trait_ref.trait_ref.ref_id);
1097             }
1098         }
1099     }
1100
1101     fn item_is_public(&self, id: &ast::NodeId, vis: hir::Visibility) -> bool {
1102         self.access_levels.is_reachable(*id) || vis == hir::Public
1103     }
1104 }
1105
1106 impl<'a, 'b, 'tcx, 'v> Visitor<'v> for ObsoleteCheckTypeForPrivatenessVisitor<'a, 'b, 'tcx> {
1107     fn visit_ty(&mut self, ty: &hir::Ty) {
1108         if let hir::TyPath(..) = ty.node {
1109             if self.inner.path_is_private_type(ty.id) {
1110                 self.contains_private = true;
1111                 // found what we're looking for so let's stop
1112                 // working.
1113                 return
1114             } else if self.at_outer_type {
1115                 self.outer_type_is_public_path = true;
1116             }
1117         }
1118         self.at_outer_type = false;
1119         intravisit::walk_ty(self, ty)
1120     }
1121
1122     // don't want to recurse into [, .. expr]
1123     fn visit_expr(&mut self, _: &hir::Expr) {}
1124 }
1125
1126 impl<'a, 'tcx, 'v> Visitor<'v> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> {
1127     /// We want to visit items in the context of their containing
1128     /// module and so forth, so supply a crate for doing a deep walk.
1129     fn visit_nested_item(&mut self, item: hir::ItemId) {
1130         self.visit_item(self.tcx.map.expect_item(item.id))
1131     }
1132
1133     fn visit_item(&mut self, item: &hir::Item) {
1134         match item.node {
1135             // contents of a private mod can be reexported, so we need
1136             // to check internals.
1137             hir::ItemMod(_) => {}
1138
1139             // An `extern {}` doesn't introduce a new privacy
1140             // namespace (the contents have their own privacies).
1141             hir::ItemForeignMod(_) => {}
1142
1143             hir::ItemTrait(_, _, ref bounds, _) => {
1144                 if !self.trait_is_public(item.id) {
1145                     return
1146                 }
1147
1148                 for bound in bounds.iter() {
1149                     self.check_ty_param_bound(bound)
1150                 }
1151             }
1152
1153             // impls need some special handling to try to offer useful
1154             // error messages without (too many) false positives
1155             // (i.e. we could just return here to not check them at
1156             // all, or some worse estimation of whether an impl is
1157             // publicly visible).
1158             hir::ItemImpl(_, _, ref g, ref trait_ref, ref self_, ref impl_items) => {
1159                 // `impl [... for] Private` is never visible.
1160                 let self_contains_private;
1161                 // impl [... for] Public<...>, but not `impl [... for]
1162                 // Vec<Public>` or `(Public,)` etc.
1163                 let self_is_public_path;
1164
1165                 // check the properties of the Self type:
1166                 {
1167                     let mut visitor = ObsoleteCheckTypeForPrivatenessVisitor {
1168                         inner: self,
1169                         contains_private: false,
1170                         at_outer_type: true,
1171                         outer_type_is_public_path: false,
1172                     };
1173                     visitor.visit_ty(&self_);
1174                     self_contains_private = visitor.contains_private;
1175                     self_is_public_path = visitor.outer_type_is_public_path;
1176                 }
1177
1178                 // miscellaneous info about the impl
1179
1180                 // `true` iff this is `impl Private for ...`.
1181                 let not_private_trait =
1182                     trait_ref.as_ref().map_or(true, // no trait counts as public trait
1183                                               |tr| {
1184                         let did = self.tcx.trait_ref_to_def_id(tr);
1185
1186                         if let Some(node_id) = self.tcx.map.as_local_node_id(did) {
1187                             self.trait_is_public(node_id)
1188                         } else {
1189                             true // external traits must be public
1190                         }
1191                     });
1192
1193                 // `true` iff this is a trait impl or at least one method is public.
1194                 //
1195                 // `impl Public { $( fn ...() {} )* }` is not visible.
1196                 //
1197                 // This is required over just using the methods' privacy
1198                 // directly because we might have `impl<T: Foo<Private>> ...`,
1199                 // and we shouldn't warn about the generics if all the methods
1200                 // are private (because `T` won't be visible externally).
1201                 let trait_or_some_public_method =
1202                     trait_ref.is_some() ||
1203                     impl_items.iter()
1204                               .any(|impl_item| {
1205                                   match impl_item.node {
1206                                       hir::ImplItemKind::Const(..) |
1207                                       hir::ImplItemKind::Method(..) => {
1208                                           self.access_levels.is_reachable(impl_item.id)
1209                                       }
1210                                       hir::ImplItemKind::Type(_) => false,
1211                                   }
1212                               });
1213
1214                 if !self_contains_private &&
1215                         not_private_trait &&
1216                         trait_or_some_public_method {
1217
1218                     intravisit::walk_generics(self, g);
1219
1220                     match *trait_ref {
1221                         None => {
1222                             for impl_item in impl_items {
1223                                 // This is where we choose whether to walk down
1224                                 // further into the impl to check its items. We
1225                                 // should only walk into public items so that we
1226                                 // don't erroneously report errors for private
1227                                 // types in private items.
1228                                 match impl_item.node {
1229                                     hir::ImplItemKind::Const(..) |
1230                                     hir::ImplItemKind::Method(..)
1231                                         if self.item_is_public(&impl_item.id, impl_item.vis) =>
1232                                     {
1233                                         intravisit::walk_impl_item(self, impl_item)
1234                                     }
1235                                     hir::ImplItemKind::Type(..) => {
1236                                         intravisit::walk_impl_item(self, impl_item)
1237                                     }
1238                                     _ => {}
1239                                 }
1240                             }
1241                         }
1242                         Some(ref tr) => {
1243                             // Any private types in a trait impl fall into three
1244                             // categories.
1245                             // 1. mentioned in the trait definition
1246                             // 2. mentioned in the type params/generics
1247                             // 3. mentioned in the associated types of the impl
1248                             //
1249                             // Those in 1. can only occur if the trait is in
1250                             // this crate and will've been warned about on the
1251                             // trait definition (there's no need to warn twice
1252                             // so we don't check the methods).
1253                             //
1254                             // Those in 2. are warned via walk_generics and this
1255                             // call here.
1256                             intravisit::walk_path(self, &tr.path);
1257
1258                             // Those in 3. are warned with this call.
1259                             for impl_item in impl_items {
1260                                 if let hir::ImplItemKind::Type(ref ty) = impl_item.node {
1261                                     self.visit_ty(ty);
1262                                 }
1263                             }
1264                         }
1265                     }
1266                 } else if trait_ref.is_none() && self_is_public_path {
1267                     // impl Public<Private> { ... }. Any public static
1268                     // methods will be visible as `Public::foo`.
1269                     let mut found_pub_static = false;
1270                     for impl_item in impl_items {
1271                         match impl_item.node {
1272                             hir::ImplItemKind::Const(..) => {
1273                                 if self.item_is_public(&impl_item.id, impl_item.vis) {
1274                                     found_pub_static = true;
1275                                     intravisit::walk_impl_item(self, impl_item);
1276                                 }
1277                             }
1278                             hir::ImplItemKind::Method(ref sig, _) => {
1279                                 if sig.explicit_self.node == hir::SelfStatic &&
1280                                       self.item_is_public(&impl_item.id, impl_item.vis) {
1281                                     found_pub_static = true;
1282                                     intravisit::walk_impl_item(self, impl_item);
1283                                 }
1284                             }
1285                             _ => {}
1286                         }
1287                     }
1288                     if found_pub_static {
1289                         intravisit::walk_generics(self, g)
1290                     }
1291                 }
1292                 return
1293             }
1294
1295             // `type ... = ...;` can contain private types, because
1296             // we're introducing a new name.
1297             hir::ItemTy(..) => return,
1298
1299             // not at all public, so we don't care
1300             _ if !self.item_is_public(&item.id, item.vis) => {
1301                 return;
1302             }
1303
1304             _ => {}
1305         }
1306
1307         // We've carefully constructed it so that if we're here, then
1308         // any `visit_ty`'s will be called on things that are in
1309         // public signatures, i.e. things that we're interested in for
1310         // this visitor.
1311         debug!("VisiblePrivateTypesVisitor entering item {:?}", item);
1312         intravisit::walk_item(self, item);
1313     }
1314
1315     fn visit_generics(&mut self, generics: &hir::Generics) {
1316         for ty_param in generics.ty_params.iter() {
1317             for bound in ty_param.bounds.iter() {
1318                 self.check_ty_param_bound(bound)
1319             }
1320         }
1321         for predicate in &generics.where_clause.predicates {
1322             match predicate {
1323                 &hir::WherePredicate::BoundPredicate(ref bound_pred) => {
1324                     for bound in bound_pred.bounds.iter() {
1325                         self.check_ty_param_bound(bound)
1326                     }
1327                 }
1328                 &hir::WherePredicate::RegionPredicate(_) => {}
1329                 &hir::WherePredicate::EqPredicate(ref eq_pred) => {
1330                     self.visit_ty(&eq_pred.ty);
1331                 }
1332             }
1333         }
1334     }
1335
1336     fn visit_foreign_item(&mut self, item: &hir::ForeignItem) {
1337         if self.access_levels.is_reachable(item.id) {
1338             intravisit::walk_foreign_item(self, item)
1339         }
1340     }
1341
1342     fn visit_ty(&mut self, t: &hir::Ty) {
1343         debug!("VisiblePrivateTypesVisitor checking ty {:?}", t);
1344         if let hir::TyPath(..) = t.node {
1345             if self.path_is_private_type(t.id) {
1346                 self.old_error_set.insert(t.id);
1347             }
1348         }
1349         intravisit::walk_ty(self, t)
1350     }
1351
1352     fn visit_variant(&mut self, v: &hir::Variant, g: &hir::Generics, item_id: ast::NodeId) {
1353         if self.access_levels.is_reachable(v.node.data.id()) {
1354             self.in_variant = true;
1355             intravisit::walk_variant(self, v, g, item_id);
1356             self.in_variant = false;
1357         }
1358     }
1359
1360     fn visit_struct_field(&mut self, s: &hir::StructField) {
1361         if s.vis == hir::Public || self.in_variant {
1362             intravisit::walk_struct_field(self, s);
1363         }
1364     }
1365
1366     // we don't need to introspect into these at all: an
1367     // expression/block context can't possibly contain exported things.
1368     // (Making them no-ops stops us from traversing the whole AST without
1369     // having to be super careful about our `walk_...` calls above.)
1370     // FIXME(#29524): Unfortunately this ^^^ is not true, blocks can contain
1371     // exported items (e.g. impls) and actual code in rustc itself breaks
1372     // if we don't traverse blocks in `EmbargoVisitor`
1373     fn visit_block(&mut self, _: &hir::Block) {}
1374     fn visit_expr(&mut self, _: &hir::Expr) {}
1375 }
1376
1377 ///////////////////////////////////////////////////////////////////////////////
1378 /// SearchInterfaceForPrivateItemsVisitor traverses an item's interface and
1379 /// finds any private components in it.
1380 /// PrivateItemsInPublicInterfacesVisitor ensures there are no private types
1381 /// and traits in public interfaces.
1382 ///////////////////////////////////////////////////////////////////////////////
1383
1384 struct SearchInterfaceForPrivateItemsVisitor<'a, 'tcx: 'a> {
1385     tcx: &'a TyCtxt<'tcx>,
1386     // Do not report an error when a private type is found
1387     is_quiet: bool,
1388     // Is private component found?
1389     is_public: bool,
1390     old_error_set: &'a NodeSet,
1391 }
1392
1393 impl<'a, 'tcx: 'a> SearchInterfaceForPrivateItemsVisitor<'a, 'tcx> {
1394     // Check if the type alias contain private types when substituted
1395     fn is_public_type_alias(&self, item: &hir::Item, path: &hir::Path) -> bool {
1396         // We substitute type aliases only when determining impl publicity
1397         // FIXME: This will probably change and all type aliases will be substituted,
1398         // requires an amendment to RFC 136.
1399         if !self.is_quiet {
1400             return false
1401         }
1402         // Type alias is considered public if the aliased type is
1403         // public, even if the type alias itself is private. So, something
1404         // like `type A = u8; pub fn f() -> A {...}` doesn't cause an error.
1405         if let hir::ItemTy(ref ty, ref generics) = item.node {
1406             let mut check = SearchInterfaceForPrivateItemsVisitor { is_public: true, ..*self };
1407             check.visit_ty(ty);
1408             // If a private type alias with default type parameters is used in public
1409             // interface we must ensure, that the defaults are public if they are actually used.
1410             // ```
1411             // type Alias<T = Private> = T;
1412             // pub fn f() -> Alias {...} // `Private` is implicitly used here, so it must be public
1413             // ```
1414             let provided_params = path.segments.last().unwrap().parameters.types().len();
1415             for ty_param in &generics.ty_params[provided_params..] {
1416                 if let Some(ref default_ty) = ty_param.default {
1417                     check.visit_ty(default_ty);
1418                 }
1419             }
1420             check.is_public
1421         } else {
1422             false
1423         }
1424     }
1425 }
1426
1427 impl<'a, 'tcx: 'a, 'v> Visitor<'v> for SearchInterfaceForPrivateItemsVisitor<'a, 'tcx> {
1428     fn visit_ty(&mut self, ty: &hir::Ty) {
1429         if self.is_quiet && !self.is_public {
1430             // We are in quiet mode and a private type is already found, no need to proceed
1431             return
1432         }
1433         if let hir::TyPath(_, ref path) = ty.node {
1434             let def = self.tcx.def_map.borrow().get(&ty.id).unwrap().full_def();
1435             match def {
1436                 Def::PrimTy(..) | Def::SelfTy(..) | Def::TyParam(..) => {
1437                     // Public
1438                 }
1439                 Def::AssociatedTy(..) if self.is_quiet => {
1440                     // Conservatively approximate the whole type alias as public without
1441                     // recursing into its components when determining impl publicity.
1442                     // For example, `impl <Type as Trait>::Alias {...}` may be a public impl
1443                     // even if both `Type` and `Trait` are private.
1444                     // Ideally, associated types should be substituted in the same way as
1445                     // free type aliases, but this isn't done yet.
1446                     return
1447                 }
1448                 Def::Struct(def_id) | Def::Enum(def_id) | Def::TyAlias(def_id) |
1449                 Def::Trait(def_id) | Def::AssociatedTy(def_id, _) => {
1450                     // Non-local means public (private items can't leave their crate, modulo bugs)
1451                     if let Some(node_id) = self.tcx.map.as_local_node_id(def_id) {
1452                         let item = self.tcx.map.expect_item(node_id);
1453                         if item.vis != hir::Public && !self.is_public_type_alias(item, path) {
1454                             if !self.is_quiet {
1455                                 if self.old_error_set.contains(&ty.id) {
1456                                     span_err!(self.tcx.sess, ty.span, E0446,
1457                                               "private type in public interface");
1458                                 } else {
1459                                     self.tcx.sess.add_lint (
1460                                         lint::builtin::PRIVATE_IN_PUBLIC,
1461                                         node_id,
1462                                         ty.span,
1463                                         format!("private type in public interface"),
1464                                     );
1465                                 }
1466                             }
1467                             self.is_public = false;
1468                         }
1469                     }
1470                 }
1471                 _ => {}
1472             }
1473         }
1474
1475         intravisit::walk_ty(self, ty);
1476     }
1477
1478     fn visit_trait_ref(&mut self, trait_ref: &hir::TraitRef) {
1479         if self.is_quiet && !self.is_public {
1480             // We are in quiet mode and a private type is already found, no need to proceed
1481             return
1482         }
1483         // Non-local means public (private items can't leave their crate, modulo bugs)
1484         let def_id = self.tcx.trait_ref_to_def_id(trait_ref);
1485         if let Some(node_id) = self.tcx.map.as_local_node_id(def_id) {
1486             let item = self.tcx.map.expect_item(node_id);
1487             if item.vis != hir::Public {
1488                 if !self.is_quiet {
1489                     if self.old_error_set.contains(&trait_ref.ref_id) {
1490                         span_err!(self.tcx.sess, trait_ref.path.span, E0445,
1491                                   "private trait in public interface");
1492                     } else {
1493                         self.tcx.sess.add_lint(lint::builtin::PRIVATE_IN_PUBLIC,
1494                                                node_id,
1495                                                trait_ref.path.span,
1496                                                "private trait in public interface (error E0445)"
1497                                                     .to_string());
1498                     }
1499                 }
1500                 self.is_public = false;
1501             }
1502         }
1503
1504         intravisit::walk_trait_ref(self, trait_ref);
1505     }
1506
1507     // Don't recurse into function bodies
1508     fn visit_block(&mut self, _: &hir::Block) {}
1509     // Don't recurse into expressions in array sizes or const initializers
1510     fn visit_expr(&mut self, _: &hir::Expr) {}
1511     // Don't recurse into patterns in function arguments
1512     fn visit_pat(&mut self, _: &hir::Pat) {}
1513 }
1514
1515 struct PrivateItemsInPublicInterfacesVisitor<'a, 'tcx: 'a> {
1516     tcx: &'a TyCtxt<'tcx>,
1517     old_error_set: &'a NodeSet,
1518 }
1519
1520 impl<'a, 'tcx> PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> {
1521     // A type is considered public if it doesn't contain any private components
1522     fn is_public_ty(&self, ty: &hir::Ty) -> bool {
1523         let mut check = SearchInterfaceForPrivateItemsVisitor {
1524             tcx: self.tcx, is_quiet: true, is_public: true, old_error_set: self.old_error_set
1525         };
1526         check.visit_ty(ty);
1527         check.is_public
1528     }
1529
1530     // A trait reference is considered public if it doesn't contain any private components
1531     fn is_public_trait_ref(&self, trait_ref: &hir::TraitRef) -> bool {
1532         let mut check = SearchInterfaceForPrivateItemsVisitor {
1533             tcx: self.tcx, is_quiet: true, is_public: true, old_error_set: self.old_error_set
1534         };
1535         check.visit_trait_ref(trait_ref);
1536         check.is_public
1537     }
1538 }
1539
1540 impl<'a, 'tcx, 'v> Visitor<'v> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> {
1541     fn visit_item(&mut self, item: &hir::Item) {
1542         let mut check = SearchInterfaceForPrivateItemsVisitor {
1543             tcx: self.tcx, is_quiet: false, is_public: true, old_error_set: self.old_error_set
1544         };
1545         match item.node {
1546             // Crates are always public
1547             hir::ItemExternCrate(..) => {}
1548             // All nested items are checked by visit_item
1549             hir::ItemMod(..) => {}
1550             // Checked in resolve
1551             hir::ItemUse(..) => {}
1552             // Subitems of these items have inherited publicity
1553             hir::ItemConst(..) | hir::ItemStatic(..) | hir::ItemFn(..) |
1554             hir::ItemEnum(..) | hir::ItemTrait(..) | hir::ItemTy(..) => {
1555                 if item.vis == hir::Public {
1556                     check.visit_item(item);
1557                 }
1558             }
1559             // Subitems of foreign modules have their own publicity
1560             hir::ItemForeignMod(ref foreign_mod) => {
1561                 for foreign_item in &foreign_mod.items {
1562                     if foreign_item.vis == hir::Public {
1563                         check.visit_foreign_item(foreign_item);
1564                     }
1565                 }
1566             }
1567             // Subitems of structs have their own publicity
1568             hir::ItemStruct(ref struct_def, ref generics) => {
1569                 if item.vis == hir::Public {
1570                     check.visit_generics(generics);
1571                     for field in struct_def.fields() {
1572                         if field.vis == hir::Public {
1573                             check.visit_struct_field(field);
1574                         }
1575                     }
1576                 }
1577             }
1578             // The interface is empty
1579             hir::ItemDefaultImpl(..) => {}
1580             // An inherent impl is public when its type is public
1581             // Subitems of inherent impls have their own publicity
1582             hir::ItemImpl(_, _, ref generics, None, ref ty, ref impl_items) => {
1583                 if self.is_public_ty(ty) {
1584                     check.visit_generics(generics);
1585                     for impl_item in impl_items {
1586                         if impl_item.vis == hir::Public {
1587                             check.visit_impl_item(impl_item);
1588                         }
1589                     }
1590                 }
1591             }
1592             // A trait impl is public when both its type and its trait are public
1593             // Subitems of trait impls have inherited publicity
1594             hir::ItemImpl(_, _, ref generics, Some(ref trait_ref), ref ty, ref impl_items) => {
1595                 if self.is_public_ty(ty) && self.is_public_trait_ref(trait_ref) {
1596                     check.visit_generics(generics);
1597                     for impl_item in impl_items {
1598                         check.visit_impl_item(impl_item);
1599                     }
1600                 }
1601             }
1602         }
1603     }
1604 }
1605
1606 pub fn check_crate(tcx: &TyCtxt,
1607                    export_map: &def::ExportMap,
1608                    external_exports: ExternalExports)
1609                    -> AccessLevels {
1610     let _task = tcx.dep_graph.in_task(DepNode::Privacy);
1611
1612     let krate = tcx.map.krate();
1613
1614     // Sanity check to make sure that all privacy usage is reasonable.
1615     let mut visitor = SanePrivacyVisitor { tcx: tcx };
1616     krate.visit_all_items(&mut visitor);
1617
1618     // Figure out who everyone's parent is
1619     let mut visitor = ParentVisitor {
1620         tcx: tcx,
1621         parents: NodeMap(),
1622         curparent: ast::DUMMY_NODE_ID,
1623     };
1624     intravisit::walk_crate(&mut visitor, krate);
1625
1626     // Use the parent map to check the privacy of everything
1627     let mut visitor = PrivacyVisitor {
1628         curitem: ast::DUMMY_NODE_ID,
1629         in_foreign: false,
1630         tcx: tcx,
1631         parents: visitor.parents,
1632         external_exports: external_exports,
1633     };
1634     intravisit::walk_crate(&mut visitor, krate);
1635
1636     tcx.sess.abort_if_errors();
1637
1638     // Build up a set of all exported items in the AST. This is a set of all
1639     // items which are reachable from external crates based on visibility.
1640     let mut visitor = EmbargoVisitor {
1641         tcx: tcx,
1642         export_map: export_map,
1643         access_levels: Default::default(),
1644         prev_level: Some(AccessLevel::Public),
1645         changed: false,
1646     };
1647     loop {
1648         intravisit::walk_crate(&mut visitor, krate);
1649         if visitor.changed {
1650             visitor.changed = false;
1651         } else {
1652             break
1653         }
1654     }
1655     visitor.update(ast::CRATE_NODE_ID, Some(AccessLevel::Public));
1656
1657     {
1658         let mut visitor = ObsoleteVisiblePrivateTypesVisitor {
1659             tcx: tcx,
1660             access_levels: &visitor.access_levels,
1661             in_variant: false,
1662             old_error_set: NodeSet(),
1663         };
1664         intravisit::walk_crate(&mut visitor, krate);
1665
1666         // Check for private types and traits in public interfaces
1667         let mut visitor = PrivateItemsInPublicInterfacesVisitor {
1668             tcx: tcx,
1669             old_error_set: &visitor.old_error_set,
1670         };
1671         krate.visit_all_items(&mut visitor);
1672     }
1673
1674     visitor.access_levels
1675 }
1676
1677 __build_diagnostic_array! { librustc_privacy, DIAGNOSTICS }