From 55be7d60f03d154e7123346c296f09b54695c571 Mon Sep 17 00:00:00 2001
From: "Aaron S. Hawley" <aaron.s.hawley@gmail.com>
Date: Fri, 11 Aug 2017 00:54:58 -0400
Subject: [PATCH] Use base.url for '/' root relative links

---
 _includes/books.html                          |   2 +-
 _includes/footer.html                         |   2 +-
 _includes/masthead-documentation.html         |   4 +-
 _includes/navbar-inner.html                   |  10 +-
 _includes/sidebar-toc-multipage-overview.html |   2 +-
 .../sidebar-toc-singlepage-overview.html      |   2 +-
 _includes/sidebar-toc-tour-overview.html      |   2 +-
 _layouts/cheatsheet.html                      |   2 +-
 _overviews/FAQ/index.md                       |   2 +-
 _overviews/cheatsheets/index.md               |   2 +-
 _overviews/collections/trait-traversable.md   |   2 +-
 _overviews/macros/annotations.md              |   6 +-
 _overviews/macros/blackbox-whitebox.md        |   6 +-
 _overviews/macros/bundles.md                  |   4 +-
 _overviews/macros/changelog211.md             |   4 +-
 _overviews/macros/extractors.md               |   4 +-
 _overviews/macros/implicits.md                |   4 +-
 _overviews/macros/overview.md                 |   4 +-
 _overviews/macros/paradise.md                 |   6 +-
 _overviews/macros/roadmap.md                  |  22 ++--
 _overviews/macros/typemacros.md               |   6 +-
 _overviews/macros/typeproviders.md            |   6 +-
 _overviews/macros/untypedmacros.md            |   2 +-
 _overviews/quasiquotes/definition-details.md  |   8 +-
 _overviews/quasiquotes/expression-details.md  |  18 +--
 _overviews/quasiquotes/intro.md               |  14 +--
 _overviews/quasiquotes/lifting.md             |   4 +-
 _overviews/quasiquotes/pattern-details.md     |   4 +-
 _overviews/quasiquotes/setup.md               |   2 +-
 _overviews/quasiquotes/syntax-summary.md      | 118 +++++++++---------
 _overviews/quasiquotes/terminology.md         |   6 +-
 _overviews/quasiquotes/type-details.md        |  16 +--
 _overviews/quasiquotes/unlifting.md           |   6 +-
 .../reflection/annotations-names-scopes.md    |   2 +-
 _overviews/reflection/changelog211.md         |   2 +-
 _overviews/scaladoc/for-library-authors.md    |   2 +-
 _overviews/scaladoc/overview.md               |   6 +-
 _style/scaladoc.md                            |   2 +-
 _tour/singleton-objects.md                    |   2 +-
 _tour/tour-of-scala.md                        |   2 +-
 contribute.md                                 |   2 +-
 reference.md                                  |   4 +-
 42 files changed, 163 insertions(+), 163 deletions(-)

diff --git a/_includes/books.html b/_includes/books.html
index bbf2448be6..43c1645053 100644
--- a/_includes/books.html
+++ b/_includes/books.html
@@ -5,7 +5,7 @@
       <div class="book-item-header">
         <a href="{{book.link}}">
           <div class="content-img-boook">
-            <img src="{{book.image}}" alt="{{book.title}}">
+            <img src="{{site.baseurl}}{{book.image}}" alt="{{book.title}}">
           </div>
           <h3>{{book.title}}</h3>
         </a>
diff --git a/_includes/footer.html b/_includes/footer.html
index 3762a98d4e..5440bfc177 100644
--- a/_includes/footer.html
+++ b/_includes/footer.html
@@ -5,7 +5,7 @@
           <ul class="{{item.class}}">
             <li><h3>{{item.title}}</h3></li>
             {% for link in item.links %}
-              <li><a href="{{link.url}}">{{link.title}}</a></li>
+              <li><a href="{% if link.url contains '://' %}{{link.url}}{% else %}{{site.baseurl}}{{link.url}}{% endif %}">{{link.title}}</a></li>
             {% endfor %}
           </ul>
         {% endfor %}
diff --git a/_includes/masthead-documentation.html b/_includes/masthead-documentation.html
index 0a3c1c9403..a15b70e81e 100644
--- a/_includes/masthead-documentation.html
+++ b/_includes/masthead-documentation.html
@@ -6,7 +6,7 @@
           <div class="section">
             <h2 class="frontpage">{{ section.title }}</h2>
             {% for link in section.links %}
-  					<a href="{{link.link}}" class="doc-item">
+  					<a href="{% if link.link contains '://' %}{{link.link}}{% else %}{{site.baseurl}}{{link.link}}{% endif %}" class="doc-item">
   						<div class="doc-item-header">
   							<i class="{{link.icon}}"></i>
   							<h5>{{link.title}}</h5>
@@ -22,7 +22,7 @@ <h5>{{link.title}}</h5>
               <span class="heading">More Resources: </span>
               <ul>
               {% for resource in section.more-resources %}
-                <li><a href="{{ resource.url }}">{{ resource.title }}</a></li>
+                <li><a href="{{ site.baseurl }}{{ resource.url }}">{{ resource.title }}</a></li>
               {% endfor %}
               </ul>
             {% endif %}
diff --git a/_includes/navbar-inner.html b/_includes/navbar-inner.html
index 0fa60aa52e..eb64eda00d 100644
--- a/_includes/navbar-inner.html
+++ b/_includes/navbar-inner.html
@@ -10,7 +10,7 @@
       <ul class="navigation-menu">
         {% for navItem in site.data.nav-header %}
             <li class="navigation-menu-item">
-              <a href="{{navItem.url}}/" {% if page.url contains navItem.url %}class="active"{% endif %}>{{navItem.title}}</a>
+              <a href="{% if navItem.url contains '://' %}{{navItem.url}}{% else %}{{site.baseurl}}{{navItem.url}}{% endif %}" {% if page.url contains navItem.url %}class="active"{% endif %}>{{navItem.title}}</a>
             </li>
         {% endfor %}
       </ul>
@@ -29,12 +29,12 @@
       <ul class="navigation-menu">
         {% for navItem in site.data.doc-nav-header %}
             <li class="navigation-menu-item">
-              <a href="{{navItem.url}}" id="{{ navItem.title | downcase | strip }}" {% if page.url contains navItem.url %}class="active"{% endif %}>{{navItem.title}}</a>
+              <a href="{% if navItem.url contains '://' or navItem.url == '#'  %}{{navItem.url}}{% else %}{{site.baseurl}}{{navItem.url}}{% endif %}" id="{{ navItem.title | downcase | strip }}" {% if page.url contains navItem.url %}class="active"{% endif %}>{{navItem.title}}</a>
                 {% if navItem.submenu %}
                 <ul class="navigation-dropdown">
                 {% for subItem in navItem.submenu %}
                   <li>
-                    <a href="{{ subItem.url }}">{{ subItem.title }}</a>
+                    <a href="{% if subItem.url contains '://' %}{{ subItem.url }}{% else %}{{ site.baseurl }}{{ subItem.url }}{% endif %}">{{ subItem.title }}</a>
                   </li>
                 {% endfor %}
                 </ul>
@@ -49,7 +49,7 @@
           <ul class="navigation-submenu" id="{{ navItem.title | downcase | strip }}" style="display: none;">
             {% for subItem in navItem.submenu %}
               <li>
-                <a href="{{ subItem.url }}">{{ subItem.title }}</a>
+                <a href="{% if subItem.url contains '://' %}{{subItem.url}}{% else %}{{site.baseurl}}{{subItem.url}}{% endif %}">{{ subItem.title }}</a>
               </li>
             {% endfor %}
           </ul>
@@ -58,7 +58,7 @@
       <ul class="navigation-submenu ellipsis-menu" style="display: none;">
         {% for navItem in site.data.doc-nav-header %}
           {% if forloop.index > 3 %}
-            <li><a href="{{ navItem.url }}">{{ navItem.title }}</a></li>
+            <li><a href="{% if navItem.url contains '://' %}{{navItem.url}}{% else %}{{site.baseurl}}{{navItem.url}}{% endif %}">{{ navItem.title }}</a></li>
           {% endif %}
         {% endfor %}
       </ul>
diff --git a/_includes/sidebar-toc-multipage-overview.html b/_includes/sidebar-toc-multipage-overview.html
index 7b80f83544..f454abc5e6 100644
--- a/_includes/sidebar-toc-multipage-overview.html
+++ b/_includes/sidebar-toc-multipage-overview.html
@@ -25,7 +25,7 @@ <h5 class="contents">Contents</h5>
 
       {% if page.languages %}
         <ul id="available-languages" style="display: none;">
-          <li><a href="{{ page.url }}">English</a></li>
+          <li><a href="{{ site.baseurl }}{{ page.url }}">English</a></li>
           {% for l in page.languages %}
             {% capture intermediate %}{{ page.url | remove_first: l }}{% endcapture %}
             {% capture rootTutorialURL %}{{ intermediate | remove_first: '/' }}{% endcapture %}
diff --git a/_includes/sidebar-toc-singlepage-overview.html b/_includes/sidebar-toc-singlepage-overview.html
index 50a3c59ed5..f605a2ae13 100644
--- a/_includes/sidebar-toc-singlepage-overview.html
+++ b/_includes/sidebar-toc-singlepage-overview.html
@@ -5,7 +5,7 @@ <h5 class="contents">Contents</h5>
       <div id="toc"></div>
       {% if page.languages %}
         <ul id="available-languages" style="display: none;">
-          <li><a href="{{ page.url }}">English</a></li>
+          <li><a href="{{ site.baseurl }}{{ page.url }}">English</a></li>
           {% for l in page.languages %}
             {% capture intermediate %}{{ page.url | remove_first: l }}{% endcapture %}
             {% capture rootTutorialURL %}{{ intermediate | remove_first: '/' }}{% endcapture %}
diff --git a/_includes/sidebar-toc-tour-overview.html b/_includes/sidebar-toc-tour-overview.html
index 6167d4901f..df7456ae4d 100644
--- a/_includes/sidebar-toc-tour-overview.html
+++ b/_includes/sidebar-toc-tour-overview.html
@@ -33,7 +33,7 @@ <h5 class="contents">Contents</h5>
         </ul>
       {% elsif site.data.translations.tour.languages != empty  %}
         <ul id="available-languages" style="display: none;">
-          <li><a href="{{ page.url }}">English</a></li>
+          <li><a href="{{ site.baseurl }}{{ page.url }}">English</a></li>
           {% for l in site.data.translations.tour.languages %}
             {% capture intermediate %}{{ page.url | remove_first: l }}{% endcapture %}
             {% capture rootTutorialURL %}{{ intermediate | remove_first: '/' }}{% endcapture %}
