Auto merge of #66680 - Centril:rollup-1ke3svj, r=Centril

Rollup of 5 pull requests

Successful merges:

 - #61351 (Stabilize cfg(doc))
 - #66539 (Point at type in `let` assignment on type errors)
 - #66655 (rustdoc: Mark `--extern-private` as unstable)
 - #66657 (rustdoc: Don't panic when failing to write .lock file)
 - #66673 (Move def collector from `rustc` to `rustc_resolve`)

Failed merges:

r? @ghost

Author: bors

src/doc/rustdoc/src/SUMMARY.md

@@ -7,4 +7,5 @@
 - [Documentation tests](documentation-tests.md)
 - [Lints](lints.md)
 - [Passes](passes.md)
+- [Advanced Features](advanced-features.md)
 - [Unstable features](unstable-features.md)

src/doc/rustdoc/src/advanced-features.md

@@ -0,0 +1,34 @@
+# Advanced Features
+
+The features listed on this page fall outside the rest of the main categories.
+
+## `#[cfg(doc)]`: Documenting platform-/feature-specific information
+
+For conditional compilation, Rustdoc treats your crate the same way the compiler does: Only things
+from the host target are available (or from the given `--target` if present), and everything else is
+"filtered out" from the crate. This can cause problems if your crate is providing different things
+on different targets and you want your documentation to reflect all the available items you
+provide.
+
+If you want to make sure an item is seen by Rustdoc regardless of what platform it's targeting,
+you can apply `#[cfg(doc)]` to it. Rustdoc sets this whenever it's building documentation, so
+anything that uses that flag will make it into documentation it generates. To apply this to an item
+with other `#[cfg]` filters on it, you can write something like `#[cfg(any(windows, doc))]`.
+This will preserve the item either when built normally on Windows, or when being documented
+anywhere.
+
+Please note that this feature is not passed to doctests.
+
+Example:
+
+```rust
+/// Token struct that can only be used on Windows.
+#[cfg(any(windows, doc))]
+pub struct WindowsToken;
+/// Token struct that can only be used on Unix.
+#[cfg(any(unix, doc))]
+pub struct UnixToken;
+```
+
+Here, the respective tokens can only be used by dependent crates on their respective platforms, but
+they will both appear in documentation.

src/librustc/hir/map/definitions.rs

@@ -105,7 +105,7 @@ pub struct Definitions {
     /// we know what parent node that fragment should be attached to thanks to this table.
     invocation_parents: FxHashMap<ExpnId, DefIndex>,
     /// Indices of unnamed struct or variant fields with unresolved attributes.
-    pub(super) placeholder_field_indices: NodeMap<usize>,
+    placeholder_field_indices: NodeMap<usize>,
 }
 
 /// A unique identifier that we can use to lookup a definition
@@ -535,6 +535,15 @@ impl Definitions {
         let old_parent = self.invocation_parents.insert(invoc_id, parent);
         assert!(old_parent.is_none(), "parent `DefIndex` is reset for an invocation");
     }
+
+    pub fn placeholder_field_index(&self, node_id: ast::NodeId) -> usize {
+        self.placeholder_field_indices[&node_id]
+    }
+
+    pub fn set_placeholder_field_index(&mut self, node_id: ast::NodeId, index: usize) {
+        let old_index = self.placeholder_field_indices.insert(node_id, index);
+        assert!(old_index.is_none(), "placeholder field index is reset for a node ID");
+    }
 }
 
 impl DefPathData {

src/librustc/hir/map/mod.rs

@@ -1,5 +1,4 @@
 use self::collector::NodeCollector;
-pub use self::def_collector::DefCollector;
 pub use self::definitions::{
     Definitions, DefKey, DefPath, DefPathData, DisambiguatedDefPathData, DefPathHash
 };
@@ -25,7 +24,6 @@ use syntax_pos::{Span, DUMMY_SP};
 
 pub mod blocks;
 mod collector;
-mod def_collector;
 pub mod definitions;
 mod hir_id_validator;
 

src/librustc_data_structures/flock.rs

@@ -298,15 +298,3 @@ cfg_if! {
         }
     }
 }
-
-impl Lock {
-    pub fn panicking_new(p: &Path,
-                         wait: bool,
-                         create: bool,
-                         exclusive: bool)
-                         -> Lock {
-        Lock::new(p, wait, create, exclusive).unwrap_or_else(|err| {
-            panic!("could not lock `{}`: {}", p.display(), err);
-        })
-    }
-}

src/librustc_resolve/build_reduced_graph.rs

@@ -5,6 +5,7 @@
 //! unexpanded macros in the fragment are visited and registered.
 //! Imports are also considered items and placed into modules here, but not resolved yet.
 
+use crate::def_collector::collect_definitions;
 use crate::macros::{LegacyBinding, LegacyScope};
 use crate::resolve_imports::ImportDirective;
 use crate::resolve_imports::ImportDirectiveSubclass::{self, GlobImport, SingleImport};
@@ -16,7 +17,6 @@ use crate::{ResolutionError, Determinacy, PathResult, CrateLint};
 use rustc::bug;
 use rustc::hir::def::{self, *};
 use rustc::hir::def_id::{CRATE_DEF_INDEX, LOCAL_CRATE, DefId};
-use rustc::hir::map::DefCollector;
 use rustc::ty;
 use rustc::middle::cstore::CrateStore;
 use rustc_metadata::cstore::LoadedMacro;
@@ -167,8 +167,7 @@ impl<'a> Resolver<'a> {
         fragment: &AstFragment,
         parent_scope: ParentScope<'a>,
     ) -> LegacyScope<'a> {
