Merge branch 'master' into resolver-moved

Author: tshepang

src/name-resolution.md

@@ -28,14 +28,15 @@ source to relevant places where the name was introduced. It also generates
 helpful error messages, like typo suggestions, traits to import or lints about
 unused items.
 
-A successful run of the second phase (`Resolver::resolve_crate`) creates kind
+A successful run of the second phase ([`Resolver::resolve_crate`]) creates kind
 of an index the rest of the compilation may use to ask about the present names
 (through the `hir::lowering::Resolver` interface).
 
 The name resolution lives in the `librustc_resolve` crate, with the meat in
 `lib.rs` and some helpers or symbol-type specific logic in the other modules.
 
 [`Resolver`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_ast_lowering/trait.Resolver.html
+[`Resolver::resolve_crate`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_resolve/struct.Resolver.html#method.resolve_crate
 
 ## Namespaces
 

src/type-inference.md

@@ -149,7 +149,7 @@ To allow for this, the inference context supports a `snapshot` method.
 When you call it, it will start recording changes that occur from the
 operations you perform. When you are done, you can either invoke
 `rollback_to`, which will undo those changes, or else `confirm`, which
-will make the permanent. Snapshots can be nested as long as you follow
+will make them permanent. Snapshots can be nested as long as you follow
 a stack-like discipline.
 
 Rather than use snapshots directly, it is often helpful to use the
@@ -200,7 +200,7 @@ idea:
 ```
 
 (There are various other kinds of constraints, such as "verifys"; see
-the `region_constraints` module for details.)
+the [`region_constraints`] module for details.)
 
 There is one case where we do some amount of eager unification. If you have an
 equality constraint between two regions
@@ -210,10 +210,13 @@ equality constraint between two regions
 ```
 
 we will record that fact in a unification table. You can then use
-`opportunistic_resolve_var` to convert `'b` to `'a` (or vice
+[`opportunistic_resolve_var`] to convert `'b` to `'a` (or vice
 versa). This is sometimes needed to ensure termination of fixed-point
 algorithms.
 
+[`region_constraints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/region_constraints/index.html
+[`opportunistic_resolve_var`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/region_constraints/struct.RegionConstraintCollector.html#method.opportunistic_resolve_var
+
 ## Extracting region constraints
 
 Ultimately, region constraints are only solved at the very end of
@@ -222,22 +225,27 @@ ways to solve region constraints right now: lexical and
 non-lexical. Eventually there will only be one.
 
 To solve **lexical** region constraints, you invoke
-`resolve_regions_and_report_errors`.  This "closes" the region
-constraint process and invoke the `lexical_region_resolve` code. Once
+[`resolve_regions_and_report_errors`].  This "closes" the region
+constraint process and invokes the [`lexical_region_resolve`] code. Once
 this is done, any further attempt to equate or create a subtyping
 relationship will yield an ICE.
 
 Non-lexical region constraints are not handled within the inference
 context. Instead, the NLL solver (actually, the MIR type-checker)
-invokes `take_and_reset_region_constraints` periodically. This
+invokes [`take_and_reset_region_constraints`] periodically. This
 extracts all of the outlives constraints from the region solver, but
 leaves the set of variables intact. This is used to get *just* the
 region constraints that resulted from some particular point in the
 program, since the NLL solver needs to know not just *what* regions
-were subregions but *where*. Finally, the NLL solver invokes
-`take_region_var_origins`, which "closes" the region constraint
+were subregions, but also *where*. Finally, the NLL solver invokes
+[`take_region_var_origins`], which "closes" the region constraint
 process in the same way as normal solving.
 
+[`resolve_regions_and_report_errors`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.resolve_regions_and_report_errors
+[`lexical_region_resolve`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/lexical_region_resolve/index.html
+[`take_and_reset_region_constraints`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.take_and_reset_region_constraints
+[`take_region_var_origins`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_infer/infer/struct.InferCtxt.html#method.take_region_var_origins
+
 ## Lexical region resolution
 
 Lexical region resolution is done by initially assigning each region