diff --git a/_layouts/cheatsheet.html b/_layouts/cheatsheet.html
index 3e6e9cd3ec..6dacd54d46 100644
--- a/_layouts/cheatsheet.html
+++ b/_layouts/cheatsheet.html
@@ -9,7 +9,7 @@
 				{{content}}
         {% if page.languages %}
           <ul id="available-languages" style="display: none;">
-            <li><a href="{{ page.url }}">English</a></li>
+            <li><a href="{{site.baseurl}}{{ page.url }}">English</a></li>
             {% for l in page.languages %}
               {% capture intermediate %}{{ page.url | remove_first: l }}{% endcapture %}
               {% capture rootTutorialURL %}{{ intermediate | remove_first: '/' }}{% endcapture %}
diff --git a/_overviews/FAQ/index.md b/_overviews/FAQ/index.md
index 80b0e657de..417d08280d 100644
--- a/_overviews/FAQ/index.md
+++ b/_overviews/FAQ/index.md
@@ -16,7 +16,7 @@ provided by Daniel Sobral, adapted from his StackOverflow posts.
 <ul>
 {% for overview in overviews %}
   {% if overview.partof == "FAQ" %}
-    <li><a href="{{ overview.url }}">{{ overview.title }}</a></li>
+    <li><a href="{{ site.baseurl }}{{ overview.url }}">{{ overview.title }}</a></li>
   {% endif %}
 {% endfor %}
 </ul>
