From ea855d29bdc44003eda5d51c373487a33eeaeb1c Mon Sep 17 00:00:00 2001
From: Ivan Enderlin <ivan.enderlin@hoa-project.net>
Date: Fri, 21 Feb 2020 12:23:58 +0100
Subject: [PATCH] doc(interface-types) Add intra links.

---
 src/ast.rs             |  2 +-
 src/decoders/binary.rs |  5 +++--
 src/decoders/mod.rs    |  3 ++-
 src/interpreter/mod.rs |  4 ++--
 src/lib.rs             | 41 +++++++++++++++++++++++------------------
 5 files changed, 31 insertions(+), 24 deletions(-)

diff --git a/src/ast.rs b/src/ast.rs
index beb77c1..d0c8cab 100644
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -5,7 +5,7 @@ use crate::interpreter::Instruction;
 use std::str;
 
 /// Represents the types supported by WIT.
-#[derive(PartialEq, Clone, Debug)]
+#[derive(PartialEq, Debug)]
 pub enum InterfaceType {
     /// An integer.
     Int,
diff --git a/src/decoders/binary.rs b/src/decoders/binary.rs
index fbe2e29..26fa382 100644
--- a/src/decoders/binary.rs
+++ b/src/decoders/binary.rs
@@ -1,4 +1,4 @@
-//! Parse the WIT binary representation into an AST.
+//! Parse the WIT binary representation into an [AST](crate::ast).
 
 use crate::{ast::*, interpreter::Instruction};
 use nom::{
@@ -408,7 +408,8 @@ fn forwards<'input, E: ParseError<&'input [u8]>>(
 }
 
 /// Parse a sequence of bytes, expecting it to be a valid WIT binary
-/// representation, into an `ast::Interfaces`.
+/// representation, into an [`Interfaces`](crate::ast::Interfaces)
+/// structure.
 ///
 /// # Example
 ///
diff --git a/src/decoders/mod.rs b/src/decoders/mod.rs
index 1b2aaaf..399bb89 100644
--- a/src/decoders/mod.rs
+++ b/src/decoders/mod.rs
@@ -1,5 +1,6 @@
 //! Reads the AST from a particular data representation; for instance,
-//! `decoders::binary` reads the AST from a binary.
+//! [`decoders::binary`](binary) reads the [AST](crate::ast)
+//! from a binary.
 
 pub mod binary;
 pub mod wat;
diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs
index 792c91e..e7ef7f1 100644
--- a/src/interpreter/mod.rs
+++ b/src/interpreter/mod.rs
@@ -43,8 +43,8 @@ pub(crate) type ExecutableInstruction<Instance, Export, LocalImport, Memory, Mem
 
 /// An interpreter is the central piece of this crate. It is a set of
 /// executable instructions. Each instruction takes the runtime as
-/// argument. The runtime holds the invocation inputs, the stack, and
-/// the WebAssembly instance.
+/// argument. The runtime holds the invocation inputs, [the
+/// stack](stack), and [the WebAssembly instance](wasm).
 ///
 /// When the interpreter executes the instructions, each of them can
 /// query the WebAssembly instance, operates on the stack, or reads
diff --git a/src/lib.rs b/src/lib.rs
index f4deaba..aa7499a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,21 +1,23 @@
 //! This crate contains an implementation of [WebAssembly Interface
 //! Types][wit] (abbreviated WIT). It is composed of 4 parts:
 //!
-//! 1. AST: To represent the WIT language as a tree (which is not
-//!    really abstract). This is the central representation of the
-//!    language.
-//! 2. Decoders: To read the AST from a particular data representation;
-//!    for instance, `decoders::binary` reads the AST from a binary.
-//! 3. Encoders: To write the AST into a particular format; for
-//!    instance, `encoders::wat` writes the AST into a string
-//!    representing WIT with its textual format.
-
-//! 4. Interpreter: WIT defines a concept called Adapters. An adapter
-//!    contains a set of instructions. So, in more details, this
-//!    module contains:
-//!     * A very light and generic stack implementation, exposing only
-//!       the operations required by the interpreter,
-//!     * A stack-based interpreter, defined by:
+//! 1. [AST]: To represent the WIT language as a tree
+//!    (which is not really abstract). This is the central
+//!    representation of the language.
+//! 2. [Decoders](decoders): To read the [AST] from a particular data
+//!    representation; for instance, [`decoders::binary`] reads the
+//!    [AST] from a binary.
+//! 3. [Encoders](encoders): To write the [AST](ast) into a particular
+//!    format; for instance, [`encoders::wat`] writes the [AST] into a
+//!    string representing WIT with its textual format.
+//! 4. [Interpreter](interpreter): WIT defines a concept called
+//!    Adapters. An adapter contains a set of [instructions]. So, in
+//!    more details, this module contains:
+//!     * [A very light and generic stack
+//!       implementation](interpreter::stack), exposing only the
+//!       operations required by the interpreter,
+//!     * [A stack-based interpreter](interpreter::Interpreter),
+//!       defined by:
 //!          * A compiler that transforms a set of instructions into a
 //!            set of executable instructions,
 //!          * A stack,
@@ -23,16 +25,19 @@
 //!            of the interpreter), the stack, and the WebAssembly
 //!            instance (which holds the exports, the imports, the
 //!            memories, the tables etc.),
-//!     * An hypothetic WebAssembly runtime, represented as a set of
-//!       enums, types, and traits —basically this is the part a
-//!       runtime should take a look to use the
+//!     * [An hypothetic WebAssembly runtime](interpreter::wasm),
+//!       represented as a set of enums, types, and traits —basically
+//!       this is the part a runtime should take a look to use the
 //!       `wasmer-interface-types` crate—.
 //!
 //!
 //! [wit]: https://github.com/WebAssembly/interface-types
+//! [AST]: ast
+//! [instructions]: interpreter::Instruction
 
 #![deny(
     dead_code,
+    intra_doc_link_resolution_failure,
     missing_docs,
     nonstandard_style,
     unreachable_patterns,