-        let mut def_collector = DefCollector::new(&mut self.definitions, parent_scope.expansion);
-        fragment.visit_with(&mut def_collector);
+        collect_definitions(&mut self.definitions, fragment, parent_scope.expansion);
         let mut visitor = BuildReducedGraphVisitor { r: self, parent_scope };
         fragment.visit_with(&mut visitor);
         visitor.parent_scope.legacy

src/librustc/hir/map/def_collector.rs renamed to src/librustc_resolve/def_collector.rs

@@ -1,26 +1,31 @@
-use crate::hir::map::definitions::*;
-use crate::hir::def_id::DefIndex;
-
+use log::debug;
+use rustc::hir::map::definitions::*;
+use rustc::hir::def_id::DefIndex;
 use syntax::ast::*;
 use syntax::visit;
 use syntax::symbol::{kw, sym};
 use syntax::token::{self, Token};
+use syntax_expand::expand::AstFragment;
 use syntax_pos::hygiene::ExpnId;
 use syntax_pos::Span;
 
+crate fn collect_definitions(
+    definitions: &mut Definitions,
+    fragment: &AstFragment,
+    expansion: ExpnId,
+) {
+    let parent_def = definitions.invocation_parent(expansion);
+    fragment.visit_with(&mut DefCollector { definitions, parent_def, expansion });
+}
+
 /// Creates `DefId`s for nodes in the AST.
-pub struct DefCollector<'a> {
+struct DefCollector<'a> {
     definitions: &'a mut Definitions,
     parent_def: DefIndex,
     expansion: ExpnId,
 }
 
 impl<'a> DefCollector<'a> {
-    pub fn new(definitions: &'a mut Definitions, expansion: ExpnId) -> Self {
-        let parent_def = definitions.invocation_parent(expansion);
-        DefCollector { definitions, parent_def, expansion }
-    }
-
     fn create_def(&mut self,
                   node_id: NodeId,
                   data: DefPathData,
@@ -82,7 +87,7 @@ impl<'a> DefCollector<'a> {
                 .or_else(|| index.map(sym::integer))
                 .unwrap_or_else(|| {
                     let node_id = NodeId::placeholder_from_expn_id(self.expansion);
-                    sym::integer(self.definitions.placeholder_field_indices[&node_id])
+                    sym::integer(self.definitions.placeholder_field_index(node_id))
                 });
             let def = self.create_def(field.id, DefPathData::ValueNs(name), field.span);
             self.with_parent(def, |this| visit::walk_struct_field(this, field));
@@ -186,7 +191,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
         for (index, field) in data.fields().iter().enumerate() {
             self.collect_field(field, Some(index));
             if field.is_placeholder && field.ident.is_none() {
-                self.definitions.placeholder_field_indices.insert(field.id, index);
+                self.definitions.set_placeholder_field_index(field.id, index);
             }
         }
     }

src/librustc_resolve/lib.rs

@@ -68,6 +68,7 @@ use rustc_error_codes::*;
 
 type Res = def::Res<NodeId>;
 
+mod def_collector;
 mod diagnostics;
 mod late;
 mod macros;

src/librustc_typeck/check/demand.rs

@@ -102,12 +102,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     // N.B., this code relies on `self.diverges` to be accurate. In
     // particular, assignments to `!` will be permitted if the
     // diverges flag is currently "always".
-    pub fn demand_coerce_diag(&self,
-                              expr: &hir::Expr,
-                              checked_ty: Ty<'tcx>,
-                              expected: Ty<'tcx>,
-                              allow_two_phase: AllowTwoPhase)
-                              -> (Ty<'tcx>, Option<DiagnosticBuilder<'tcx>>) {
+    pub fn demand_coerce_diag(
+        &self,
+        expr: &hir::Expr,
+        checked_ty: Ty<'tcx>,
+        expected: Ty<'tcx>,
+        allow_two_phase: AllowTwoPhase,
+    ) -> (Ty<'tcx>, Option<DiagnosticBuilder<'tcx>>) {
         let expected = self.resolve_vars_with_obligations(expected);
 
         let e = match self.try_coerce(expr, checked_ty, expected, allow_two_phase) {
@@ -126,6 +127,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             return (expected, None)
         }
 
+        self.annotate_expected_due_to_let_ty(&mut err, expr);
         self.suggest_compatible_variants(&mut err, expr, expected, expr_ty);
         self.suggest_ref_or_into(&mut err, expr, expected, expr_ty);
         self.suggest_boxing_when_appropriate(&mut err, expr, expected, expr_ty);
@@ -134,6 +136,20 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         (expected, Some(err))
     }
 
+    fn annotate_expected_due_to_let_ty(&self, err: &mut DiagnosticBuilder<'_>, expr: &hir::Expr) {
+        let parent = self.tcx.hir().get_parent_node(expr.hir_id);
+        if let Some(hir::Node::Local(hir::Local {
+            ty: Some(ty),
+            init: Some(init),
+            ..
+        })) = self.tcx.hir().find(parent) {
+            if init.hir_id == expr.hir_id {
+                // Point at `let` assignment type.
+                err.span_label(ty.span, "expected due to this");
+            }
+        }
+    }
+
     /// Returns whether the expected type is `bool` and the expression is `x = y`.
     pub fn is_assign_to_bool(&self, expr: &hir::Expr, expected: Ty<'tcx>) -> bool {
         if let hir::ExprKind::Assign(..) = expr.kind {

src/librustdoc/core.rs

@@ -250,7 +250,7 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
 
     let extern_names: Vec<String> = externs.iter().map(|(s,_)| s).cloned().collect();
 
-    // Add the rustdoc cfg into the doc build.
+    // Add the doc cfg into the doc build.
     cfgs.push("doc".to_string());
 
     let cpath = Some(input.clone());