diff --git a/_overviews/cheatsheets/index.md b/_overviews/cheatsheets/index.md
index f069308031..989e6af690 100644
--- a/_overviews/cheatsheets/index.md
+++ b/_overviews/cheatsheets/index.md
@@ -320,7 +320,7 @@ Some(3) match {
     </tr>
     <tr>
       <td><code class="highlighter-rouge">trait T { ... }</code><br /><code class="highlighter-rouge">class C extends T { ... }</code><br /><code class="highlighter-rouge">class C extends D with T { ... }</code></td>
-      <td>traits.<br />interfaces-with-implementation. no constructor params. <a href="/tutorials/tour/mixin-class-composition.html">mixin-able</a>.</td>
+      <td>traits.<br />interfaces-with-implementation. no constructor params. <a href="{{site.baseurl}}/tutorials/tour/mixin-class-composition.html">mixin-able</a>.</td>
     </tr>
     <tr>
       <td><code class="highlighter-rouge">trait T1; trait T2</code><br /><code class="highlighter-rouge">class C extends T1 with T2</code><br /><code class="highlighter-rouge">class C extends D with T1 with T2</code></td>
diff --git a/_overviews/collections/trait-traversable.md b/_overviews/collections/trait-traversable.md
index 7d1a033e48..b223cb2cb1 100644
--- a/_overviews/collections/trait-traversable.md
+++ b/_overviews/collections/trait-traversable.md
@@ -35,7 +35,7 @@ The `foreach` method is meant to traverse all elements of the collection, and ap
 * **Folds** `foldLeft`, `foldRight`, `/:`, `:\`, `reduceLeft`, `reduceRight` which apply a binary operation to successive elements.
 * **Specific folds** `sum`, `product`, `min`, `max`, which work on collections of specific types (numeric or comparable).
 * **String** operations `mkString`, `addString`, `stringPrefix`, which give alternative ways of converting a collection to a string.
-* **View** operations, consisting of two overloaded variants of the `view` method. A view is a collection that's evaluated lazily. You'll learn more about views in [later](#Views).
+* **View** operations, consisting of two overloaded variants of the `view` method. A view is a collection that's evaluated lazily. You'll learn more about views in [later](views.html).
 
 ### Operations in Class Traversable ###
 
diff --git a/_overviews/macros/annotations.md b/_overviews/macros/annotations.md
index 02bc52a4f4..d7b70d9258 100644
--- a/_overviews/macros/annotations.md
+++ b/_overviews/macros/annotations.md
@@ -18,7 +18,7 @@ permalink: /overviews/macros/:title.html
 
 Macro annotations are only available with the macro paradise plugin (in Scala 2.10.x, 2.11.x and 2.12.x alike).
 Their inclusion in official Scala might happen in Scala 2.13, but there is no certainty about it yet.
-Follow the instructions at the ["Macro Paradise"](/overviews/macros/paradise.html) page to download and use our compiler plugin.
+Follow the instructions at the ["Macro Paradise"](paradise.html) page to download and use our compiler plugin.
 
 Note that macro paradise is needed both to compile and to expand macro annotations,
 which means that your users will have to also add macro paradise to their builds in order to use your macro annotations.
@@ -109,5 +109,5 @@ macro annotations are not an exceptions. During expansion we can have all the ty
 
 ## Blackbox vs whitebox
 
-Macro annotations must be [whitebox](/overviews/macros/blackbox-whitebox.html).
-If you declare a macro annotation as [blackbox](/overviews/macros/blackbox-whitebox.html), it will not work.
+Macro annotations must be [whitebox]({{ site.baseurl }}/overviews/macros/blackbox-whitebox.html).
+If you declare a macro annotation as [blackbox]({{ site.baseurl }}/overviews/macros/blackbox-whitebox.html), it will not work.
diff --git a/_overviews/macros/blackbox-whitebox.md b/_overviews/macros/blackbox-whitebox.md
index 45c7b3cd89..4fc2519bb9 100644
--- a/_overviews/macros/blackbox-whitebox.md
+++ b/_overviews/macros/blackbox-whitebox.md
@@ -35,7 +35,7 @@ compehensibility.
 
 However sometimes def macros transcend the notion of "just a regular method". For example, it is possible for a macro expansion to yield an expression of a type that is more specific than the return type of a macro. In Scala 2.10, such expansion will retain its precise type as highlighted in the ["Static return type of Scala macros"](http://stackoverflow.com/questions/13669974/static-return-type-of-scala-macros) article at Stack Overflow.
 
-This curious feature provides additional flexibility, enabling [fake type providers](http://meta.plasm.us/posts/2013/07/11/fake-type-providers-part-2/), [extended vanilla materialization](/sips/pending/source-locations.html), [fundep materialization](/overviews/macros/implicits.html#fundep-materialization) and [extractor macros](https://github.com/scala/scala/commit/84a335916556cb0fe939d1c51f27d80d9cf980dc), but it also sacrifices clarity - both for humans and for machines.
+This curious feature provides additional flexibility, enabling [fake type providers](http://meta.plasm.us/posts/2013/07/11/fake-type-providers-part-2/), [extended vanilla materialization](/sips/pending/source-locations.html), [fundep materialization]({{ site.baseurl }}/overviews/macros/implicits.html#fundep-materialization) and [extractor macros](https://github.com/scala/scala/commit/84a335916556cb0fe939d1c51f27d80d9cf980dc), but it also sacrifices clarity - both for humans and for machines.
 
 To concretize the crucial distinction between macros that behave just like normal methods and macros that refine their return types, we introduce the notions of blackbox macros and whitebox macros. Macros that faithfully follow their type signatures are called **blackbox macros** as their implementations are irrelevant to understanding their behaviour (could be treated as black boxes). Macros that can't have precise signatures in Scala's type system are called **whitebox macros** (whitebox def macros do have signatures, but these signatures are only approximations).
 
@@ -50,8 +50,8 @@ We express the distinction by replacing `scala.reflect.macros.Context` with `sca
 Blackbox def macros are treated differently from def macros of Scala 2.10. The following restrictions are applied to them by the Scala typechecker:
 
 1. When an application of a blackbox macro expands into tree `x`, the expansion is wrapped into a type ascription `(x: T)`, where `T` is the declared return type of the blackbox macro with type arguments and path dependencies applied in consistency with the particular macro application being expanded. This invalidates blackbox macros as an implementation vehicle of [type providers](http://meta.plasm.us/posts/2013/07/11/fake-type-providers-part-2/).
-1. When an application of a blackbox macro still has undetermined type parameters after Scala's type inference algorithm has finished working, these type parameters are inferred forcedly, in exactly the same manner as type inference happens for normal methods. This makes it impossible for blackbox macros to influence type inference, prohibiting [fundep materialization](/overviews/macros/implicits.html#fundep-materialization).
-1. When an application of a blackbox macro is used as an implicit candidate, no expansion is performed until the macro is selected as the result of the implicit search. This makes it impossible to [dynamically calculate availability of implicit macros](/sips/rejected/source-locations.html).
+1. When an application of a blackbox macro still has undetermined type parameters after Scala's type inference algorithm has finished working, these type parameters are inferred forcedly, in exactly the same manner as type inference happens for normal methods. This makes it impossible for blackbox macros to influence type inference, prohibiting [fundep materialization]({{ site.baseurl }}/overviews/macros/implicits.html#fundep-materialization).
+1. When an application of a blackbox macro is used as an implicit candidate, no expansion is performed until the macro is selected as the result of the implicit search. This makes it impossible to [dynamically calculate availability of implicit macros]({{ site.baseurl }}/sips/rejected/source-locations.html).
 1. When an application of a blackbox macro is used as an extractor in a pattern match, it triggers an unconditional compiler error, preventing [customizations of pattern matching](https://github.com/paulp/scala/commit/84a335916556cb0fe939d1c51f27d80d9cf980dc) implemented with macros.
 
 Whitebox def macros work exactly like def macros used to work in Scala 2.10. No restrictions of any kind get applied, so everything that could be done with macros in 2.10 should be possible in 2.11 and 2.12.
diff --git a/_overviews/macros/bundles.md b/_overviews/macros/bundles.md
index f698a304a7..fb5e8a3360 100644
--- a/_overviews/macros/bundles.md
+++ b/_overviews/macros/bundles.md
@@ -27,7 +27,7 @@ following reasons:
 1. Being limited to functions makes modularizing complex macros awkward. It's quite typical to see macro logic concentrate in helper
 traits outside macro implementations, turning implementations into trivial wrappers, which just instantiate and call helpers.
 
-2. Moreover, since macro parameters are path-dependent on the macro context, [special incantations](/overviews/macros/overview.html#writing-bigger-macros) are required to wire implementations and helpers together.
+2. Moreover, since macro parameters are path-dependent on the macro context, [special incantations](overview.html#writing-bigger-macros) are required to wire implementations and helpers together.
 
 Macro bundles provide a solution to these problems by allowing macro implementations to be declared in classes that take
 `c: scala.reflect.macros.blackbox.Context` or `c: scala.reflect.macros.whitebox.Context` as their constructor parameters, relieving macro implementations from having
@@ -49,4 +49,4 @@ providing type arguments if necessary.
 
 ## Blackbox vs whitebox
 
-Macro bundles can be used to implement both [blackbox](/overviews/macros/blackbox-whitebox.html) and [whitebox](/overviews/macros/blackbox-whitebox.html) macros. Give the macro bundle constructor parameter the type of `scala.reflect.macros.blackbox.Context` to define a blackbox macro and  the type of `scala.reflect.macros.whitebox.Context` to define a whitebox macro.
+Macro bundles can be used to implement both [blackbox]({{ site.baseurl }}/overviews/macros/blackbox-whitebox.html) and [whitebox]({{ site.baseurl }}/overviews/macros/blackbox-whitebox.html) macros. Give the macro bundle constructor parameter the type of `scala.reflect.macros.blackbox.Context` to define a blackbox macro and  the type of `scala.reflect.macros.whitebox.Context` to define a whitebox macro.
diff --git a/_overviews/macros/changelog211.md b/_overviews/macros/changelog211.md
index bed801af57..45c9f154f4 100644
--- a/_overviews/macros/changelog211.md
+++ b/_overviews/macros/changelog211.md
@@ -21,7 +21,7 @@ This document lists all major changes to reflection and macros during the develo
 
 ### Quasiquotes
 
-Quasiquotes is the single most impressive upgrade for reflection and macros in Scala 2.11.0. Implemented by Denys Shabalin, they have significantly simplified the life of Scala metaprogrammers around the globe. Visit [the dedicated documentation page](/overviews/quasiquotes/intro.html) to learn more about quasiquotes.
+Quasiquotes is the single most impressive upgrade for reflection and macros in Scala 2.11.0. Implemented by Denys Shabalin, they have significantly simplified the life of Scala metaprogrammers around the globe. Visit [the dedicated documentation page]({{ site.baseurl }}/overviews/quasiquotes/intro.html) to learn more about quasiquotes.
 
 ### New macro powers
 
@@ -53,7 +53,7 @@ Quasiquotes is the single most impressive upgrade for reflection and macros in S
 
 12) **[Introduction of Universe.internal and Context.internal](https://github.com/xeno-by/scala/commit/114c99691674873393223a11a9aa9168c3f41d77)**. Feedback from the users of the Scala 2.10.x reflection API has given us two important insights. First, certain functionality that we exposed was too low-level and were very out of place in the public API. Second, certain low-level functionality was very important in getting important macros operational. In order to somewhat resolve the tension created by these two development vectors, we've created internal subsections of the public APIs that are: a) clearly demarcated from the blessed parts of the reflection API, b) available to those who know what they are doing and want to implement practically important use cases that we want to support. Follow migration and compatibility notes in the bottom of the document to learn more.
 
-13) **[Thread safety for runtime reflection](http://docs.scala-lang.org/overviews/reflection/thread-safety.html)**. The most pressing problem in reflection for Scala 2.10.x was its thread unsafety. Attempts to use runtime reflection (e.g. type tags) from multiple threads resulted in weird crashes documented above. We believe to have fixed this problem in Scala 2.11.0-RC1 by introducing a number of locks in critical places of our implementation. On the one hand, the strategy we are using at the moment is sub-optimal in the sense that certain frequently used operations (such as `Symbol.typeSignature` or `TypeSymbol.typeParams`) are hidden behind a global lock, but we plan to optimize that in the future. On the other hand, most of the typical APIs (e.g. `Type.members` or `Type.<:<`) either use thread-local state or don't require synchronization at all, so it's definitely worth a try.
+13) **[Thread safety for runtime reflection]({{ site.baseurl }}/overviews/reflection/thread-safety.html)**. The most pressing problem in reflection for Scala 2.10.x was its thread unsafety. Attempts to use runtime reflection (e.g. type tags) from multiple threads resulted in weird crashes documented above. We believe to have fixed this problem in Scala 2.11.0-RC1 by introducing a number of locks in critical places of our implementation. On the one hand, the strategy we are using at the moment is sub-optimal in the sense that certain frequently used operations (such as `Symbol.typeSignature` or `TypeSymbol.typeParams`) are hidden behind a global lock, but we plan to optimize that in the future. On the other hand, most of the typical APIs (e.g. `Type.members` or `Type.<:<`) either use thread-local state or don't require synchronization at all, so it's definitely worth a try.
 
 14) **[Type.typeArgs](https://github.com/xeno-by/scala/commit/0f4e95574081bd9a945fb5b32d157a32af840cd3)**. It is now dead simple to obtain type arguments of a given type. What required a pattern match in Scala 2.10.x is now a simple method invocation. The `typeArgs` method is also joined by `typeParams`, `paramLists`, and `resultType`, making it very easy to perform common type inspection tasks.
 
diff --git a/_overviews/macros/extractors.md b/_overviews/macros/extractors.md
index 43fb30c911..d75019879e 100644
--- a/_overviews/macros/extractors.md
+++ b/_overviews/macros/extractors.md
@@ -94,5 +94,5 @@ of this and other use cases for extractor macros.
 
 ## Blackbox vs whitebox
 
-Extractor macros must be [whitebox](/overviews/macros/blackbox-whitebox.html).
-If you declare an extractor macro as [blackbox](/overviews/macros/blackbox-whitebox.html), it will not work.
+Extractor macros must be [whitebox](blackbox-whitebox.html).
+If you declare an extractor macro as [blackbox](blackbox-whitebox.html), it will not work.
diff --git a/_overviews/macros/implicits.md b/_overviews/macros/implicits.md
index bc277680b0..4ba43d986b 100644
--- a/_overviews/macros/implicits.md
+++ b/_overviews/macros/implicits.md
@@ -22,7 +22,7 @@ neither in 2.10.x, nor in 2.11.
 
 An extension to implicit macros,
 called fundep materialization, is unavailable in 2.10.0 through 2.10.4, but has been implemented in
-[macro paradise](/overviews/macros/paradise.html), Scala 2.10.5 and Scala 2.11.x.
+[macro paradise](paradise.html), Scala 2.10.5 and Scala 2.11.x.
 Note that in 2.10.0 through 2.10.4, expansion of fundep materializer macros requires macro paradise,
 which means that your users will have to add macro paradise to their builds in order to use your fundep materializers.
 However, after fundep materializers expand, the resulting code will no longer have any references to macro paradise
@@ -157,7 +157,7 @@ Please note that there is [a funny caveat](https://github.com/scala/scala/blob/7
 
 ## Blackbox vs whitebox
 
-Vanilla materializers (covered in the first part of this document) can be both [blackbox](/overviews/macros/blackbox-whitebox.html) and [whitebox](/overviews/macros/blackbox-whitebox.html).
+Vanilla materializers (covered in the first part of this document) can be both [blackbox](blackbox-whitebox.html) and [whitebox](blackbox-whitebox.html).
 
 There is a noticeable distinction between blackbox and whitebox materializers. An error in an expansion of a blackbox implicit macro (e.g. an explicit <code>c.abort</code> call or an expansion typecheck error) will produce a compilation error. An error in an expansion of a whitebox implicit macro will just remove the macro from the list of implicit candidates in the current implicit search, without ever reporting an actual error to the user. This creates a trade-off: blackbox implicit macros feature better error reporting, while whitebox implicit macros are more flexible, being able to dynamically turn themselves off when necessary.
 
diff --git a/_overviews/macros/overview.md b/_overviews/macros/overview.md
index f099131408..8d275f1dad 100644
--- a/_overviews/macros/overview.md
+++ b/_overviews/macros/overview.md
@@ -22,7 +22,7 @@ A subset of def macros, pending a thorough specification, is tentatively schedul
 <span class="label success">UPDATE</span> This guide has been written for Scala 2.10.0, and now we're well into the Scala 2.11.x release cycle,
 so naturally the contents of the document are outdated. Nevertheless, this guide is not obsolete -
 everything written here will still work in both Scala 2.10.x and Scala 2.11.x, so it will be helpful to read it through.
-After reading the guide, take a look at the docs on [quasiquotes](/overviews/quasiquotes/intro.html)
+After reading the guide, take a look at the docs on [quasiquotes]({{ site.baseurl }}/overviews/quasiquotes/intro.html)
 and [macro bundles](bundles.html) to familiarize yourself with latest developments
 that dramatically simplify writing macros. Then it might be a good idea to follow
 [our macro workshop](https://github.com/scalamacros/macrology201) for more in-depth examples.
@@ -136,7 +136,7 @@ This also means that the code below won't work for `printf(get_format(), ...)`,
     val Literal(Constant(s_format: String)) = format.tree
 
 Typical macros (and this macro is not an exception) need to create ASTs (abstract syntax trees) which represent Scala code.
-To learn more about generation of Scala code, take a look at [the overview of reflection](http://docs.scala-lang.org/overviews/reflection/overview.html). Along with creating ASTs the code provided below also manipulates types.
+To learn more about generation of Scala code, take a look at [the overview of reflection]({{ site.baseurl }}/overviews/reflection/overview.html). Along with creating ASTs the code provided below also manipulates types.
 Note how we get a hold of Scala types that correspond to `Int` and `String`.
 Reflection overview linked above covers type manipulations in detail.
 The final step of code generation combines all the generated code into a `Block`.
diff --git a/_overviews/macros/paradise.md b/_overviews/macros/paradise.md
index 775b3ebc75..b32a293aa4 100644
--- a/_overviews/macros/paradise.md
+++ b/_overviews/macros/paradise.md
@@ -22,7 +22,7 @@ permalink: /overviews/macros/:title.html
 Macro paradise is a plugin for several versions of Scala compilers.
 It is designed to reliably work with production releases of <code>scalac</code>,
 making latest macro developments available way before they end up in future versions Scala.
-Refer to the roadmap for [the list of supported features and versions](/overviews/macros/roadmap.html)
+Refer to the roadmap for [the list of supported features and versions](roadmap.html)
 and visit [the paradise announcement](http://scalamacros.org/news/2013/08/07/roadmap-for-macro-paradise.html)
 to learn more about our support guarantees.
 
@@ -38,11 +38,11 @@ to learn more about our support guarantees.
 
 Some features in macro paradise bring a compile-time dependency on the macro paradise plugin,
 some features do not, however none of those features need macro paradise at runtime.
-Proceed to the [the feature list](/overviews/macros/roadmap.html) document for more information.
+Proceed to the [the feature list](roadmap.html) document for more information.
 
 Consult [https://github.com/scalamacros/sbt-example-paradise](https://github.com/scalamacros/sbt-example-paradise)
 for an end-to-end example, but in a nutshell working with macro paradise is as easy as adding the following two lines
-to your build (granted you’ve already [set up sbt](/overviews/macros/overview.html#using-macros-with-maven-or-sbt)
+to your build (granted you’ve already [set up sbt](overview.html#using-macros-with-maven-or-sbt)
 to use macros).
 
     resolvers += Resolver.sonatypeRepo("releases")
diff --git a/_overviews/macros/roadmap.md b/_overviews/macros/roadmap.md
index 6c24216c8f..5b5e5c5fae 100644
--- a/_overviews/macros/roadmap.md
+++ b/_overviews/macros/roadmap.md
@@ -26,18 +26,18 @@ the new foundation for metaprogramming Scala, which is simpler, more robust and
 than the current system based on scala.reflect. We hope that one day scala.meta will supersede scala.reflect
 and become the new standard way of doing metaprogramming in Scala.
 
-| Feature                                                                           | Scala 2.10                      | [Paradise 2.10](/overviews/macros/paradise.html) | Scala 2.11                 | [Paradise 2.11](/overviews/macros/paradise.html) | Scala 2.12                  | [Paradise 2.12](/overviews/macros/paradise.html) |
+| Feature                                                                           | Scala 2.10                      | [Paradise 2.10](paradise.html) | Scala 2.11                 | [Paradise 2.11](paradise.html) | Scala 2.12                  | [Paradise 2.12](paradise.html) |
 |-----------------------------------------------------------------------------------|---------------------------------|--------------------------------------------------|----------------------------|--------------------------------------------------|-----------------------------|--------------------------------------------------|
-| [Blackbox/whitebox separation](/overviews/macros/blackbox-whitebox.html)          | No                              | No  <sup>1</sup>                                 | Yes                        | Yes <sup>1</sup>                                 | Yes                         | Yes <sup>1</sup>                                 |
-| [Def macros](/overviews/macros/overview.html)                                     | Yes                             | Yes <sup>1</sup>                                 | Yes                        | Yes <sup>1</sup>                                 | Yes                         | Yes <sup>1</sup>                                 |
-| [Macro bundles](/overviews/macros/bundles.html)                                   | No                              | No  <sup>1</sup>                                 | Yes                        | Yes <sup>1</sup>                                 | Yes                         | Yes <sup>1</sup>                                 |
-| [Implicit macros](/overviews/macros/implicits.html)                               | Yes (since 2.10.2)              | Yes <sup>1</sup>                                 | Yes                        | Yes <sup>1</sup>                                 | Yes                         | Yes <sup>1</sup>                                 |
-| [Fundep materialization](/overviews/macros/implicits.html#fundep-materialization) | Yes (since 2.10.5) <sup>3</sup> | Yes <sup>2</sup>                                 | Yes                        | Yes <sup>1</sup>                                 | Yes                         | Yes <sup>1</sup>                                 |
-| [Type providers](/overviews/macros/typeproviders.html)                            | Partial support (see docs)      | Yes <sup>2</sup>                                 | Partial support (see docs) | Yes <sup>2</sup>                                 | Partial support (see docs)  | Yes <sup>2</sup>                                 |
-| [Quasiquotes](/overviews/quasiquotes/intro.html)                                 | No                              | Yes <sup>1</sup>                                 | Yes                        | Yes <sup>1</sup>                                 | Yes                         | Yes <sup>1</sup>                                 |
-| [Type macros](/overviews/macros/typemacros.html)                                  | No                              | No                                               | No                         | No                                               | No                          | No                                               |
-| [Untyped macros](/overviews/macros/untypedmacros.html)                            | No                              | No                                               | No                         | No                                               | No                          | No                                               |
-| [Macro annotations](/overviews/macros/annotations.html)                           | No                              | Yes <sup>2</sup>                                 | No                         | Yes <sup>2</sup>                                 | No                          | Yes <sup>2</sup>                                 |
+| [Blackbox/whitebox separation](blackbox-whitebox.html)          | No                              | No  <sup>1</sup>                                 | Yes                        | Yes <sup>1</sup>                                 | Yes                         | Yes <sup>1</sup>                                 |
+| [Def macros](overview.html)                                     | Yes                             | Yes <sup>1</sup>                                 | Yes                        | Yes <sup>1</sup>                                 | Yes                         | Yes <sup>1</sup>                                 |
+| [Macro bundles](bundles.html)                                   | No                              | No  <sup>1</sup>                                 | Yes                        | Yes <sup>1</sup>                                 | Yes                         | Yes <sup>1</sup>                                 |
+| [Implicit macros](implicits.html)                               | Yes (since 2.10.2)              | Yes <sup>1</sup>                                 | Yes                        | Yes <sup>1</sup>                                 | Yes                         | Yes <sup>1</sup>                                 |
+| [Fundep materialization](implicits.html#fundep-materialization) | Yes (since 2.10.5) <sup>3</sup> | Yes <sup>2</sup>                                 | Yes                        | Yes <sup>1</sup>                                 | Yes                         | Yes <sup>1</sup>                                 |
+| [Type providers](typeproviders.html)                            | Partial support (see docs)      | Yes <sup>2</sup>                                 | Partial support (see docs) | Yes <sup>2</sup>                                 | Partial support (see docs)  | Yes <sup>2</sup>                                 |
+| [Quasiquotes]({{ site.baseurl }}/overviews/quasiquotes/intro.html)                                 | No                              | Yes <sup>1</sup>                                 | Yes                        | Yes <sup>1</sup>                                 | Yes                         | Yes <sup>1</sup>                                 |
+| [Type macros](typemacros.html)                                  | No                              | No                                               | No                         | No                                               | No                          | No                                               |
+| [Untyped macros](untypedmacros.html)                            | No                              | No                                               | No                         | No                                               | No                          | No                                               |
+| [Macro annotations](annotations.html)                           | No                              | Yes <sup>2</sup>                                 | No                         | Yes <sup>2</sup>                                 | No                          | Yes <sup>2</sup>                                 |
 
 <p><sup>1</sup> This feature doesn't bring a compile-time or a runtime dependency on macro paradise. This means that neither compiling against your bytecode that uses this feature, nor running this bytecode requires the macro paradise plugin to be present on classpath.</p>
 <p><sup>2</sup> This feature brings a compile-time, but not a runtime dependency on macro paradise. This means that compiling against your bytecode that uses this feature will need the plugin to be added to your users' builds, however running this bytecode or results of macro expansions produced by this bytecode doesn't need additional classpath entries.</p>
diff --git a/_overviews/macros/typemacros.md b/_overviews/macros/typemacros.md
index f638aebf74..15ed40ae44 100644
--- a/_overviews/macros/typemacros.md
+++ b/_overviews/macros/typemacros.md
@@ -13,7 +13,7 @@ permalink: /overviews/macros/:title.html
 
 **Eugene Burmako**
 
-Type macros used to be available in previous versions of ["Macro Paradise"](/overviews/macros/paradise.html),
+Type macros used to be available in previous versions of ["Macro Paradise"](paradise.html),
 but are not supported anymore in macro paradise 2.0.
 Visit [the paradise 2.0 announcement](http://scalamacros.org/news/2013/08/05/macro-paradise-2.0.0-snapshot.html)
 for an explanation and suggested migration strategy.
@@ -30,7 +30,7 @@ Just as def macros make the compiler execute custom functions when it sees invoc
     Db.Coffees.update(brazilian.copy(price = 10))
     println(Db.Coffees.all)
 
-The full source code of the `H2Db` type macro is provided [at GitHub](https://github.com/xeno-by/typemacros-h2db), and this guide covers its most important aspects. First the macro generates the statically typed database wrapper by connecting to a database at compile-time (tree generation is explained in [the reflection overview](http://docs.scala-lang.org/overviews/reflection/overview.html)). Then it uses the <span class="label success">NEW</span> `c.introduceTopLevel` API ([Scaladoc](https://scala-webapps.epfl.ch/jenkins/view/misc/job/macro-paradise211-nightly-main/ws/dists/latest/doc/scala-devel-docs/api/index.html#scala.reflect.macros.Synthetics)) to insert the generated wrapper into the list of top-level definitions maintained by the compiler. Finally, the macro returns an `Apply` node, which represents a super constructor call to the generated class. <span class="tag">NOTE</span> that type macros are supposed to expand into `c.Tree`, unlike def macros, which expand into `c.Expr[T]`. That's because `Expr`s represent terms, while type macros expand into types.
+The full source code of the `H2Db` type macro is provided [at GitHub](https://github.com/xeno-by/typemacros-h2db), and this guide covers its most important aspects. First the macro generates the statically typed database wrapper by connecting to a database at compile-time (tree generation is explained in [the reflection overview]({{ site.baseurl }}/overviews/reflection/overview.html)). Then it uses the <span class="label success">NEW</span> `c.introduceTopLevel` API ([Scaladoc](https://scala-webapps.epfl.ch/jenkins/view/misc/job/macro-paradise211-nightly-main/ws/dists/latest/doc/scala-devel-docs/api/index.html#scala.reflect.macros.Synthetics)) to insert the generated wrapper into the list of top-level definitions maintained by the compiler. Finally, the macro returns an `Apply` node, which represents a super constructor call to the generated class. <span class="tag">NOTE</span> that type macros are supposed to expand into `c.Tree`, unlike def macros, which expand into `c.Expr[T]`. That's because `Expr`s represent terms, while type macros expand into types.
 
     type H2Db(url: String) = macro impl
 
@@ -93,4 +93,4 @@ For example, a type macro used as `TM(2)(3)` in `class C extends TM(2)(3)` can e
 
 ### Generating classes and objects
 
-With type macros you might increasingly find yourself in a zone where `reify` is not applicable, as explained [at StackOverflow](http://stackoverflow.com/questions/13795490/how-to-use-type-calculated-in-scala-macro-in-a-reify-clause). In that case consider using [quasiquotes](/overviews/quasiquotes/intro.html), another experimental feature from macro paradise, as an alternative to manual tree construction.
+With type macros you might increasingly find yourself in a zone where `reify` is not applicable, as explained [at StackOverflow](http://stackoverflow.com/questions/13795490/how-to-use-type-calculated-in-scala-macro-in-a-reify-clause). In that case consider using [quasiquotes]({{ site.baseurl }}/overviews/quasiquotes/intro.html), another experimental feature from macro paradise, as an alternative to manual tree construction.
diff --git a/_overviews/macros/typeproviders.md b/_overviews/macros/typeproviders.md
index 99a67437aa..db886a9c4b 100644
--- a/_overviews/macros/typeproviders.md
+++ b/_overviews/macros/typeproviders.md
@@ -93,7 +93,7 @@ so I refer you to an amazing blog series by Travis Brown for details: [post 1](h
 
 ## Public type providers
 
-With the help of [macro paradise](/overviews/macros/paradise.html) and its [macro annotations](/overviews/macros/annotations.html), it becomes
+With the help of [macro paradise](paradise.html) and its [macro annotations](annotations.html), it becomes
 possible to easily generate publicly visible classes, without having to apply workarounds based on structural types. The annotation-based
 solution is very straightforward, so I won't be writing much about it here.
 
@@ -140,5 +140,5 @@ than bytecode of a full-fledged class. This technique applies to both anonymous
 
 ## Blackbox vs whitebox
 
-Both anonymous and public type providers must be [whitebox](/overviews/macros/blackbox-whitebox.html).
-If you declare a type provider macro as [blackbox](/overviews/macros/blackbox-whitebox.html), it will not work.
+Both anonymous and public type providers must be [whitebox](blackbox-whitebox.html).
+If you declare a type provider macro as [blackbox](blackbox-whitebox.html), it will not work.
diff --git a/_overviews/macros/untypedmacros.md b/_overviews/macros/untypedmacros.md
index 5b1a57c0bd..d03a4f3109 100644
--- a/_overviews/macros/untypedmacros.md
+++ b/_overviews/macros/untypedmacros.md
@@ -13,7 +13,7 @@ permalink: /overviews/macros/:title.html
 
 **Eugene Burmako**
 
-Untyped macros used to be available in previous versions of ["Macro Paradise"](/overviews/macros/paradise.html),
+Untyped macros used to be available in previous versions of ["Macro Paradise"](paradise.html),
 but are not supported anymore in macro paradise 2.0.
 Visit [the paradise 2.0 announcement](http://scalamacros.org/news/2013/08/05/macro-paradise-2.0.0-snapshot.html)
 for an explanation and suggested migration strategy.
diff --git a/_overviews/quasiquotes/definition-details.md b/_overviews/quasiquotes/definition-details.md
index a74ec7e17b..d859b6d136 100644
--- a/_overviews/quasiquotes/definition-details.md
+++ b/_overviews/quasiquotes/definition-details.md
@@ -115,7 +115,7 @@ The template consists of:
 
 ## Val and Var Definitions
 
-`val`s and `var`s allow you to define immutable values and mutable variables respectively. Additionally they can be used to represent [function](/overviews/quasiquotes/expression-details.html#function), [class](#class-definition) and [method](#method-definition) parameters.
+`val`s and `var`s allow you to define immutable values and mutable variables respectively. Additionally they can be used to represent [function](expression-details.html#function), [class](#class-definition) and [method](#method-definition) parameters.
 
 Each `val` and `var` consistents of four components: modifiers, a name, a type tree and a right hand side:
 
@@ -128,7 +128,7 @@ Each `val` and `var` consistents of four components: modifiers, a name, a type t
     tpt: universe.Tree = <type ?>
     rhs: universe.Tree = 2
 
-If the type of the `val` isn't explicitly specified by the user an [empty type](/overviews/quasiquotes/type-details.html#empty-type) is used as `tpt`.
+If the type of the `val` isn't explicitly specified by the user an [empty type](type-details.html#empty-type) is used as `tpt`.
 
 `val`s and `var`s are disjoint (they don't match one another):
 
@@ -216,7 +216,7 @@ Abstract type definitions have the following shape:
     low: universe.Tree = <empty>
     high: universe.Tree = List[T]
 
-Whenever one of the bounds isn\'t available, it gets represented as an [empty tree](/overviews/quasiquotes/expression-details.html#empty). Here each of the type arguments is a type definition itself.
+Whenever one of the bounds isn\'t available, it gets represented as an [empty tree](expression-details.html#empty). Here each of the type arguments is a type definition itself.
 
 Another form of type definition is a type alias:
 
@@ -249,7 +249,7 @@ Each method consists of modifiers, a name, type arguments, value arguments, retu
     tpt: universe.Tree = <type ?>
     body: universe.Tree = 1
 
-Type arguments are [type definitions](#type-definition) and value arguments are [val definitions](#val-and-var-definitions). The inferred return type is represented as an [empty type](/overviews/quasiquotes/type-details.html#empty-type). If the body of the method is an [empty expression](/overviews/quasiquotes/expression-details.html#empty) it means that method is abstract.
+Type arguments are [type definitions](#type-definition) and value arguments are [val definitions](#val-and-var-definitions). The inferred return type is represented as an [empty type](type-details.html#empty-type). If the body of the method is an [empty expression](expression-details.html#empty) it means that method is abstract.
 
 Alternatively you can also deconstruct arguments, separating implicit and non-implicit parameters:
 
diff --git a/_overviews/quasiquotes/expression-details.md b/_overviews/quasiquotes/expression-details.md
index 35af8c09f8..371b7508dc 100644
--- a/_overviews/quasiquotes/expression-details.md
+++ b/_overviews/quasiquotes/expression-details.md
@@ -42,13 +42,13 @@ All of those values are of type `Literal` except symbols, which have a different
     scala> val foo = q"'foo"
     foo: universe.Tree = scala.Symbol("foo")
 
-Thanks to [lifting](/overviews/quasiquotes/lifting.html), you can also easily create literal trees directly from values of corresponding types:
+Thanks to [lifting]({{ site.baseurl }}/overviews/quasiquotes/lifting.html), you can also easily create literal trees directly from values of corresponding types:
 
     scala> val x = 1
     scala> val one = q"$x"
     one: universe.Tree = 1
 
-This would work the same way for all literal types (see [standard liftables](/overviews/quasiquotes/lifting.html#standard-liftables) except `Null`. Lifting of the `null` value into the `Null` type isn't supported; use `q"null"` if you really want to create a `null` literal:
+This would work the same way for all literal types (see [standard liftables]({{ site.baseurl }}/overviews/quasiquotes/lifting.html#standard-liftables) except `Null`. Lifting of the `null` value into the `Null` type isn't supported; use `q"null"` if you really want to create a `null` literal:
 
     scala> val x = null
     scala> q"$x"
@@ -56,12 +56,12 @@ This would work the same way for all literal types (see [standard liftables](/ov
                   q"$x"
                      ^
 
-During deconstruction you can use [unlifting](/overviews/quasiquotes/unlifting.html) to extract values out of `Literal` trees:
+During deconstruction you can use [unlifting]({{ site.baseurl }}/overviews/quasiquotes/unlifting.html) to extract values out of `Literal` trees:
 
     scala> val q"${x: Int}" = q"1"
     x: Int = 1
 
-Similarly it would work with all the literal types except `Null`. (see [standard unliftables](/overviews/quasiquotes/unlifting.html#standard-unliftables))
+Similarly it would work with all the literal types except `Null`. (see [standard unliftables]({{ site.baseurl }}/overviews/quasiquotes/unlifting.html#standard-unliftables))
 
 ## Identifier and Selection
 
@@ -86,7 +86,7 @@ Although backquoted and non-backquoted identifiers may refer to the same thing t
 
 This is because backquoted identifiers have different semantics in pattern patching.
 
-Apart from matching on identifiers with a given name, you can also extract their name values with the help of [unlifting](/overviews/quasiquotes/unlifting.html):
+Apart from matching on identifiers with a given name, you can also extract their name values with the help of [unlifting]({{ site.baseurl }}/overviews/quasiquotes/unlifting.html):
 
     scala> val q"${name: TermName}" = q"Foo"
     name: universe.TermName = Foo
@@ -273,7 +273,7 @@ It's important to mention that such a pattern won't match if we combine annotati
     scala.MatchError: (1.$plus(1): Int @positive) (of class scala.reflect.internal.Trees$Typed)
       ... 32 elided
 
-In this case we need to deconstruct it as an [ascription](#ascription) and then deconstruct `tpt` as an [annotated type](/overviews/quasiquotes/type-details.html#annotated-type).
+In this case we need to deconstruct it as an [ascription](#ascription) and then deconstruct `tpt` as an [annotated type]({{ site.baseurl }}/overviews/quasiquotes/type-details.html#annotated-type).
 
 ## Tuple
 
@@ -474,7 +474,7 @@ There are three ways to create anonymous function:
 
 The first one uses the placeholder syntax. The second one names the function parameter but still relies on type inference to infer its type. An the last one explicitly defines the function parameter. Due to an implementation restriction, the second notation can only be used in parentheses or inside another expression. If you leave them out the you must specify the parameter types.
 
-Parameters are represented as [Vals](/overviews/quasiquotes/definition-details.html#val-and-var-definitions). If you want to programmatically create a `val` that should have its type inferred you need to use the [empty type](/overviews/quasiquotes/type-details.html#empty-type):
+Parameters are represented as [Vals]({{ site.baseurl }}/overviews/quasiquotes/definition-details.html#val-and-var-definitions). If you want to programmatically create a `val` that should have its type inferred you need to use the [empty type]({{ site.baseurl }}/overviews/quasiquotes/type-details.html#empty-type):
 
     scala> val tpt = tq""
     tpt: universe.TypeTree = <type ?>
@@ -504,7 +504,7 @@ You can also tear arguments apart even further:
     name: universe.TermName = a
     tpt: universe.Tree = Int
 
-It is recommended that you use the underscore pattern in place of [modifiers](/overviews/quasiquotes/definition-details.html#modifiers), even if you don't plan to work with them as parameters, they may contain additional flags which might cause match failures.
+It is recommended that you use the underscore pattern in place of [modifiers]({{ site.baseurl }}/overviews/quasiquotes/definition-details.html#modifiers), even if you don't plan to work with them as parameters, they may contain additional flags which might cause match failures.
 
 ## Partial Function
 
@@ -598,7 +598,7 @@ New expressions let you construct an instance of given type, possibly refining i
     parents: List[universe.Tree] = List(Foo(1), Bar)
     body: List[universe.Tree] = List(def baz = 2)
 
-See the [templates](/overviews/quasiquotes/definition-details.html#templates) section for details.
+See the [templates]({{ site.baseurl }}/overviews/quasiquotes/definition-details.html#templates) section for details.
 
 ## Import
 
diff --git a/_overviews/quasiquotes/intro.md b/_overviews/quasiquotes/intro.md
index 8ae3d6cb58..fbebb00f77 100644
--- a/_overviews/quasiquotes/intro.md
+++ b/_overviews/quasiquotes/intro.md
@@ -69,9 +69,9 @@ Each of these contexts is covered by a separate interpolator:
 
     | Used for
 ----|----------------
- q  | [expressions](/overviews/quasiquotes/syntax-summary.html#expressions), [definitions](/overviews/quasiquotes/syntax-summary.html#definitions) and [imports](http://localhost:4000/overviews/quasiquotes/expression-details.html#import)
- tq | [types](/overviews/quasiquotes/syntax-summary.html#types)
- pq | [patterns](/overviews/quasiquotes/syntax-summary.html#patterns)
+ q  | [expressions]({{ site.baseurl }}/overviews/quasiquotes/syntax-summary.html#expressions), [definitions]({{ site.baseurl }}/overviews/quasiquotes/syntax-summary.html#definitions) and [imports](http://localhost:4000/overviews/quasiquotes/expression-details.html#import)
+ tq | [types]({{ site.baseurl }}/overviews/quasiquotes/syntax-summary.html#types)
+ pq | [patterns]({{ site.baseurl }}/overviews/quasiquotes/syntax-summary.html#patterns)
 
 Syntactical similarity between different contexts doesn\'t imply similarity between underlying trees:
 
@@ -97,10 +97,10 @@ Additionally there are two auxiliary interpolators that let you work with minor
 
     | Used for
 ----|-------------------------------------
- cq | [case clause](/overviews/quasiquotes/syntax-summary.html#auxiliary)
- fq | [for loop enumerator](/overviews/quasiquotes/syntax-summary.html#auxiliary)
+ cq | [case clause]({{ site.baseurl }}/overviews/quasiquotes/syntax-summary.html#auxiliary)
+ fq | [for loop enumerator]({{ site.baseurl }}/overviews/quasiquotes/syntax-summary.html#auxiliary)
 
-See the section [syntax summary](/overviews/quasiquotes/syntax-summary.html) for details.
+See the section [syntax summary]({{ site.baseurl }}/overviews/quasiquotes/syntax-summary.html) for details.
 
 ## Splicing
 
@@ -154,4 +154,4 @@ So, in general, only one `..$` is allowed per given list. Similar restrictions a
     case q"f(...$init)(..$first)" => // ok
     case q"f(...$a)(...$b)"       => // not allowed
 
-In this section we only worked with function arguments but the same splicing rules are true for all syntax forms with a variable number of elements. [Syntax summary](/overviews/quasiquotes/syntax-summary.html) and the corresponding details sections demonstrate how you can use splicing with other syntactic forms.
+In this section we only worked with function arguments but the same splicing rules are true for all syntax forms with a variable number of elements. [Syntax summary]({{ site.baseurl }}/overviews/quasiquotes/syntax-summary.html) and the corresponding details sections demonstrate how you can use splicing with other syntactic forms.
diff --git a/_overviews/quasiquotes/lifting.md b/_overviews/quasiquotes/lifting.md
index eea2842479..2c6126a789 100644
--- a/_overviews/quasiquotes/lifting.md
+++ b/_overviews/quasiquotes/lifting.md
@@ -13,7 +13,7 @@ permalink: /overviews/quasiquotes/:title.html
 ---
 **Denys Shabalin** <span class="tag" style="float: right;">EXPERIMENTAL</span>
 
-Lifting is an extensible way to unquote custom data types in quasiquotes. Its primary use-case is support unquoting of [literal](/overviews/quasiquotes/expression-details.html#literal) values and a number of reflection primitives as trees:
+Lifting is an extensible way to unquote custom data types in quasiquotes. Its primary use-case is support unquoting of [literal]({{ site.baseurl }}/overviews/quasiquotes/expression-details.html#literal) values and a number of reflection primitives as trees:
 
     scala> val two = 1 + 1
     two: Int = 2
@@ -69,7 +69,7 @@ This way, whenever a value of type `Point` is unquoted at runtime it will be aut
    compatible with the others. This problem is caused by the path-dependent nature of the current reflection
    API. (see [sharing liftable implementation between universes](#reusing-liftable-implementation-between-universes))
 
-3. Due to a lack of [hygiene](/overviews/quasiquotes/hygiene.html), the reference to `Point`'s companion
+3. Due to a lack of [hygiene]({{ site.baseurl }}/overviews/quasiquotes/hygiene.html), the reference to `Point`'s companion
    has to be fully qualified to ensure the correctness of this tree in every possible context. Another
    way to workaround this reference issue is to use symbols instead:
 
diff --git a/_overviews/quasiquotes/pattern-details.md b/_overviews/quasiquotes/pattern-details.md
index 5a0349bd80..d6d3597a20 100644
--- a/_overviews/quasiquotes/pattern-details.md
+++ b/_overviews/quasiquotes/pattern-details.md
@@ -24,7 +24,7 @@ Literal patterns are equivalent to literal expressions on AST level:
     scala> val equivalent = pq"1" equalsStructure q"1"
     equivalent: Boolean = true
 
-See the chapter on [literal expressions](/overviews/quasiquotes/expression-details.html#literal) for details.
+See the chapter on [literal expressions]({{ site.baseurl }}/overviews/quasiquotes/expression-details.html#literal) for details.
 
 ## Binding Pattern
 
@@ -106,7 +106,7 @@ Pattern alternatives represent a pattern that matches whenever, at least, one of
 
 ## Tuple Pattern
 
-Similar to [tuple expressions](/overviews/quasiquotes/expression-details.html#tuple) and [tuple types](/overviews/quasiquotes/type-details.html#tuple-type), tuple patterns are just syntactic sugar that expands as a `TupleN` extractor:
+Similar to [tuple expressions]({{ site.baseurl }}/overviews/quasiquotes/expression-details.html#tuple) and [tuple types]({{ site.baseurl }}/overviews/quasiquotes/type-details.html#tuple-type), tuple patterns are just syntactic sugar that expands as a `TupleN` extractor:
 
     scala> val tup2pat = pq"(a, b)"
     tup2pat: universe.Tree = scala.Tuple2((a @ _), (b @ _))
diff --git a/_overviews/quasiquotes/setup.md b/_overviews/quasiquotes/setup.md
index b1231be7cc..940216b055 100644
--- a/_overviews/quasiquotes/setup.md
+++ b/_overviews/quasiquotes/setup.md
@@ -52,7 +52,7 @@ On the other side of spectrum there is also a `showRaw` pretty printer that show
 
 ## Scala 2.10
 
-In Scala 2.10, quasiquotes are only available via the [macro paradise compiler plugin](http://docs.scala-lang.org/overviews/macros/paradise.html).
+In Scala 2.10, quasiquotes are only available via the [macro paradise compiler plugin]({{ site.baseurl }}/overviews/macros/paradise.html).
 
 In short, using quasiquotes in 2.10 is as simple as adding a single `addCompilerPlugin` line to your sbt build for the macro paradise plugin that enables quasiquotes and an additional `libraryDependencies` line for the supporting library that is necessary for quasiquotes to function in Scala 2.10. A full example is provided at [https://github.com/scalamacros/sbt-example-paradise](https://github.com/scalamacros/sbt-example-paradise).
 
diff --git a/_overviews/quasiquotes/syntax-summary.md b/_overviews/quasiquotes/syntax-summary.md
index 786723f096..f7de0517f9 100644
--- a/_overviews/quasiquotes/syntax-summary.md
+++ b/_overviews/quasiquotes/syntax-summary.md
@@ -47,26 +47,26 @@ permalink: /overviews/quasiquotes/:title.html
  XML Literal             | Not natively supported                                           | Tree
 
 
-[101]: /overviews/quasiquotes/expression-details.html#empty
-[102]: /overviews/quasiquotes/expression-details.html#literal
-[103]: /overviews/quasiquotes/expression-details.html#identifier-and-selection
-[104]: /overviews/quasiquotes/expression-details.html#super-and-this
-[105]: /overviews/quasiquotes/expression-details.html#application-and-type-application
-[106]: /overviews/quasiquotes/expression-details.html#assign-and-update
-[107]: /overviews/quasiquotes/expression-details.html#return
-[108]: /overviews/quasiquotes/expression-details.html#throw
-[109]: /overviews/quasiquotes/expression-details.html#ascription
-[110]: /overviews/quasiquotes/expression-details.html#annotation
-[111]: /overviews/quasiquotes/expression-details.html#tuple
-[112]: /overviews/quasiquotes/expression-details.html#block
-[113]: /overviews/quasiquotes/expression-details.html#if
-[114]: /overviews/quasiquotes/expression-details.html#pattern-match
-[115]: /overviews/quasiquotes/expression-details.html#try
-[116]: /overviews/quasiquotes/expression-details.html#function
-[117]: /overviews/quasiquotes/expression-details.html#partial-function
-[118]: /overviews/quasiquotes/expression-details.html#while-and-do-while-loops
-[119]: /overviews/quasiquotes/expression-details.html#for-and-for-yield-loops
-[120]: /overviews/quasiquotes/expression-details.html#new
+[101]: expression-details.html#empty
+[102]: expression-details.html#literal
+[103]: expression-details.html#identifier-and-selection
+[104]: expression-details.html#super-and-this
+[105]: expression-details.html#application-and-type-application
+[106]: expression-details.html#assign-and-update
+[107]: expression-details.html#return
+[108]: expression-details.html#throw
+[109]: expression-details.html#ascription
+[110]: expression-details.html#annotation
+[111]: expression-details.html#tuple
+[112]: expression-details.html#block
+[113]: expression-details.html#if
+[114]: expression-details.html#pattern-match
+[115]: expression-details.html#try
+[116]: expression-details.html#function
+[117]: expression-details.html#partial-function
+[118]: expression-details.html#while-and-do-while-loops
+[119]: expression-details.html#for-and-for-yield-loops
+[120]: expression-details.html#new
 
 ## Types
 
@@ -86,16 +86,16 @@ permalink: /overviews/quasiquotes/:title.html
  [Tuple Type][209]           | `tq"(..$tpts)"`                       | Tree
  [Function Type][210]        | `tq"(..$tpts) => $tpt"`               | Tree
 
-[201]: /overviews/quasiquotes/type-details.html#empty-type
-[202]: /overviews/quasiquotes/type-details.html#type-identifier
-[203]: /overviews/quasiquotes/type-details.html#singleton-type
-[204]: /overviews/quasiquotes/type-details.html#type-projection
-[205]: /overviews/quasiquotes/type-details.html#applied-type
-[206]: /overviews/quasiquotes/type-details.html#annotated-type
-[207]: /overviews/quasiquotes/type-details.html#compound-type
-[208]: /overviews/quasiquotes/type-details.html#existential-type
-[209]: /overviews/quasiquotes/type-details.html#tuple-type
-[210]: /overviews/quasiquotes/type-details.html#function-type
+[201]: type-details.html#empty-type
+[202]: type-details.html#type-identifier
+[203]: type-details.html#singleton-type
+[204]: type-details.html#type-projection
+[205]: type-details.html#applied-type
+[206]: type-details.html#annotated-type
+[207]: type-details.html#compound-type
+[208]: type-details.html#existential-type
+[209]: type-details.html#tuple-type
+[210]: type-details.html#function-type
 
 ## Patterns
 
@@ -110,13 +110,13 @@ permalink: /overviews/quasiquotes/:title.html
  [Tuple Pattern][307]       | `pq"(..$pats)"`        | Apply, UnApply
  XML Pattern                | Not natively supported | Tree
 
-[301]: /overviews/quasiquotes/pattern-details.html#wildcard-pattern
-[302]: /overviews/quasiquotes/pattern-details.html#literal-pattern
-[303]: /overviews/quasiquotes/pattern-details.html#binding-pattern
-[304]: /overviews/quasiquotes/pattern-details.html#extractor-pattern
-[305]: /overviews/quasiquotes/pattern-details.html#type-pattern
-[306]: /overviews/quasiquotes/pattern-details.html#alternative-pattern
-[307]: /overviews/quasiquotes/pattern-details.html#tuple-pattern
+[301]: pattern-details.html#wildcard-pattern
+[302]: pattern-details.html#literal-pattern
+[303]: pattern-details.html#binding-pattern
+[304]: pattern-details.html#extractor-pattern
+[305]: pattern-details.html#type-pattern
+[306]: pattern-details.html#alternative-pattern
+[307]: pattern-details.html#tuple-pattern
 
 ## Definitions
 
@@ -135,16 +135,16 @@ permalink: /overviews/quasiquotes/:title.html
  [Package][409]               | `q"package $ref { ..$topstats }"`                                                                                           | PackageDef
  [Package Object][410]        | `q"package object $tname extends { ..$earlydefns } with ..$parents { $self => ..$stats }"`                                  | PackageDef
 
-[401]: /overviews/quasiquotes/definition-details.html#val-and-var-definitions
-[402]: /overviews/quasiquotes/definition-details.html#pattern-definitions
-[403]: /overviews/quasiquotes/definition-details.html#method-definition
-[404]: /overviews/quasiquotes/definition-details.html#secondary-constructor-definition
-[405]: /overviews/quasiquotes/definition-details.html#type-definition
-[406]: /overviews/quasiquotes/definition-details.html#class-definition
-[407]: /overviews/quasiquotes/definition-details.html#trait-definition
-[408]: /overviews/quasiquotes/definition-details.html#object-definition
-[409]: /overviews/quasiquotes/definition-details.html#package-definition
-[410]: /overviews/quasiquotes/definition-details.html#package-object-definition
+[401]: definition-details.html#val-and-var-definitions
+[402]: definition-details.html#pattern-definitions
+[403]: definition-details.html#method-definition
+[404]: definition-details.html#secondary-constructor-definition
+[405]: definition-details.html#type-definition
+[406]: definition-details.html#class-definition
+[407]: definition-details.html#trait-definition
+[408]: definition-details.html#object-definition
+[409]: definition-details.html#package-definition
+[410]: definition-details.html#package-object-definition
 
 ## Auxiliary
 
@@ -157,9 +157,9 @@ permalink: /overviews/quasiquotes/:title.html
  [Guard Enumerator][503]            | `fq"if $expr"`              | Tree
 
 
-[501]: /overviews/quasiquotes/expression-details.html#import
-[502]: /overviews/quasiquotes/expression-details.html#pattern-match
-[503]: /overviews/quasiquotes/expression-details.html#for-and-for-yield-loops
+[501]: expression-details.html#import
+[502]: expression-details.html#pattern-match
+[503]: expression-details.html#for-and-for-yield-loops
 
 ## Abbreviations
 
@@ -171,14 +171,14 @@ Prefixes of unquotees imply the following:
 * `tpt: Tree` a [type tree](#types)
 * `pat: Tree` a [pattern tree](#patterns)
 * `defn: Tree` a [definition tree](#definitions)
-* `earlydefn: Tree` an early definion tree ([val](/overviews/quasiquotes/definition-details.html#val-and-var-definitions) or [type definition](/overviews/quasiquotes/definition-details.html#type-definition))
-* `self: Tree` a self definition tree (i.e. [val definition](/overviews/quasiquotes/definition-details.html#val-and-var-definitions))
-* `stat: Tree` a statement tree ([definition](#definitions), [expression](#expressions) or an [import](/overviews/quasiquotes/expression-details.html#import))
-* `topstat: Tree` a top-level statement tree ([class](/overviews/quasiquotes/definition-details.html#class-definition), [trait](/overviews/quasiquotes/definition-details.html#trait-definition), [package](/overviews/quasiquotes/definition-details.html#package-definition), [package object](/overviews/quasiquotes/definition-details.html#package-object-definition) or [import](/overviews/quasiquotes/expression-details.html#import))
-* `enum: Tree` a [for loop](/overviews/quasiquotes/expression-details.html#for-and-for-yield-loops) enumerator
-* `param: Tree` a value parameter tree (i.e. [val definition](/overviews/quasiquotes/definition-details.html#val-and-var-definitions))
-* `tparam: Tree` a type paremeter tree (i.e. [type definition](/overviews/quasiquotes/definition-details.html#type-definition))
-* `parent: Tree` a [template](/overviews/quasiquotes/definition-details.html#templates) parent
-* `sel: Tree` an [import](/overviews/quasiquotes/expression-details.html#import) selector tree
+* `earlydefn: Tree` an early definion tree ([val](definition-details.html#val-and-var-definitions) or [type definition](definition-details.html#type-definition))
+* `self: Tree` a self definition tree (i.e. [val definition](definition-details.html#val-and-var-definitions))
+* `stat: Tree` a statement tree ([definition](#definitions), [expression](#expressions) or an [import](expression-details.html#import))
+* `topstat: Tree` a top-level statement tree ([class](definition-details.html#class-definition), [trait](definition-details.html#trait-definition), [package](definition-details.html#package-definition), [package object](definition-details.html#package-object-definition) or [import](expression-details.html#import))
+* `enum: Tree` a [for loop](expression-details.html#for-and-for-yield-loops) enumerator
+* `param: Tree` a value parameter tree (i.e. [val definition](definition-details.html#val-and-var-definitions))
+* `tparam: Tree` a type paremeter tree (i.e. [type definition](definition-details.html#type-definition))
+* `parent: Tree` a [template](definition-details.html#templates) parent
+* `sel: Tree` an [import](expression-details.html#import) selector tree
 
 Whenever a name has suffix `s` it means that it is a `List` of something. `ss` means List of Lists. So for example `exprss` means a `List` of `List`s of expressions.
diff --git a/_overviews/quasiquotes/terminology.md b/_overviews/quasiquotes/terminology.md
index 54a868ad77..d528551c4c 100644
--- a/_overviews/quasiquotes/terminology.md
+++ b/_overviews/quasiquotes/terminology.md
@@ -13,12 +13,12 @@ permalink: /overviews/quasiquotes/:title.html
 ---
 <span class="tag" style="float: right;">EXPERIMENTAL</span>
 
-* **Quasiquote** (not quasi-quote) can refer to either the quasiquote library or any usage of one its [interpolators](/overviews/quasiquotes/intro.html#interpolators). The name is not hyphenated for the sake of consistency with implementations of the same concept in other languages (e.g. [Scheme and Racket](http://docs.racket-lang.org/reference/quasiquote.html), [Haskell](http://www.haskell.org/haskellwiki/Quasiquotation))
+* **Quasiquote** (not quasi-quote) can refer to either the quasiquote library or any usage of one its [interpolators](intro.html#interpolators). The name is not hyphenated for the sake of consistency with implementations of the same concept in other languages (e.g. [Scheme and Racket](http://docs.racket-lang.org/reference/quasiquote.html), [Haskell](http://www.haskell.org/haskellwiki/Quasiquotation))
 * **Tree** or **AST** (Abstract Syntax Tree) is a representation of a Scala program or a part of it through means of the Scala reflection API's Tree type.
 * **Tree construction** refers to usages of quasiquotes as expressions to represent creation of new tree values.
 * **Tree deconstruction** refers to usages of quasiquotes as patterns to structurally tear apart trees.
 * **Unquoting** is a way of either putting things in or extracting things out of quasiquotes. Can be performed with `$` syntax within a quasiquote.
 * **Unquote splicing** (or just splicing) is another form of unquoting that flattens contents of the unquotee into a tree. Can be performed with either `..$` or `...$` syntax.
 * **Rank** is a degree of flattenning of unquotee: `rank($) == 0`, `rank(..$) == 1`, `rank(...$) == 2`.
-* [**Lifting**](/overviews/quasiquotes/lifting.html) is a way to unquote non-tree values and transform them into trees with the help of the `Liftable` typeclass.
-* [**Unlifting**](/overviews/quasiquotes/unlifting.html) is a way to unquote non-tree values out of quasiquote patterns with the help of the `Unliftable` typeclass.
+* [**Lifting**](lifting.html) is a way to unquote non-tree values and transform them into trees with the help of the `Liftable` typeclass.
+* [**Unlifting**](unlifting.html) is a way to unquote non-tree values out of quasiquote patterns with the help of the `Unliftable` typeclass.
diff --git a/_overviews/quasiquotes/type-details.md b/_overviews/quasiquotes/type-details.md
index af87eb505c..b9d6929f22 100644
--- a/_overviews/quasiquotes/type-details.md
+++ b/_overviews/quasiquotes/type-details.md
@@ -17,13 +17,13 @@ permalink: /overviews/quasiquotes/:title.html
 
 The empty type (`tq""`) is a canonical way to say that the type at given location isn't given by the user and should be inferred by the compiler:
 
-1. [Method](/overviews/quasiquotes/definition-details.html#method-definition) with unknown return type
-2. [Val or Var](/overviews/quasiquotes/definition-details.html#val-and-var-definitions) with unknown type
-3. [Anonymous function](/overviews/quasiquotes/expression-details.html#function) with unknown argument type
+1. [Method](definition-details.html#method-definition) with unknown return type
+2. [Val or Var](definition-details.html#val-and-var-definitions) with unknown type
+3. [Anonymous function](expression-details.html#function) with unknown argument type
 
 ## Type Identifier
 
-Similarly to [term identifiers](/overviews/quasiquotes/expression-details.html#identifier-and-selection) one can construct a type identifier based on a name:
+Similarly to [term identifiers](expression-details.html#identifier-and-selection) one can construct a type identifier based on a name:
 
     scala> val name = TypeName("Foo")
     name: universe.TypeName = Foo
@@ -31,7 +31,7 @@ Similarly to [term identifiers](/overviews/quasiquotes/expression-details.html#i
     scala> val foo = tq"$name"
     foo: universe.Ident = Foo
 
-And deconstruct it back through [unlifting](/overviews/quasiquotes/unlifting.html):
+And deconstruct it back through [unlifting](unlifting.html):
 
     scala> val tq"${name: TypeName}" = tq"Foo"
     name: universe.TypeName = Foo
@@ -74,7 +74,7 @@ But semantically, such selections are just a shortcut for a combination of singl
     scala> val projected = tq"scala.type#Int"
     projected: universe.SelectFromTypeTree = scala.type#Int
 
-Lastly and [similarly to expressions](/overviews/quasiquotes/expression-details.html#super-and-this) one can select members through `super` and `this`:
+Lastly and [similarly to expressions](expression-details.html#super-and-this) one can select members through `super` and `this`:
 
     scala> val superbar = tq"super.Bar"
     superbar: universe.Select = super.Bar
@@ -159,7 +159,7 @@ Alternatively there is also an underscrore notation:
 
 ## Tuple Type
 
-[Similar to expressions](/overviews/quasiquotes/expression-details.html#tuple), tuple types are just syntactic sugar over `TupleN` classes:
+[Similar to expressions](expression-details.html#tuple), tuple types are just syntactic sugar over `TupleN` classes:
 
     scala> val tup2 = tq"(A, B)"
     tup2: universe.Tree = scala.Tuple2[A, B]
@@ -172,7 +172,7 @@ Analogously the `Unit` type is considered to be a nullary tuple:
     scala> val tq"(..$tpts)" = tq"_root_.scala.Unit"
     tpts: List[universe.Tree] = List()
 
-It is important to mention that pattern matching a reference to `Unit` is limited to either fully the qualified path or a reference that contains symbols. (see [hygiene](/overviews/quasiquotes/hygiene.html))
+It is important to mention that pattern matching a reference to `Unit` is limited to either fully the qualified path or a reference that contains symbols. (see [hygiene](hygiene.html))
 
 ## Function Type
 
diff --git a/_overviews/quasiquotes/unlifting.md b/_overviews/quasiquotes/unlifting.md
index 72dcc8c8f5..364dd77d97 100644
--- a/_overviews/quasiquotes/unlifting.md
+++ b/_overviews/quasiquotes/unlifting.md
@@ -13,7 +13,7 @@ permalink: /overviews/quasiquotes/:title.html
 ---
 **Denys Shabalin** <span class="tag" style="float: right;">EXPERIMENTAL</span>
 
-Unlifting is the reverse operation to [lifting](/overviews/quasiquotes/lifting.html): it takes a tree and recovers a value from it:
+Unlifting is the reverse operation to [lifting](lifting.html): it takes a tree and recovers a value from it:
 
     trait Unliftable[T] {
       def unapply(tree: Tree): Option[T]
@@ -73,11 +73,11 @@ Here one must pay attention to a few nuances:
    it is expected to return an instance of `T` unconditionally.
 
 2. We've only define `Unliftable` for the runtime universe, it won't be available in macros.
-   (see [sharing liftable implementations](/overviews/quasiquotes/lifting.html#reusing-liftable-implementation-between-universes))
+   (see [sharing liftable implementations](lifting.html#reusing-liftable-implementation-between-universes))
 
 3. Patterns used in this unliftable will only match a fully qualified reference to `Point` that
    starts with `_root_`. It won't match other possible shapes of the reference; they have
-   to be specified by hand. This problem is caused by a lack of [hygiene](/overviews/quasiquotes/hygiene.html).
+   to be specified by hand. This problem is caused by a lack of [hygiene](hygiene.html).
 
 4. The pattern will only match trees that have literal `Int` arguments.
    It won't work for other expressions that might evaluate to `Int`.
diff --git a/_overviews/reflection/annotations-names-scopes.md b/_overviews/reflection/annotations-names-scopes.md
index e5bc6c266d..804fd100e2 100644
--- a/_overviews/reflection/annotations-names-scopes.md
+++ b/_overviews/reflection/annotations-names-scopes.md
@@ -142,7 +142,7 @@ an abstract syntax tree and an internal type tag to provide access to the type
 of the tree. `Expr`s are mainly used to simply and conveniently create typed
 abstract syntax trees for use in a macro. In most cases, this involves methods
 `reify` and `splice` (see the
-[macros guide](http://docs.scala-lang.org/overviews/macros/overview.html) for details).
+[macros guide]({{ site.baseurl }}/overviews/macros/overview.html) for details).
 
 ## Flags and flag sets
 
diff --git a/_overviews/reflection/changelog211.md b/_overviews/reflection/changelog211.md
index ab49dd7842..92c7f2e173 100644
--- a/_overviews/reflection/changelog211.md
+++ b/_overviews/reflection/changelog211.md
@@ -15,4 +15,4 @@ permalink: /overviews/reflection/:title.html
 
 **Eugene Burmako**
 
-The page lives at [/overviews/macros/changelog211.html](/overviews/macros/changelog211.html).
+The page lives at [/overviews/macros/changelog211.html]({{ site.baseurl }}/overviews/macros/changelog211.html).
diff --git a/_overviews/scaladoc/for-library-authors.md b/_overviews/scaladoc/for-library-authors.md
index cb5a733d0f..a0f3639d0d 100644
--- a/_overviews/scaladoc/for-library-authors.md
+++ b/_overviews/scaladoc/for-library-authors.md
@@ -196,4 +196,4 @@ Some of the standard markup available:
 ## More details on writing Scaladoc
 
 Further information on the formatting and style recommendations can be found in
-[Scala-lang scaladoc style guide](http://docs.scala-lang.org/style/scaladoc.html).
+[Scala-lang scaladoc style guide]({{ site.baseurl }}/style/scaladoc.html).
diff --git a/_overviews/scaladoc/overview.md b/_overviews/scaladoc/overview.md
index 3aa7de3d34..efe893b729 100644
--- a/_overviews/scaladoc/overview.md
+++ b/_overviews/scaladoc/overview.md
@@ -19,14 +19,14 @@ based on other comment based documentation systems like Javadoc.
 
 There are two flavors of Scaladoc documentation:
 
-  - **[Using the Scaladoc interface](/overviews/scaladoc/interface.html)** – how to navigate and use generated Scaladoc documentation to learn more about a library.
-  - **[Generating documentation for your library with Scaladoc](/overviews/scaladoc/for-library-authors.html)** – how to use Scaladoc to generate documentation for your library.
+  - **[Using the Scaladoc interface]({{ site.baseurl }}/overviews/scaladoc/interface.html)** – how to navigate and use generated Scaladoc documentation to learn more about a library.
+  - **[Generating documentation for your library with Scaladoc]({{ site.baseurl }}/overviews/scaladoc/for-library-authors.html)** – how to use Scaladoc to generate documentation for your library.
 
 ### Contributing to Scaladoc
 
 If you are interested in contributing to the API documentation of the Scala
 standard library (the documentation generated by Scaladoc), please read the
-[Scaladoc for Library Authors](/overviews/scaladoc/basics.html) first.
+[Scaladoc for Library Authors]({{ site.baseurl }}/overviews/scaladoc/basics.html) first.
 
 If you'd like to contribute to the actual Scaladoc documentation generation
 tool itself, then please see the
diff --git a/_style/scaladoc.md b/_style/scaladoc.md
index 6d21ca49f4..d173a80b11 100644
--- a/_style/scaladoc.md
+++ b/_style/scaladoc.md
@@ -51,7 +51,7 @@ In particular, text is aligned on a multiple of two columns,
 since Scala source is usually indented by two columns.
 
 See
-[Scaladoc for Library Authors](/overviews/scaladoc/for-library-authors.html)
+[Scaladoc for Library Authors]({{ site.baseurl }}/overviews/scaladoc/for-library-authors.html)
 for more technical info on formatting Scaladoc.
 
 ## General Style
diff --git a/_tour/singleton-objects.md b/_tour/singleton-objects.md
index 0ac90f1997..af76b4f90f 100644
--- a/_tour/singleton-objects.md
+++ b/_tour/singleton-objects.md
@@ -34,7 +34,7 @@ A singleton object can extend classes and traits. In fact, a [case class](case-c
 
 Most singleton objects do not stand alone, but instead are associated with a class of the same name. The “singleton object of the same name” of a case class, mentioned above, is an example of this. When this happens, the singleton object is called the *companion object* of the class, and the class is called the *companion class* of the object.
 
-[Scaladoc](/style/scaladoc.html) has special support for jumping between a class and its companion: if the big “C” or “O” circle has its edge folded up at the bottom, you can click the circle to jump to the companion.
+[Scaladoc]({{ site.baseurl }}/style/scaladoc.html) has special support for jumping between a class and its companion: if the big “C” or “O” circle has its edge folded up at the bottom, you can click the circle to jump to the companion.
 
 A class and its companion object, if any, must be defined in the same source file. Like this:
 
diff --git a/_tour/tour-of-scala.md b/_tour/tour-of-scala.md
index 0db0db67ae..5ec4d674b2 100644
--- a/_tour/tour-of-scala.md
+++ b/_tour/tour-of-scala.md
@@ -19,7 +19,7 @@ Scala is a modern multi-paradigm programming language designed to express common
 Scala is a pure object-oriented language in the sense that [every value is an object](unified-types.html). Types and behavior of objects are described by [classes](classes.html) and [traits](traits.html). Classes are extended by subclassing and a flexible [mixin-based composition](mixin-class-composition.html) mechanism as a clean replacement for multiple inheritance.
 
 ## Scala is functional ##
-Scala is also a functional language in the sense that [every function is a value](unified-types.html). Scala provides a [lightweight syntax](basic.html#functions) for defining anonymous functions, it supports [higher-order functions](higher-order-functions.html), it allows functions to be [nested](nested-functions.html), and supports [currying](currying.html). Scala's [case classes](case-classes.html) and its built-in support for [pattern matching](pattern-matching.html) model algebraic types used in many functional programming languages. [Singleton objects](singleton-objects.html) provide a convenient way to group functions that aren't members of a class.
+Scala is also a functional language in the sense that [every function is a value](unified-types.html). Scala provides a [lightweight syntax](basics.html#functions) for defining anonymous functions, it supports [higher-order functions](higher-order-functions.html), it allows functions to be [nested](nested-functions.html), and supports [currying](currying.html). Scala's [case classes](case-classes.html) and its built-in support for [pattern matching](pattern-matching.html) model algebraic types used in many functional programming languages. [Singleton objects](singleton-objects.html) provide a convenient way to group functions that aren't members of a class.
 
 Furthermore, Scala's notion of pattern matching naturally extends to the [processing of XML data](https://github.com/scala/scala-xml/wiki/XML-Processing) with the help of [right-ignoring sequence patterns](regular-expression-patterns.html), by way of general extension via [extractor objects](extractor-objects.html). In this context, [for comprehensions](for-comprehensions.html) are useful for formulating queries. These features make Scala ideal for developing applications like web services.
 
diff --git a/contribute.md b/contribute.md
index 2ce673eb56..6d8866e325 100644
--- a/contribute.md
+++ b/contribute.md
@@ -124,7 +124,7 @@ At the moment, a tutorial that can be logically placed on **one** page must be p
     title: YOUR TITLE
     ---
 
-If you have a **multiple-page** tutorial, like in the case of multiple-page overviews, you must both specify an ordering for your document, and a name must be assigned to the collection of tutorial pages. For example, the following header is used for the [Tour of Scala]({{ site.baseurl }}/tutorials) series of tutorial articles:
+If you have a **multiple-page** tutorial, like in the case of multiple-page overviews, you must both specify an ordering for your document, and a name must be assigned to the collection of tutorial pages. For example, the following header is used for the [Tour of Scala]({{ site.baseurl }}/tour/tour-of-scala.html) series of tutorial articles:
 
     ---
     layout: inner-page-no-masthead
diff --git a/reference.md b/reference.md
index 06e00783bc..b4eda7cc83 100644
--- a/reference.md
+++ b/reference.md
@@ -7,8 +7,8 @@ includeTOC: true
 ---
 
 ## Quick Reference
-* [Glossary](/glossary/) of Scala terms
-* [Cheatsheet](/cheatsheets/) for syntax. This can be useful for quickly picking up the syntax once you understand the basics of the language.
+* [Glossary]({{ site.baseurl }}/glossary/) of Scala terms
+* [Cheatsheet]({{ site.baseurl }}/cheatsheets/) for syntax. This can be useful for quickly picking up the syntax once you understand the basics of the language.
 
 ## Search the API
 The searchable API docs below are an invaluable resource as you make use of the Scala libraries. For newcomers to Scala, start with the [Standard Library API for 2.12.2](http://www.scala-lang.org/api/2.12.2/).