From 190279ddb66036f73ac589d11ffa2413a55180cd Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 15 Jan 2019 16:49:25 -0500
Subject: [PATCH 01/25] 2.6: document ESM browser build

---
 src/v2/guide/installation.md | 38 ++++++++++++++++++++++++++----------
 1 file changed, 28 insertions(+), 10 deletions(-)

diff --git a/src/v2/guide/installation.md b/src/v2/guide/installation.md
index d0f344adec..db4bc05c0f 100644
--- a/src/v2/guide/installation.md
+++ b/src/v2/guide/installation.md
@@ -27,17 +27,31 @@ Simply download and include with a script tag. `Vue` will be registered as a glo
 <p class="tip">Don't use the minified version during development. You will miss out on all the nice warnings for common mistakes!</p>
 
 <div id="downloads">
-<a class="button" href="/js/vue.js" download>Development Version</a><span class="light info">With full warnings and debug mode</span>
+  <a class="button" href="/js/vue.js" download>Development Version</a><span class="light info">With full warnings and debug mode</span>
 
-<a class="button" href="/js/vue.min.js" download>Production Version</a><span class="light info">Warnings stripped, {{gz_size}}KB min+gzip</span>
+  <a class="button" href="/js/vue.min.js" download>Production Version</a><span class="light info">Warnings stripped, {{gz_size}}KB min+gzip</span>
 </div>
 
 ### CDN
 
-We recommend linking to a specific version number that you can update manually:
+For prototyping or learning purposes, you can use the latest version with:
 
 ``` html
-<script src="https://cdn.jsdelivr.net/npm/vue@2.5.16/dist/vue.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/vue"></script>
+```
+
+For production, we recommend linking to a specific version number and build to avoid unexpected breakage from newer versions:
+
+``` html
+<script src="https://cdn.jsdelivr.net/npm/vue@2.6.0/dist/vue.js"></script>
+```
+
+If you are using ES Modules, there is also an ES Modules compatible build:
+
+``` html
+<script type="module">
+  import Vue from 'https://cdn.jsdelivr.net/npm/vue@2.6.0/dist/vue.esm.browser.js'
+</script>
 ```
 
 You can browse the source of the NPM package at [cdn.jsdelivr.net/npm/vue](https://cdn.jsdelivr.net/npm/vue/).
@@ -68,12 +82,12 @@ Vue provides an [official CLI](https://github.com/vuejs/vue-cli) for quickly sca
 
 In the [`dist/` directory of the NPM package](https://cdn.jsdelivr.net/npm/vue/dist/) you will find many different builds of Vue.js. Here's an overview of the difference between them:
 
-| | UMD | CommonJS | ES Module |
+| | UMD | CommonJS | ES Module (for bundlers) | ES Module (for browsers)
 | --- | --- | --- | --- |
-| **Full** | vue.js | vue.common.js | vue.esm.js |
-| **Runtime-only** | vue.runtime.js | vue.runtime.common.js | vue.runtime.esm.js |
-| **Full (production)** | vue.min.js | - | - |
-| **Runtime-only (production)** | vue.runtime.min.js | - | - |
+| **Full** | vue.js | vue.common.js | vue.esm.js | vue.esm.browser.js |
+| **Runtime-only** | vue.runtime.js | vue.runtime.common.js | vue.runtime.esm.js | - |
+| **Full (production)** | vue.min.js | - | - | vue.esm.browser.min.js |
+| **Runtime-only (production)** | vue.runtime.min.js | - | - | - |
 
 ### Terms
 
@@ -87,7 +101,11 @@ In the [`dist/` directory of the NPM package](https://cdn.jsdelivr.net/npm/vue/d
 
 - **[CommonJS](http://wiki.commonjs.org/wiki/Modules/1.1)**: CommonJS builds are intended for use with older bundlers like [browserify](http://browserify.org/) or [webpack 1](https://webpack.github.io). The default file for these bundlers (`pkg.main`) is the Runtime only CommonJS build (`vue.runtime.common.js`).
 
-- **[ES Module](http://exploringjs.com/es6/ch_modules.html)**: ES module builds are intended for use with modern bundlers like [webpack 2](https://webpack.js.org) or [rollup](https://rollupjs.org/). The default file for these bundlers (`pkg.module`) is the Runtime only ES Module build (`vue.runtime.esm.js`).
+- **[ES Module](http://exploringjs.com/es6/ch_modules.html)**: starting in 2.6 Vue provides two ES Modules (ESM) builds:
+
+  - ESM for bundlers: intended for use with modern bundlers like [webpack 2](https://webpack.js.org) or [rollup](https://rollupjs.org/). ESM format is designed to be statically analyzable so the bundlers can take advantage of that to perform "tree-shaking" and eliminate unused code from your final bundle. The default file for these bundlers (`pkg.module`) is the Runtime only ES Module build (`vue.runtime.esm.js`).
+
+  - ESM for browsers (2.6+ only): intended for direct imports in modern browsers via `<script type="module">`.
 
 ### Runtime + Compiler vs. Runtime-only
 

From 177f0afbaffa8a0e9de121413e83b257a91a1b81 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 15 Jan 2019 17:04:12 -0500
Subject: [PATCH 02/25] 2.6: document Vue.observable

---
 src/v2/api/index.md | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index 8c3411c354..090d7c4bab 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -402,6 +402,33 @@ type: api
 
 - **See also:** [Render Functions](../guide/render-function.html)
 
+### Vue.observable( value )
+
+> New in 2.6.0+
+
+- **Arguments:**
+  - `{object} value`
+
+- **Usage:**
+
+  Explicitly creates a reactive object. This is what Vue performs internally on objects returned from a component's `data()` function.
+
+  The returned object can be used directly inside [render functions](../guide/render-function.html) and [computed properties](../guide/computed.html), and will trigger appropriate updates when mutated. It can be used as a minimal cross-component state store for simple scenarios.
+
+  ``` js
+  const obj = Vue.observable({ count: 0 })
+
+  const Demo = {
+    render(h) {
+      return h('button', {
+        on: { click: () => { obj.count++ }}
+      }, `count is: ${obj.count}`)
+    }
+  }
+  ```
+
+- **See also:** [Reactivity in Depth](../guide/reactivity.html)
+
 ### Vue.version
 
 - **Details**: Provides the installed version of Vue as a string. This is especially useful for community plugins and components, where you might use different strategies for different versions.

From f639b8310d33142f3710075db89799f429bae969 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 15 Jan 2019 17:10:10 -0500
Subject: [PATCH 03/25] 2.6: document shorthand for v-bind .prop modifier

---
 src/v2/api/index.md    |  3 +++
 src/v2/guide/syntax.md | 14 +++++++++++++-
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index 090d7c4bab..a1fda35210 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -2142,6 +2142,9 @@ type: api
   <!-- DOM attribute binding with prop modifier -->
   <div v-bind:text-content.prop="text"></div>
 
+  <!-- shorthand for prop modifier (2.6+) -->
+  <div .text-content="text"></div>
+
   <!-- prop binding. "prop" must be declared in my-component. -->
   <my-component :prop="someThing"></my-component>
 
diff --git a/src/v2/guide/syntax.md b/src/v2/guide/syntax.md
index 2f28d967d1..acfb685c65 100644
--- a/src/v2/guide/syntax.md
+++ b/src/v2/guide/syntax.md
@@ -66,7 +66,7 @@ Mustaches cannot be used inside HTML attributes. Instead, use a [v-bind directiv
 <div v-bind:id="dynamicId"></div>
 ```
 
-In the case of boolean attributes, where their mere existence implies `true`, `v-bind` works a little differently. In this example: 
+In the case of boolean attributes, where their mere existence implies `true`, `v-bind` works a little differently. In this example:
 
 ``` html
 <button v-bind:disabled="isButtonDisabled">Button</button>
@@ -152,6 +152,18 @@ The `v-` prefix serves as a visual cue for identifying Vue-specific attributes i
 <a :href="url"> ... </a>
 ```
 
+> New in 2.6
+
+In 2.6 a separate shorthand for explicit DOM property bindings (with the `.prop` modifier) have been introduced:
+
+``` html
+<!-- full syntax -->
+<video v-bind:muted.prop="isMuted"> ... </video>
+
+<!-- shorthand -->
+<video .muted="isMuted"> ... </video>
+```
+
 ### `v-on` Shorthand
 
 ``` html

From 5295c84ae0f49055b5250d11f168a6bbefb8c737 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 15 Jan 2019 17:19:24 -0500
Subject: [PATCH 04/25] 2.6: document $scopedSlots changes

---
 src/v2/api/index.md | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index a1fda35210..aca0cfbbee 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -1418,7 +1418,7 @@ type: api
 
 > New in 2.1.0+
 
-- **Type:** `{ [name: string]: props => VNode | Array<VNode> }`
+- **Type:** `{ [name: string]: props => Array<VNode> | undefined }`
 
 - **Read only**
 
@@ -1428,6 +1428,12 @@ type: api
 
   Accessing `vm.$scopedSlots` is most useful when writing a component with a [render function](../guide/render-function.html).
 
+  **Note:** since 2.6.0+, there are two notable changes to this property:
+
+  1. Scoped slot functions now are guaranteed to return Array of VNodes, unless the return value is invalid, in which case the function will return `undefined`.
+
+  2. All normal slots on `vm.$slots` are now also exposed on `vm.$scopeSlots` as functions. If you work with render functions, it is now recommended to always access all slots via `vm.$scopedSlots` for consistency.
+
 - **See also:**
   - [`<slot>` Component](#slot-1)
   - [Scoped Slots](../guide/components.html#Scoped-Slots)

From 3ca4eeae9b974c554c1fb6cb047e65e0239b49e7 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 15 Jan 2019 17:24:28 -0500
Subject: [PATCH 05/25] 2.6: document errorHandler improvements

---
 src/v2/api/index.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index aca0cfbbee..1679c2236e 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -84,6 +84,8 @@ type: api
 
   > In 2.4.0+ this hook also captures errors thrown inside Vue custom event handlers.
 
+  > In 2.6.0+ this hook also captures errors thrown inside `v-on` DOM listeners. In addition, if any of the covered hooks or handlers returns a Promise chain (e.g. async functions), the error from that Promise chain will also be handled.
+
   > Error tracking services [Sentry](https://sentry.io/for/vue/) and [Bugsnag](https://docs.bugsnag.com/platforms/browsers/vue/) provide official integrations using this option.
 
 ### warnHandler

From 036bf19192b3187710df6c4a38b3ad1cbe115aea Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 15 Jan 2019 17:26:03 -0500
Subject: [PATCH 06/25] 2.6 document scopedSlots on functional context

---
 src/v2/guide/render-function.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/v2/guide/render-function.md b/src/v2/guide/render-function.md
index be320bfe7c..068f176249 100644
--- a/src/v2/guide/render-function.md
+++ b/src/v2/guide/render-function.md
@@ -536,6 +536,7 @@ Everything the component needs is passed through `context`, which is an object c
 - `props`: An object of the provided props
 - `children`: An array of the VNode children
 - `slots`: A function returning a slots object
+- `scopedSlots`: (2.6.0+) An object that exposes passed-in scoped slots
 - `data`: The entire [data object](#The-Data-Object-In-Depth), passed to the component as the 2nd argument of `createElement`
 - `parent`: A reference to the parent component
 - `listeners`: (2.3.0+) An object containing parent-registered event listeners. This is an alias to `data.on`

From 2d7a9182c741cddfdf2a91209587c35c9e28e3d7 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 15 Jan 2019 17:31:35 -0500
Subject: [PATCH 07/25] 2.6: document v-for iterable support

---
 src/v2/api/index.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index 1679c2236e..594e449955 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -1980,7 +1980,7 @@ type: api
 
 ### v-for
 
-- **Expects:** `Array | Object | number | string`
+- **Expects:** `Array | Object | number | string | Iterable (since 2.6)`
 
 - **Usage:**
 
@@ -2008,6 +2008,8 @@ type: api
   </div>
   ```
 
+  Since 2.6, `v-for` can also work on values that implements the [Iterable Protocol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol), including native `Map` and `Set`. However it should be noted that Vue 2.x currently does not support reactivity detection on `Map` and `Set` values.
+
   <p class="tip">When used together with v-if, v-for has a higher priority than v-if. See the <a href="../guide/list.html#v-for-with-v-if">list rendering guide</a> for details.</p>
 
   The detailed usage for `v-for` is explained in the guide section linked below.

From eb9c932325d4f35405668f7bab8312820a684e16 Mon Sep 17 00:00:00 2001
From: GU Yiling <justice360@gmail.com>
Date: Wed, 16 Jan 2019 09:57:10 -0500
Subject: [PATCH 08/25] 2.6: apply suggestions from code review

Co-Authored-By: yyx990803 <yyx990803@gmail.com>
---
 src/v2/api/index.md          | 4 ++--
 src/v2/guide/installation.md | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index 594e449955..6a13265b0f 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -409,7 +409,7 @@ type: api
 > New in 2.6.0+
 
 - **Arguments:**
-  - `{object} value`
+  - `{Object} value`
 
 - **Usage:**
 
@@ -2008,7 +2008,7 @@ type: api
   </div>
   ```
 
-  Since 2.6, `v-for` can also work on values that implements the [Iterable Protocol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol), including native `Map` and `Set`. However it should be noted that Vue 2.x currently does not support reactivity detection on `Map` and `Set` values.
+  Since 2.6, `v-for` can also work on values that implement the [Iterable Protocol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol), including native `Map` and `Set`. However it should be noted that Vue 2.x currently does not support reactivity detection on `Map` and `Set` values.
 
   <p class="tip">When used together with v-if, v-for has a higher priority than v-if. See the <a href="../guide/list.html#v-for-with-v-if">list rendering guide</a> for details.</p>
 
diff --git a/src/v2/guide/installation.md b/src/v2/guide/installation.md
index db4bc05c0f..1f16888f13 100644
--- a/src/v2/guide/installation.md
+++ b/src/v2/guide/installation.md
@@ -82,8 +82,8 @@ Vue provides an [official CLI](https://github.com/vuejs/vue-cli) for quickly sca
 
 In the [`dist/` directory of the NPM package](https://cdn.jsdelivr.net/npm/vue/dist/) you will find many different builds of Vue.js. Here's an overview of the difference between them:
 
-| | UMD | CommonJS | ES Module (for bundlers) | ES Module (for browsers)
-| --- | --- | --- | --- |
+| | UMD | CommonJS | ES Module (for bundlers) | ES Module (for browsers) |
+| --- | --- | --- | --- | --- |
 | **Full** | vue.js | vue.common.js | vue.esm.js | vue.esm.browser.js |
 | **Runtime-only** | vue.runtime.js | vue.runtime.common.js | vue.runtime.esm.js | - |
 | **Full (production)** | vue.min.js | - | - | vue.esm.browser.min.js |

From 1aa67808bdf3256115fd588cce14753d94e24ae1 Mon Sep 17 00:00:00 2001
From: Phan An <me@phanan.net>
Date: Wed, 16 Jan 2019 11:04:16 -0500
Subject: [PATCH 09/25] case tweak

Co-Authored-By: yyx990803 <yyx990803@gmail.com>
---
 src/v2/guide/installation.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/v2/guide/installation.md b/src/v2/guide/installation.md
index 1f16888f13..24d2e83e67 100644
--- a/src/v2/guide/installation.md
+++ b/src/v2/guide/installation.md
@@ -103,7 +103,7 @@ In the [`dist/` directory of the NPM package](https://cdn.jsdelivr.net/npm/vue/d
 
 - **[ES Module](http://exploringjs.com/es6/ch_modules.html)**: starting in 2.6 Vue provides two ES Modules (ESM) builds:
 
-  - ESM for bundlers: intended for use with modern bundlers like [webpack 2](https://webpack.js.org) or [rollup](https://rollupjs.org/). ESM format is designed to be statically analyzable so the bundlers can take advantage of that to perform "tree-shaking" and eliminate unused code from your final bundle. The default file for these bundlers (`pkg.module`) is the Runtime only ES Module build (`vue.runtime.esm.js`).
+  - ESM for bundlers: intended for use with modern bundlers like [webpack 2](https://webpack.js.org) or [Rollup](https://rollupjs.org/). ESM format is designed to be statically analyzable so the bundlers can take advantage of that to perform "tree-shaking" and eliminate unused code from your final bundle. The default file for these bundlers (`pkg.module`) is the Runtime only ES Module build (`vue.runtime.esm.js`).
 
   - ESM for browsers (2.6+ only): intended for direct imports in modern browsers via `<script type="module">`.
 

From cdf7ca330246e4774b345bb2e0ba38b4fcc727a9 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Wed, 16 Jan 2019 11:06:47 -0500
Subject: [PATCH 10/25] 2.6: add a note about functional context scopedSlots
 also exposing normal slots

---
 src/v2/guide/render-function.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/v2/guide/render-function.md b/src/v2/guide/render-function.md
index 068f176249..4aadc884c9 100644
--- a/src/v2/guide/render-function.md
+++ b/src/v2/guide/render-function.md
@@ -536,7 +536,7 @@ Everything the component needs is passed through `context`, which is an object c
 - `props`: An object of the provided props
 - `children`: An array of the VNode children
 - `slots`: A function returning a slots object
-- `scopedSlots`: (2.6.0+) An object that exposes passed-in scoped slots
+- `scopedSlots`: (2.6.0+) An object that exposes passed-in scoped slots. Also exposes normal slots as functions.
 - `data`: The entire [data object](#The-Data-Object-In-Depth), passed to the component as the 2nd argument of `createElement`
 - `parent`: A reference to the parent component
 - `listeners`: (2.3.0+) An object containing parent-registered event listeners. This is an alias to `data.on`

From 746f12841e40a1c2e2a878620d1c7abf427717bc Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 28 Jan 2019 16:33:55 -0500
Subject: [PATCH 11/25] 2.6: dynamic arguments

---
 src/v2/guide/syntax.md | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/src/v2/guide/syntax.md b/src/v2/guide/syntax.md
index acfb685c65..0e5cf9d3c8 100644
--- a/src/v2/guide/syntax.md
+++ b/src/v2/guide/syntax.md
@@ -128,6 +128,38 @@ Another example is the `v-on` directive, which listens to DOM events:
 
 Here the argument is the event name to listen to. We will talk about event handling in more detail too.
 
+### Dynamic Arguments
+
+> New in 2.6
+
+Starting in 2.6, it is also possible to use JavaScript expressions in an directive argument by wrapping it with square brackets:
+
+``` html
+<a v-bind:[key]="url"> ... </a>
+```
+
+Here `key` will be dynamically evaluated as a JavaScript expression, and its evaluated value will be used as the final value for the argument. For example, if your Vue instance has a data property `key` whose value is `"href"`, then this binding will be equivalent to `v-bind:href`.
+
+Similarly, you can use dynamic arguments to bind a handler to a dynamic event:
+
+``` html
+<a v-on:[event]="doSomething"> ... </a>
+```
+
+#### Dynamic Argument Value Constraints
+
+Dynamic argument values are expected to be strings, with the exception of `null`. The special value `null` can be used to explicitly remove the binding. Any other non-string value will trigger a warning.
+
+#### Dynamic Argument Expression Constraints
+
+When using dynamic arguments, it is important to remember that HTML attribute names cannot contain spaces or quotes. For example, the following is invalid:
+
+``` html
+<a v-bind:['foo' + bar]="value"> ... </a>
+```
+
+The Vue template compiler will warn against such usage. The workaround is to either use expressions without spaces or quotes, or use a computed property instead.
+
 ### Modifiers
 
 Modifiers are special postfixes denoted by a dot, which indicate that a directive should be bound in some special way. For example, the `.prevent` modifier tells the `v-on` directive to call `event.preventDefault()` on the triggered event:

From 1f5b2c98f1543e112a1dcf5ce6ceea04c1f0c4d7 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 28 Jan 2019 16:38:22 -0500
Subject: [PATCH 12/25] 2.6: more examples for dynamic arguments

---
 src/v2/api/index.md    | 14 +++++++++++++-
 src/v2/guide/syntax.md |  8 +++++++-
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index 6a13265b0f..44989749e8 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -2055,12 +2055,18 @@ type: api
   <!-- method handler -->
   <button v-on:click="doThis"></button>
 
+  <!-- dynamic event (2.6.0+) -->
+  <button v-on:[event]="doThis"></button>
+
   <!-- inline statement -->
   <button v-on:click="doThat('hello', $event)"></button>
 
   <!-- shorthand -->
   <button @click="doThis"></button>
 
+  <!-- shorthand dynamic event (2.6.0+) -->
+  <button @[event]="doThis"></button>
+
   <!-- stop propagation -->
   <button @click.stop="doThis"></button>
 
@@ -2131,9 +2137,15 @@ type: api
   <!-- bind an attribute -->
   <img v-bind:src="imageSrc">
 
+  <!-- dynamic attribute name (2.6.0+) -->
+  <button v-bind:[key]="value"></button>
+
   <!-- shorthand -->
   <img :src="imageSrc">
 
+  <!-- shorthand dynamic attribute name (2.6.0+) -->
+  <button :[key]="value"></button>
+
   <!-- with inline string concatenation -->
   <img :src="'/path/to/images/' + fileName">
 
@@ -2152,7 +2164,7 @@ type: api
   <!-- DOM attribute binding with prop modifier -->
   <div v-bind:text-content.prop="text"></div>
 
-  <!-- shorthand for prop modifier (2.6+) -->
+  <!-- shorthand for prop modifier (2.6.0+) -->
   <div .text-content="text"></div>
 
   <!-- prop binding. "prop" must be declared in my-component. -->
diff --git a/src/v2/guide/syntax.md b/src/v2/guide/syntax.md
index 0e5cf9d3c8..9249e56de9 100644
--- a/src/v2/guide/syntax.md
+++ b/src/v2/guide/syntax.md
@@ -182,9 +182,12 @@ The `v-` prefix serves as a visual cue for identifying Vue-specific attributes i
 
 <!-- shorthand -->
 <a :href="url"> ... </a>
+
+<!-- shorthand with dynamic argument (2.6.0+) -->
+<a :[key]="url"> ... </a>
 ```
 
-> New in 2.6
+> DOM Property Shorthand
 
 In 2.6 a separate shorthand for explicit DOM property bindings (with the `.prop` modifier) have been introduced:
 
@@ -204,6 +207,9 @@ In 2.6 a separate shorthand for explicit DOM property bindings (with the `.prop`
 
 <!-- shorthand -->
 <a @click="doSomething"> ... </a>
+
+<!-- shorthand with dynamic argument (2.6.0+) -->
+<a @[event]="doSomething"> ... </a>
 ```
 
 They may look a bit different from normal HTML, but `:` and `@` are valid chars for attribute names and all Vue.js supported browsers can parse it correctly. In addition, they do not appear in the final rendered markup. The shorthand syntax is totally optional, but you will likely appreciate it when you learn more about its usage later.

From 535a48d6c086d1852bc354ee052737a1d0e3040c Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Mon, 28 Jan 2019 18:09:32 -0500
Subject: [PATCH 13/25] 2.6: make dynamic argument constraint more noticable

---
 src/v2/guide/syntax.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/v2/guide/syntax.md b/src/v2/guide/syntax.md
index 9249e56de9..030afcb4c2 100644
--- a/src/v2/guide/syntax.md
+++ b/src/v2/guide/syntax.md
@@ -152,7 +152,9 @@ Dynamic argument values are expected to be strings, with the exception of `null`
 
 #### Dynamic Argument Expression Constraints
 
-When using dynamic arguments, it is important to remember that HTML attribute names cannot contain spaces or quotes. For example, the following is invalid:
+<p class="tip">Dynamic argument expressions have some syntax constraints because certain characters are invalid inside HTML attribute names, in particular spaces and quotes.</p>
+
+For example, the following is invalid:
 
 ``` html
 <a v-bind:['foo' + bar]="value"> ... </a>

From 70c7b63f31fc8382784ec75cb2b8b93194f7484f Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 29 Jan 2019 18:41:58 -0500
Subject: [PATCH 14/25] 2.6: update slot guide

---
 src/v2/guide/components-slots.md | 297 ++++++++++++++++++++++++-------
 1 file changed, 235 insertions(+), 62 deletions(-)

diff --git a/src/v2/guide/components-slots.md b/src/v2/guide/components-slots.md
index cb38542f4a..a6dd7ec745 100644
--- a/src/v2/guide/components-slots.md
+++ b/src/v2/guide/components-slots.md
@@ -6,9 +6,11 @@ order: 104
 
 > This page assumes you've already read the [Components Basics](components.html). Read that first if you are new to components.
 
+> In 2.6.0, we introduced a new unified syntax (the `v-slot` directive) for named slots and scoped slots. It replaces the `slot` and `slot-scope` syntax which is still documented [here](#Legacy-Syntax). The rationale for introducing the new syntax is described in this [RFC](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0001-new-slot-syntax.md).
+
 ## Slot Content
 
-Vue implements a content distribution API that's modeled after the current [Web Components spec draft](https://github.com/w3c/webcomponents/blob/gh-pages/proposals/Slots-Proposal.md), using the `<slot>` element to serve as distribution outlets for content.
+Vue implements a content distribution API inspired by the [Web Components spec draft](https://github.com/w3c/webcomponents/blob/gh-pages/proposals/Slots-Proposal.md), using the `<slot>` element to serve as distribution outlets for content.
 
 This allows you to compose components like this:
 
@@ -51,6 +53,34 @@ Or even other components:
 
 If `<navigation-link>` did **not** contain a `<slot>` element, any content passed to it would simply be discarded.
 
+## Compilation Scope
+
+When you want to use data inside a slot, such as in:
+
+``` html
+<navigation-link url="/profile">
+  Logged in as {{ user.name }}
+</navigation-link>
+```
+
+That slot has access to the same instance properties (i.e. the same "scope") as the rest of the template. The slot does **not** have access to `<navigation-link>`'s scope. For example, trying to access `url` would not work. As a rule, remember that:
+
+> Everything in the parent template is compiled in parent scope; everything in the child template is compiled in the child scope.
+
+## Fallback Content
+
+There are cases when it's useful to provide a slot with fallback content, which is rendered when the parent did not provide content for the slot. For example, a `<submit-button>` component might want the content of the button to be "Submit" by default, but also allow users to override with "Save", "Upload", or anything else.
+
+To achieve this, specify the fallback content in between the `<slot>` tags in your component's template:
+
+```html
+<button type="submit">
+  <slot>Submit</slot>
+</button>
+```
+
+The fallback content "Submit" only gets rendered if the parent did not provide any slot content.
+
 ## Named Slots
 
 There are times when it's useful to have multiple slots. For example, in a hypothetical `base-layout` component with the following template:
@@ -85,91 +115,134 @@ For these cases, the `<slot>` element has a special attribute, `name`, which can
 </div>
 ```
 
-To provide content to named slots, we can use the `slot` attribute on a `<template>` element in the parent:
+A `<slot>` outlet without `name` implicitly has the name "default".
+
+To provide content to named slots, we can use the `v-slot` directive on a `<template>` element in the parent, using the directive argument to indicate which named slot the content is being passed to:
 
 ```html
 <base-layout>
-  <template slot="header">
+  <template v-slot:header>
     <h1>Here might be a page title</h1>
   </template>
 
-  <p>A paragraph for the main content.</p>
-  <p>And another one.</p>
+  <template v-slot:default>
+    <p>A paragraph for the main content.</p>
+    <p>And another one.</p>
+  </template>
 
-  <template slot="footer">
+  <template v-slot:footer>
     <p>Here's some contact info</p>
   </template>
 </base-layout>
 ```
 
-Or, the `slot` attribute can also be used directly on a normal element:
+Note that unlike the legacy `slot` attribute, `v-slot` must appear on a `<template>` wrapper when being used to denote named slots. The only exception is when used directly on a component tag to denote a [default slot with props](#Default-Slot-with-Props).
 
-``` html
+### Named Slots Shorthand
+
+Similar to `v-on` and `v-bind`, `v-slot` also has a shorthand, replacing everything before the argument with the special symbol `#`. The above example can also be written as:
+
+```html
 <base-layout>
-  <h1 slot="header">Here might be a page title</h1>
+  <template #header>
+    <h1>Here might be a page title</h1>
+  </template>
 
-  <p>A paragraph for the main content.</p>
-  <p>And another one.</p>
+  <template #default>
+    <p>A paragraph for the main content.</p>
+    <p>And another one.</p>
+  </template>
 
-  <p slot="footer">Here's some contact info</p>
+  <template #footer>
+    <p>Here's some contact info</p>
+  </template>
 </base-layout>
 ```
 
-There can still be one unnamed slot, which is the **default slot** that serves as a catch-all outlet for any unmatched content. In both examples above, the  rendered HTML would be:
+### Dynamic Slot Names
+
+Dynamic directive arguments also work on `v-slot`:
 
 ``` html
-<div class="container">
-  <header>
-    <h1>Here might be a page title</h1>
-  </header>
-  <main>
-    <p>A paragraph for the main content.</p>
-    <p>And another one.</p>
-  </main>
-  <footer>
-    <p>Here's some contact info</p>
-  </footer>
-</div>
+<base-layout>
+  <template v-slot:[dynamicSlotName]>
+    ...
+  </template>
+
+  <!-- shorthand equivalent -->
+  <template #[anotherSlotName]>
+    ...
+  </template>
+</base-layout>
 ```
 
-## Default Slot Content
+## Slot Props
 
-There are cases when it's useful to provide a slot with default content. For example, a `<submit-button>` component might want the content of the button to be "Submit" by default, but also allow users to override with "Save", "Upload", or anything else.
+So far we have seen that the slot feature allows a child component to compose content passed from the parent with its own template. However, in some cases the child component may wish to customize the slot content based on its own data, which the parent has no access to. It would be great if the child can pass props to `<slot>` outlets. Imagine we have a `<slot-example>` component with the following template:
 
-To achieve this, specify the default content in between the `<slot>` tags in your component's template:
+``` html
+<!-- slot-example -->
+<span>
+  <slot v-bind:msg="myMessage"></slot>
+</span>
+```
 
-```html
-<button type="submit">
-  <slot>Submit</slot>
-</button>
+In order to receive and make use of the props being passed to a slot, the parent component declares the props received using the attribute value of the `v-slot` directive:
+
+``` html
+<slot-example>
+  <template v-slot:default="slotProps">
+    {{ slotProps.msg }}
+  </template>
+</slot-example>
 ```
 
-If the slot is provided content by the parent, it will replace the default content.
+Here you can name `slotProps` anything you like, just like declaring a function argument in JavaScript. The declared variable will become available inside the scope of the slot's `<template>`.
 
-## Compilation Scope
+Slots that expect props are also known as "scoped slots", as they create a "scope" within which the received props can be used.
 
-When you want to use data inside a slot, such as in:
+<p class="tip">The `v-slot` syntax is introduced in 2.6.0 and is not supported in older versions. The legacy `slot` and `slot-scope` syntax is still supported in 2.6, and is documented [here](#Legacy-Syntax).</p>
+
+### Default Slot with Props
+
+When there is only the default slot, the `v-slot` directive can be placed directly on the component itself, and the `default` argument can also be omitted. The above example can thus be simplified to:
 
 ``` html
-<navigation-link url="/profile">
-  Logged in as {{ user.name }}
-</navigation-link>
+<slot-example v-slot="slotProps">
+  {{ slotProps.msg }}
+</slot-example>
 ```
 
-That slot has access to the same instance properties (i.e. the same "scope") as the rest of the template. The slot does **not** have access to `<navigation-link>`'s scope. For example, trying to access `url` would not work. As a rule, remember that:
+### Slot Props Destructuring
 
-> Everything in the parent template is compiled in parent scope; everything in the child template is compiled in the child scope.
+The value of `v-slot` can actually accept any valid JavaScript expression that can appear in the argument position of a function definition. This means in supported environments ([single-file components](single-file-components.html) or [modern browsers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Browser_compatibility)) you can also use [ES2015 destructuring](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Object_destructuring) in the expression, like so:
 
-## Scoped Slots
+``` html
+<slot-example v-slot="{ msg }">
+  {{ msg }}
+</slot-example>
+```
+
+This can make the template much cleaner when the slot expects a lot of props.
+
+Conceptually, the syntax is similar to argument destructuring in JavaScript:
+
+``` js
+function CustomText({ text }) {
+  return text
+}
+```
 
-> New in 2.1.0+
+### Todo List Example
 
-Sometimes you'll want to provide a component with a reusable slot that can access data from the child component. For example, a simple `<todo-list>` component may contain the following in its template:
+**Slot props allow us to turn slots into reusable templates that can render different content based on input props.** This is most useful when you are designing a reusable component that encapsulates data logic while allowing the consuming parent component to customize part of its layout.
+
+For example, we are implementing a `<todo-list>` component that contains the layout and filtering logic for a list:
 
 ```html
 <ul>
   <li
-    v-for="todo in todos"
+    v-for="todo in filteredTodos"
     v-bind:key="todo.id"
   >
     {{ todo.text }}
@@ -177,19 +250,17 @@ Sometimes you'll want to provide a component with a reusable slot that can acces
 </ul>
 ```
 
-But in some parts of our app, we want the individual todo items to render something different than just the `todo.text`. This is where scoped slots come in.
-
-To make the feature possible, all we have to do is wrap the todo item content in a `<slot>` element, then pass the slot any data relevant to its context: in this case, the `todo` object:
+Instead of hard-coding how each todo looks like, we can let the parent component take control by making each todo a slot, and passing in the `todo` as a slot prop:
 
 ```html
 <ul>
   <li
-    v-for="todo in todos"
+    v-for="todo in filteredTodos"
     v-bind:key="todo.id"
   >
     <!-- We have a slot for each todo, passing it the -->
     <!-- `todo` object as a slot prop.                -->
-    <slot v-bind:todo="todo">
+    <slot name="todo" v-bind:todo="todo">
       <!-- Fallback content -->
       {{ todo.text }}
     </slot>
@@ -197,33 +268,135 @@ To make the feature possible, all we have to do is wrap the todo item content in
 </ul>
 ```
 
-Now when we use the `<todo-list>` component, we can optionally define an alternative `<template>` for todo items, but with access to data from the child via the `slot-scope` attribute:
+Now when we use the `<todo-list>` component, we can optionally define an alternative `<template>` for todo items, but with access to data from the child:
 
 ```html
 <todo-list v-bind:todos="todos">
-  <!-- Define `slotProps` as the name of our slot scope -->
-  <template slot-scope="slotProps">
-    <!-- Define a custom template for todo items, using -->
-    <!-- `slotProps` to customize each todo.            -->
-    <span v-if="slotProps.todo.isComplete">✓</span>
-    {{ slotProps.todo.text }}
+  <template v-slot:todo="{ todo }">
+    <span v-if="todo.isComplete">✓</span>
+    {{ todo.text }}
   </template>
 </todo-list>
 ```
 
-> In 2.5.0+, `slot-scope` is no longer limited to the `<template>` element, but can instead be used on any element or component in the slot.
+Admitted, the above example is still contrived. A more real-world use case would be a reusable list component that encapsulates the logic of fetching items from an API with infinite scroll, and lets the parent customize how each fetched item should be rendered:
 
-### Destructuring `slot-scope`
+``` html
+<infinite-scroll endpoint="/api/posts" :fetch-count="20">
+  <template v-slot:item="{ data }">
+    <div class="post">
+      <h2>{{ data.title }}</h2>
+      <p>by {{ data.author }} on {{ data.date }}</p>
+      <p>{{ data.content }}</p>
+    </div>
+  </template>
+</infinite-scroll>
+```
+
+## Legacy Syntax
+
+The `v-slot` directive was introduced in Vue 2.6.0, replacing the legacy `slot` + `slot-scope` syntax. The rationale for introducing the new syntax is described in this [RFC](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0001-new-slot-syntax.md). The legacy syntax is still supported in 2.6 and will continue to be supported in all future 2.x releases, but is marked for deprecation and will eventually be removed in a future major release.
+
+### Named Slots with `slot`
 
-The value of `slot-scope` can actually accept any valid JavaScript expression that can appear in the argument position of a function definition. This means in supported environments ([single-file components](single-file-components.html) or [modern browsers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Browser_compatibility)) you can also use [ES2015 destructuring](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Object_destructuring) in the expression, like so:
+To pass content to named slots from the parent, use the special `slot` attribute on `<template>` (Using the `<base-layout>` component described [here](#Named-Slots) as example):
+
+```html
+<base-layout>
+  <template slot="header">
+    <h1>Here might be a page title</h1>
+  </template>
+
+  <p>A paragraph for the main content.</p>
+  <p>And another one.</p>
+
+  <template slot="footer">
+    <p>Here's some contact info</p>
+  </template>
+</base-layout>
+```
+
+Or, the `slot` attribute can also be used directly on a normal element:
+
+``` html
+<base-layout>
+  <h1 slot="header">Here might be a page title</h1>
+
+  <p>A paragraph for the main content.</p>
+  <p>And another one.</p>
+
+  <p slot="footer">Here's some contact info</p>
+</base-layout>
+```
+
+There can still be one unnamed slot, which is the **default slot** that serves as a catch-all outlet for any unmatched content. In both examples above, the  rendered HTML would be:
+
+``` html
+<div class="container">
+  <header>
+    <h1>Here might be a page title</h1>
+  </header>
+  <main>
+    <p>A paragraph for the main content.</p>
+    <p>And another one.</p>
+  </main>
+  <footer>
+    <p>Here's some contact info</p>
+  </footer>
+</div>
+```
+
+### Scoped Slots with `slot-scope`
+
+To receive props passed to a slot, the parent component can use `<template>` with the `slot-scope` special attribute (Using the `<slot-example>` described [here](#Slot-Props) as example):
+
+``` html
+<slot-example>
+  <template slot="default" slot-scope="slotProps">
+    {{ slotProps.msg }}
+  </template>
+</slot-example>
+```
+
+Here `slot-scope` declares the received props object as the `slotProps` variable, and makes it available inside the `<template>` scope. You can name `slotProps` anything you like similar to naming function arguments in JavaScript.
+
+Here `slot="default"` can be omitted as it is implied:
+
+``` html
+<slot-example>
+  <template slot-scope="slotProps">
+    {{ slotProps.msg }}
+  </template>
+</slot-example>
+```
+
+`slot-scope` can also be used directly on a non `<template>` element (including components):
+
+``` html
+<slot-example>
+  <span slot-scope="slotProps">
+    {{ slotProps.msg }}
+  </span>
+</slot-example>
+```
+
+The value of `slot-scope` can accept any valid JavaScript expression that can appear in the argument position of a function definition. This means in supported environments ([single-file components](single-file-components.html) or [modern browsers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Browser_compatibility)) you can also use [ES2015 destructuring](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Object_destructuring) in the expression, like so:
+
+``` html
+<slot-example>
+  <span slot-scope="{ msg }">
+    {{ msg }}
+  </span>
+</slot-example>
+```
+
+Using the `<todo-list>` described [here](#Todo-List-Example) as example, here's the equivalent usage using `slot-scope`:
 
 ```html
 <todo-list v-bind:todos="todos">
-  <template slot-scope="{ todo }">
+  <template slot="todo" slot-scope="{ todo }">
     <span v-if="todo.isComplete">✓</span>
     {{ todo.text }}
   </template>
 </todo-list>
 ```
-
-This is a great way to make scoped slots a little cleaner.

From 825c21bfa20c361c66c1c0a167021d418d225059 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Tue, 29 Jan 2019 18:55:09 -0500
Subject: [PATCH 15/25] 2.6: v-slot api entry

---
 src/v2/api/index.md | 86 ++++++++++++++++++++++++++++-----------------
 1 file changed, 54 insertions(+), 32 deletions(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index 44989749e8..f5ab17db60 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -2213,6 +2213,26 @@ type: api
   - [Form Input Bindings](../guide/forms.html)
   - [Components - Form Input Components using Custom Events](../guide/components.html#Form-Input-Components-using-Custom-Events)
 
+### v-slot
+
+- **Shorthand:** `#`
+
+- **Expects:** JavaScript expression that is valid in a function argument position (supports destructuring in [supported environments](../guide/components-slots.html#Slot-Props-Destructuring)). Optional - only needed if expecting props to be passed to the slot.
+
+- **Argument:** `slot name (optional)`
+
+- **Limited to:**
+  - `<template>`
+  - components (when denoting default slot with props)
+
+- **Usage:**
+
+  Denote named slots or slots that expect to receive props. For detailed usage, see the links below.
+
+- **See also:**
+  - [Components - Slots](../guide/components-slots.html)
+  - [RFC-0001](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0001-new-slot-syntax.md)
+
 ### v-pre
 
 - **Does not expect expression**
@@ -2332,38 +2352,6 @@ type: api
 
 - **See also:** [Child Component Refs](../guide/components.html#Child-Component-Refs)
 
-### slot
-
-- **Expects:** `string`
-
-  Used on content inserted into child components to indicate which named slot the content belongs to.
-
-  For detailed usage, see the guide section linked below.
-
-- **See also:** [Named Slots](../guide/components.html#Named-Slots)
-
-### slot-scope
-
-> New in 2.5.0+
-
-- **Expects:** `function argument expression`
-
-- **Usage:**
-
-  Used to denote an element or component as a scoped slot. The attribute's value should be a valid JavaScript expression that can appear in the argument position of a function signature. This means in supported environments you can also use ES2015 destructuring in the expression. Serves as a replacement for [`scope`](#scope-replaced) in 2.5.0+.
-
-  This attribute does not support dynamic binding.
-
-- **See also:** [Scoped Slots](../guide/components.html#Scoped-Slots)
-
-### scope <sup>replaced</sup>
-
-Used to denote a `<template>` element as a scoped slot, which is replaced by [`slot-scope`](#slot-scope) in 2.5.0+.
-
-- **Usage:**
-
-  Same as [`slot-scope`](#slot-scope) except that `scope` can only be used on `<template>` elements.
-
 ### is
 
 - **Expects:** `string | Object (component’s options object)`
@@ -2389,6 +2377,40 @@ Used to denote a `<template>` element as a scoped slot, which is replaced by [`s
   - [Dynamic Components](../guide/components.html#Dynamic-Components)
   - [DOM Template Parsing Caveats](../guide/components.html#DOM-Template-Parsing-Caveats)
 
+### slot <sup>replaced</sup>
+
+**Replaced by [v-slot](#v-slot) since 2.6.0.**
+
+- **Expects:** `string`
+
+  Used on content inserted into child components to indicate which named slot the content belongs to.
+
+- **See also:** [Named Slots with `slot`](../guide/components.html#Named-Slots-with-slot)
+
+### slot-scope <sup>replaced</sup>
+
+**Replaced by [v-slot](#v-slot) since 2.6.0.**
+
+- **Expects:** `function argument expression`
+
+- **Usage:**
+
+  Used to denote an element or component as a scoped slot. The attribute's value should be a valid JavaScript expression that can appear in the argument position of a function signature. This means in supported environments you can also use ES2015 destructuring in the expression. Serves as a replacement for [`scope`](#scope-replaced) in 2.5.0+.
+
+  This attribute does not support dynamic binding.
+
+- **See also:** [Scoped Slots with `slot-scope`](../guide/components.html#Scoped-Slots-with-slot-scope)
+
+### scope <sup>replaced</sup>
+
+**Replaced by [slot-scope](#slot-scope) since 2.5.0.**
+
+Used to denote a `<template>` element as a scoped slot.
+
+- **Usage:**
+
+  Same as [`slot-scope`](#slot-scope) except that `scope` can only be used on `<template>` elements.
+
 ## Built-In Components
 
 ### component

From 3945e1d373cbc3b6cf0ea48dea5b6d7f74b2c006 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Fri, 1 Feb 2019 09:58:02 -0500
Subject: [PATCH 16/25] 2.6: improve v-slot api entry

---
 src/v2/api/index.md | 49 ++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 42 insertions(+), 7 deletions(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index db7f3ebc24..d6686c1d8a 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -2230,7 +2230,42 @@ type: api
 
 - **Usage:**
 
-  Denote named slots or slots that expect to receive props. For detailed usage, see the links below.
+  Denote named slots or slots that expect to receive props.
+
+- **Example:**
+
+  ```html
+  <!-- named slots -->
+  <base-layout>
+    <template v-slot:header>
+      Header content
+    </template>
+
+    <template v-slot:default>
+      Default slot content
+    </template>
+
+    <template v-slot:footer>
+      Footer content
+    </template>
+  </base-layout>
+
+  <!-- named slot that receive props -->
+  <infinite-scroll>
+    <template v-slot:item="slotProps">
+      <div class="item">
+        {{ slotProps.item.text }}
+      </div>
+    </template>
+  </infinite-scroll>
+
+  <!-- default slot that receive props, with props destructuring -->
+  <mouse-position v-slot="{ x, y }">
+    Mouse position: {{ x }}, {{ y }}
+  </mouse-position>
+  ```
+
+  For more details, see the links below.
 
 - **See also:**
   - [Components - Slots](../guide/components-slots.html)
@@ -2380,9 +2415,9 @@ type: api
   - [Dynamic Components](../guide/components.html#Dynamic-Components)
   - [DOM Template Parsing Caveats](../guide/components.html#DOM-Template-Parsing-Caveats)
 
-### slot <sup>replaced</sup>
+### slot <sup style="color:#c92222">Deprecated</sup>
 
-**Replaced by [v-slot](#v-slot) since 2.6.0.**
+**Prefer [v-slot](#v-slot) if you are using 2.6.0+.**
 
 - **Expects:** `string`
 
@@ -2390,9 +2425,9 @@ type: api
 
 - **See also:** [Named Slots with `slot`](../guide/components.html#Named-Slots-with-slot)
 
-### slot-scope <sup>replaced</sup>
+### slot-scope <sup style="color:#c92222">Deprecated</sup>
 
-**Replaced by [v-slot](#v-slot) since 2.6.0.**
+**Prefer [v-slot](#v-slot) if you are using 2.6.0+.**
 
 - **Expects:** `function argument expression`
 
@@ -2404,9 +2439,9 @@ type: api
 
 - **See also:** [Scoped Slots with `slot-scope`](../guide/components.html#Scoped-Slots-with-slot-scope)
 
-### scope <sup>replaced</sup>
+### scope <sup style="color:#c92222">Deprecated</sup>
 
-**Replaced by [slot-scope](#slot-scope) since 2.5.0.**
+**Replaced by [slot-scope](#slot-scope) since 2.5.0. Prefer [v-slot](#v-slot) if you are using 2.6.0+.**
 
 Used to denote a `<template>` element as a scoped slot.
 

From 07a9bd40f06f2d1811b4ec79fcd2c5ebf152d48a Mon Sep 17 00:00:00 2001
From: Chris Fritz <chrisvfritz@gmail.com>
Date: Fri, 1 Feb 2019 14:28:22 -0500
Subject: [PATCH 17/25] clarify behavior for Vue.observable

---
 src/v2/api/index.md | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index d6686c1d8a..74096f92a4 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -82,9 +82,9 @@ type: api
 
   > In 2.2.0+, this hook also captures errors in component lifecycle hooks. Also, when this hook is `undefined`, captured errors will be logged with `console.error` instead of crashing the app.
 
-  > In 2.4.0+ this hook also captures errors thrown inside Vue custom event handlers.
+  > In 2.4.0+, this hook also captures errors thrown inside Vue custom event handlers.
 
-  > In 2.6.0+ this hook also captures errors thrown inside `v-on` DOM listeners. In addition, if any of the covered hooks or handlers returns a Promise chain (e.g. async functions), the error from that Promise chain will also be handled.
+  > In 2.6.0+, this hook also captures errors thrown inside `v-on` DOM listeners. In addition, if any of the covered hooks or handlers returns a Promise chain (e.g. async functions), the error from that Promise chain will also be handled.
 
   > Error tracking services [Sentry](https://sentry.io/for/vue/) and [Bugsnag](https://docs.bugsnag.com/platforms/browsers/vue/) provide official integrations using this option.
 
@@ -404,31 +404,33 @@ type: api
 
 - **See also:** [Render Functions](../guide/render-function.html)
 
-### Vue.observable( value )
+### Vue.observable( object )
 
 > New in 2.6.0+
 
 - **Arguments:**
-  - `{Object} value`
+  - `{Object} object`
 
 - **Usage:**
 
-  Explicitly creates a reactive object. This is what Vue performs internally on objects returned from a component's `data()` function.
+  Make an object reactive. Internally, Vue uses this on the object returned by the `data` function.
 
-  The returned object can be used directly inside [render functions](../guide/render-function.html) and [computed properties](../guide/computed.html), and will trigger appropriate updates when mutated. It can be used as a minimal cross-component state store for simple scenarios.
+  The returned object can be used directly inside [render functions](../guide/render-function.html) and [computed properties](../guide/computed.html), and will trigger appropriate updates when mutated. It can also be used as a minimal, cross-component state store for simple scenarios:
 
   ``` js
-  const obj = Vue.observable({ count: 0 })
+  const state = Vue.observable({ count: 0 })
 
   const Demo = {
     render(h) {
       return h('button', {
-        on: { click: () => { obj.count++ }}
-      }, `count is: ${obj.count}`)
+        on: { click: () => { state.count++ }}
+      }, `count is: ${state.count}`)
     }
   }
   ```
 
+  <p class="tip">In Vue 2.x, `Vue.observable` directly mutates the object passed to it, so that it is equivalent to the object returned, as [demonstrated here](../guide/instance.html#Data-and-Methods). In Vue 3.x, a reactive proxy will be returned instead, leaving the original object non-reactive if mutated directly. Therefore, for future compatibility, we recommend always working with the object returned by `Vue.observable`, rather than the object originally passed to it.</p>
+
 - **See also:** [Reactivity in Depth](../guide/reactivity.html)
 
 ### Vue.version

From 0830fc3bca0758b860d3389ab340b6c7f37087d7 Mon Sep 17 00:00:00 2001
From: Chris Fritz <chrisvfritz@gmail.com>
Date: Fri, 1 Feb 2019 14:40:21 -0500
Subject: [PATCH 18/25] fix scopedSlots typos and add more info

---
 src/v2/api/index.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index 74096f92a4..f784357b3b 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -1434,9 +1434,9 @@ type: api
 
   **Note:** since 2.6.0+, there are two notable changes to this property:
 
-  1. Scoped slot functions now are guaranteed to return Array of VNodes, unless the return value is invalid, in which case the function will return `undefined`.
+  1. Scoped slot functions are now guaranteed to return an array of VNodes, unless the return value is invalid, in which case the function will return `undefined`.
 
-  2. All normal slots on `vm.$slots` are now also exposed on `vm.$scopeSlots` as functions. If you work with render functions, it is now recommended to always access all slots via `vm.$scopedSlots` for consistency.
+  2. All `$slots` are now also exposed on `$scopedSlots` as functions. If you work with render functions, it is now recommended to always access slots via `$scopedSlots`, whether they currently use a scope or not. This will not only make future refactors to add a scope simpler, but also ease your eventual migration to Vue 3, where all slots will be functions.
 
 - **See also:**
   - [`<slot>` Component](#slot-1)

From 55ef7e2593f2ae7ddfc8ca027defd58aa284fe2e Mon Sep 17 00:00:00 2001
From: Chris Fritz <chrisvfritz@gmail.com>
Date: Fri, 1 Feb 2019 15:42:57 -0500
Subject: [PATCH 19/25] small api tweaks/fixes

---
 src/v2/api/index.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index f784357b3b..637eb47344 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -2013,7 +2013,7 @@ type: api
   </div>
   ```
 
-  Since 2.6, `v-for` can also work on values that implement the [Iterable Protocol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol), including native `Map` and `Set`. However it should be noted that Vue 2.x currently does not support reactivity detection on `Map` and `Set` values.
+  In 2.6+, `v-for` can also work on values that implement the [Iterable Protocol](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol), including native `Map` and `Set`. However, it should be noted that Vue 2.x currently does not support reactivity on `Map` and `Set` values, so cannot automatically detect changes.
 
   <p class="tip">When used together with v-if, v-for has a higher priority than v-if. See the <a href="../guide/list.html#v-for-with-v-if">list rendering guide</a> for details.</p>
 
@@ -2169,7 +2169,7 @@ type: api
   <!-- DOM attribute binding with prop modifier -->
   <div v-bind:text-content.prop="text"></div>
 
-  <!-- shorthand for prop modifier (2.6.0+) -->
+  <!-- shorthand for DOM prop modifier (2.6.0+) -->
   <div .text-content="text"></div>
 
   <!-- prop binding. "prop" must be declared in my-component. -->

From 2908c49e975a26352efe9f5b081f06dfbf3b16b8 Mon Sep 17 00:00:00 2001
From: Chris Fritz <chrisvfritz@gmail.com>
Date: Fri, 1 Feb 2019 15:45:52 -0500
Subject: [PATCH 20/25] specify browser build is for using native es modules

---
 src/v2/guide/installation.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/v2/guide/installation.md b/src/v2/guide/installation.md
index 5d55a81379..765d2c89e0 100644
--- a/src/v2/guide/installation.md
+++ b/src/v2/guide/installation.md
@@ -46,7 +46,7 @@ For production, we recommend linking to a specific version number and build to a
 <script src="https://cdn.jsdelivr.net/npm/vue@2.6.0/dist/vue.js"></script>
 ```
 
-If you are using ES Modules, there is also an ES Modules compatible build:
+If you are using native ES Modules, there is also an ES Modules compatible build:
 
 ``` html
 <script type="module">

From 8c762d93a318ff5ce5c4863d1d5da0cd306f30f6 Mon Sep 17 00:00:00 2001
From: Chris Fritz <chrisvfritz@gmail.com>
Date: Fri, 1 Feb 2019 16:36:51 -0500
Subject: [PATCH 21/25] syntax guide tweaks for v2.6

---
 src/v2/guide/syntax.md | 35 +++++++++++++++++++----------------
 1 file changed, 19 insertions(+), 16 deletions(-)

diff --git a/src/v2/guide/syntax.md b/src/v2/guide/syntax.md
index 030afcb4c2..3a59643ac9 100644
--- a/src/v2/guide/syntax.md
+++ b/src/v2/guide/syntax.md
@@ -46,9 +46,9 @@ The double mustaches interprets the data as plain text, not HTML. In order to ou
 new Vue({
   el: '#example1',
   data: function () {
-  	return {
-  	  rawHtml: '<span style="color: red">This should be red.</span>'
-  	}
+    return {
+      rawHtml: '<span style="color: red">This should be red.</span>'
+    }
   }
 })
 </script>
@@ -130,37 +130,40 @@ Here the argument is the event name to listen to. We will talk about event handl
 
 ### Dynamic Arguments
 
-> New in 2.6
+> New in 2.6.0+
 
-Starting in 2.6, it is also possible to use JavaScript expressions in an directive argument by wrapping it with square brackets:
+Starting in version 2.6.0, it is also possible to use a JavaScript expression in a directive argument by wrapping it with square brackets:
 
 ``` html
-<a v-bind:[key]="url"> ... </a>
+<a v-bind:[attributeName]="url"> ... </a>
 ```
 
-Here `key` will be dynamically evaluated as a JavaScript expression, and its evaluated value will be used as the final value for the argument. For example, if your Vue instance has a data property `key` whose value is `"href"`, then this binding will be equivalent to `v-bind:href`.
+Here `attributeName` will be dynamically evaluated as a JavaScript expression, and its evaluated value will be used as the final value for the argument. For example, if your Vue instance has a data property, `attributeName`, whose value is `"href"`, then this binding will be equivalent to `v-bind:href`.
 
-Similarly, you can use dynamic arguments to bind a handler to a dynamic event:
+Similarly, you can use dynamic arguments to bind a handler to a dynamic event name:
 
 ``` html
-<a v-on:[event]="doSomething"> ... </a>
+<a v-on:[eventName]="doSomething"> ... </a>
 ```
 
+Similarly, when `eventName`'s value is `"focus"`, for example, `v-on:[eventName]` will be equivalent to `v-on:focus`.
+
 #### Dynamic Argument Value Constraints
 
-Dynamic argument values are expected to be strings, with the exception of `null`. The special value `null` can be used to explicitly remove the binding. Any other non-string value will trigger a warning.
+Dynamic arguments are expected to evaluate to a string, with the exception of `null`. The special value `null` can be used to explicitly remove the binding. Any other non-string value will trigger a warning.
 
 #### Dynamic Argument Expression Constraints
 
-<p class="tip">Dynamic argument expressions have some syntax constraints because certain characters are invalid inside HTML attribute names, in particular spaces and quotes.</p>
+<p class="tip">Dynamic argument expressions have some syntax constraints because certain characters are invalid inside HTML attribute names, such as spaces and quotes.</p>
 
 For example, the following is invalid:
 
 ``` html
+<!-- This will trigger a compiler warning. -->
 <a v-bind:['foo' + bar]="value"> ... </a>
 ```
 
-The Vue template compiler will warn against such usage. The workaround is to either use expressions without spaces or quotes, or use a computed property instead.
+The workaround is to either use expressions without spaces or quotes, or replace the complex expression with a computed property.
 
 ### Modifiers
 
@@ -174,7 +177,7 @@ You'll see other examples of modifiers later, [for `v-on`](events.html#Event-Mod
 
 ## Shorthands
 
-The `v-` prefix serves as a visual cue for identifying Vue-specific attributes in your templates. This is useful when you are using Vue.js to apply dynamic behavior to some existing markup, but can feel verbose for some frequently used directives. At the same time, the need for the `v-` prefix becomes less important when you are building a [SPA](https://en.wikipedia.org/wiki/Single-page_application) where Vue.js manages every template. Therefore, Vue.js provides special shorthands for two of the most often used directives, `v-bind` and `v-on`:
+The `v-` prefix serves as a visual cue for identifying Vue-specific attributes in your templates. This is useful when you are using Vue.js to apply dynamic behavior to some existing markup, but can feel verbose for some frequently used directives. At the same time, the need for the `v-` prefix becomes less important when you are building a [SPA](https://en.wikipedia.org/wiki/Single-page_application), where Vue manages every template. Therefore, Vue provides special shorthands for two of the most often used directives, `v-bind` and `v-on`:
 
 ### `v-bind` Shorthand
 
@@ -189,9 +192,9 @@ The `v-` prefix serves as a visual cue for identifying Vue-specific attributes i
 <a :[key]="url"> ... </a>
 ```
 
-> DOM Property Shorthand
+#### DOM Property Shorthand
 
-In 2.6 a separate shorthand for explicit DOM property bindings (with the `.prop` modifier) have been introduced:
+In 2.6.0+, a separate shorthand for explicit DOM property bindings (with the `.prop` modifier) have been introduced:
 
 ``` html
 <!-- full syntax -->
@@ -214,4 +217,4 @@ In 2.6 a separate shorthand for explicit DOM property bindings (with the `.prop`
 <a @[event]="doSomething"> ... </a>
 ```
 
-They may look a bit different from normal HTML, but `:` and `@` are valid chars for attribute names and all Vue.js supported browsers can parse it correctly. In addition, they do not appear in the final rendered markup. The shorthand syntax is totally optional, but you will likely appreciate it when you learn more about its usage later.
+They may look a bit different from normal HTML, but `:` and `@` are valid characters for attribute names and all Vue-supported browsers can parse it correctly. In addition, they do not appear in the final rendered markup. The shorthand syntax is totally optional, but you will likely appreciate it when you learn more about its usage later.

From 985c4b7d26c9b829143310a8c41863c5ebf25c53 Mon Sep 17 00:00:00 2001
From: Chris Fritz <chrisvfritz@gmail.com>
Date: Fri, 1 Feb 2019 16:48:22 -0500
Subject: [PATCH 22/25] tweaks to v-slot docs

---
 src/v2/api/index.md              |  26 ++-
 src/v2/guide/components-slots.md | 304 ++++++++++++++++++++++---------
 2 files changed, 230 insertions(+), 100 deletions(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index 637eb47344..5343413e01 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -2224,11 +2224,11 @@ type: api
 
 - **Expects:** JavaScript expression that is valid in a function argument position (supports destructuring in [supported environments](../guide/components-slots.html#Slot-Props-Destructuring)). Optional - only needed if expecting props to be passed to the slot.
 
-- **Argument:** `slot name (optional)`
+- **Argument:** slot name (optional, defaults to `default`)
 
 - **Limited to:**
   - `<template>`
-  - components (when denoting default slot with props)
+  - [components](../guide/components-slots.html#Abbreviated-Syntax-for-Lone-Default-Slots) (for a lone default slot with props)
 
 - **Usage:**
 
@@ -2237,22 +2237,20 @@ type: api
 - **Example:**
 
   ```html
-  <!-- named slots -->
+  <!-- Named slots -->
   <base-layout>
     <template v-slot:header>
       Header content
     </template>
 
-    <template v-slot:default>
-      Default slot content
-    </template>
+    Default slot content
 
     <template v-slot:footer>
       Footer content
     </template>
   </base-layout>
 
-  <!-- named slot that receive props -->
+  <!-- Named slot that receives props -->
   <infinite-scroll>
     <template v-slot:item="slotProps">
       <div class="item">
@@ -2261,7 +2259,7 @@ type: api
     </template>
   </infinite-scroll>
 
-  <!-- default slot that receive props, with props destructuring -->
+  <!-- Default slot that receive props, with destructuring -->
   <mouse-position v-slot="{ x, y }">
     Mouse position: {{ x }}, {{ y }}
   </mouse-position>
@@ -2417,9 +2415,9 @@ type: api
   - [Dynamic Components](../guide/components.html#Dynamic-Components)
   - [DOM Template Parsing Caveats](../guide/components.html#DOM-Template-Parsing-Caveats)
 
-### slot <sup style="color:#c92222">Deprecated</sup>
+### slot <sup style="color:#c92222">deprecated</sup>
 
-**Prefer [v-slot](#v-slot) if you are using 2.6.0+.**
+**Prefer [v-slot](#v-slot) in 2.6.0+.**
 
 - **Expects:** `string`
 
@@ -2427,9 +2425,9 @@ type: api
 
 - **See also:** [Named Slots with `slot`](../guide/components.html#Named-Slots-with-slot)
 
-### slot-scope <sup style="color:#c92222">Deprecated</sup>
+### slot-scope <sup style="color:#c92222">deprecated</sup>
 
-**Prefer [v-slot](#v-slot) if you are using 2.6.0+.**
+**Prefer [v-slot](#v-slot) in 2.6.0+.**
 
 - **Expects:** `function argument expression`
 
@@ -2441,9 +2439,9 @@ type: api
 
 - **See also:** [Scoped Slots with `slot-scope`](../guide/components.html#Scoped-Slots-with-slot-scope)
 
-### scope <sup style="color:#c92222">Deprecated</sup>
+### scope <sup style="color:#c92222">deprecated</sup>
 
-**Replaced by [slot-scope](#slot-scope) since 2.5.0. Prefer [v-slot](#v-slot) if you are using 2.6.0+.**
+**Replaced by [slot-scope](#slot-scope) in 2.5.0+. Prefer [v-slot](#v-slot) in 2.6.0+.**
 
 Used to denote a `<template>` element as a scoped slot.
 
diff --git a/src/v2/guide/components-slots.md b/src/v2/guide/components-slots.md
index a6dd7ec745..daf3f6c6c4 100644
--- a/src/v2/guide/components-slots.md
+++ b/src/v2/guide/components-slots.md
@@ -6,7 +6,7 @@ order: 104
 
 > This page assumes you've already read the [Components Basics](components.html). Read that first if you are new to components.
 
-> In 2.6.0, we introduced a new unified syntax (the `v-slot` directive) for named slots and scoped slots. It replaces the `slot` and `slot-scope` syntax which is still documented [here](#Legacy-Syntax). The rationale for introducing the new syntax is described in this [RFC](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0001-new-slot-syntax.md).
+> In 2.6.0, we introduced a new unified syntax (the `v-slot` directive) for named and scoped slots. It replaces the `slot` and `slot-scope` attributes, which are now deprecated, but have _not_ been removed and are still documented [here](#Deprecated-Syntax). The rationale for introducing the new syntax is described in this [RFC](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0001-new-slot-syntax.md).
 
 ## Slot Content
 
@@ -31,7 +31,7 @@ Then in the template for `<navigation-link>`, you might have:
 </a>
 ```
 
-When the component renders, the `<slot>` element will be replaced by "Your Profile". Slots can contain any template code, including HTML:
+When the component renders, `<slot></slot>` will be replaced by "Your Profile". Slots can contain any template code, including HTML:
 
 ``` html
 <navigation-link url="/profile">
@@ -51,7 +51,7 @@ Or even other components:
 </navigation-link>
 ```
 
-If `<navigation-link>` did **not** contain a `<slot>` element, any content passed to it would simply be discarded.
+If `<navigation-link>`'s template did **not** contain a `<slot>` element, any content provided between its opening and closing tag would be discarded.
 
 ## Compilation Scope
 
@@ -63,15 +63,34 @@ When you want to use data inside a slot, such as in:
 </navigation-link>
 ```
 
-That slot has access to the same instance properties (i.e. the same "scope") as the rest of the template. The slot does **not** have access to `<navigation-link>`'s scope. For example, trying to access `url` would not work. As a rule, remember that:
+That slot has access to the same instance properties (i.e. the same "scope") as the rest of the template. The slot does **not** have access to `<navigation-link>`'s scope. For example, trying to access `url` would not work:
+
+``` html
+<navigation-link url="/profile">
+  Clicking here will send you to: {{ url }}
+  <!--
+  The `url` will be undefined, because this content is passed
+  _to_ <navigation-link>, rather than defined _inside_ the
+  <navigation-link> component.
+  -->
+</navigation-link>
+```
+
+As a rule, remember that:
 
 > Everything in the parent template is compiled in parent scope; everything in the child template is compiled in the child scope.
 
 ## Fallback Content
 
-There are cases when it's useful to provide a slot with fallback content, which is rendered when the parent did not provide content for the slot. For example, a `<submit-button>` component might want the content of the button to be "Submit" by default, but also allow users to override with "Save", "Upload", or anything else.
+There are cases when it's useful to specify fallback (i.e. default) content for a slot, to be be rendered only when no content is provided. For example, in a `<submit-button>` component:
 
-To achieve this, specify the fallback content in between the `<slot>` tags in your component's template:
+```html
+<button type="submit">
+  <slot></slot>
+</button>
+```
+
+We might want the text "Submit" to be rendered inside the `<button>` most of the time. To make "Submit" the fallback content, we can place it in between the `<slot>` tags:
 
 ```html
 <button type="submit">
@@ -79,11 +98,41 @@ To achieve this, specify the fallback content in between the `<slot>` tags in yo
 </button>
 ```
 
-The fallback content "Submit" only gets rendered if the parent did not provide any slot content.
+Now when we use `<submit-button>` in a parent component, providing no content for the slot:
+
+```html
+<submit-button></submit-button>
+```
+
+will render the fallback content, "Submit":
+
+```html
+<button type="submit">
+  Submit
+</button>
+```
+
+But if we provide content:
+
+```html
+<submit-button>
+  Save
+</submit-button>
+```
+
+Then the provided content will be rendered instead:
+
+```html
+<button type="submit">
+  Save
+</button>
+```
 
 ## Named Slots
 
-There are times when it's useful to have multiple slots. For example, in a hypothetical `base-layout` component with the following template:
+> Updated in 2.6.0+. [See here](#Deprecated-Syntax) for the deprecated syntax using the `slot` attribute.
+
+There are times when it's useful to have multiple slots. For example, in a `<base-layout>` component with the following template:
 
 ``` html
 <div class="container">
@@ -117,7 +166,7 @@ For these cases, the `<slot>` element has a special attribute, `name`, which can
 
 A `<slot>` outlet without `name` implicitly has the name "default".
 
-To provide content to named slots, we can use the `v-slot` directive on a `<template>` element in the parent, using the directive argument to indicate which named slot the content is being passed to:
+To provide content to named slots, we can use the `v-slot` directive on a `<template>`, providing the name of the slot as `v-slot`'s argument:
 
 ```html
 <base-layout>
@@ -125,10 +174,8 @@ To provide content to named slots, we can use the `v-slot` directive on a `<temp
     <h1>Here might be a page title</h1>
   </template>
 
-  <template v-slot:default>
-    <p>A paragraph for the main content.</p>
-    <p>And another one.</p>
-  </template>
+  <p>A paragraph for the main content.</p>
+  <p>And another one.</p>
 
   <template v-slot:footer>
     <p>Here's some contact info</p>
@@ -136,104 +183,195 @@ To provide content to named slots, we can use the `v-slot` directive on a `<temp
 </base-layout>
 ```
 
-Note that unlike the legacy `slot` attribute, `v-slot` must appear on a `<template>` wrapper when being used to denote named slots. The only exception is when used directly on a component tag to denote a [default slot with props](#Default-Slot-with-Props).
-
-### Named Slots Shorthand
+Now everything inside the `<template>` elements will be passed to the corresponding slots. Any content not wrapped in a `<template>` using `v-slot` is assumed to be for the default slot.
 
-Similar to `v-on` and `v-bind`, `v-slot` also has a shorthand, replacing everything before the argument with the special symbol `#`. The above example can also be written as:
+However, you can still wrap default slot content in a `<template>` if you wish to be explicit:
 
 ```html
 <base-layout>
-  <template #header>
+  <template v-slot:header>
     <h1>Here might be a page title</h1>
   </template>
 
-  <template #default>
+  <template v-slot:default>
     <p>A paragraph for the main content.</p>
     <p>And another one.</p>
   </template>
 
-  <template #footer>
+  <template v-slot:footer>
     <p>Here's some contact info</p>
   </template>
 </base-layout>
 ```
 
-### Dynamic Slot Names
-
-Dynamic directive arguments also work on `v-slot`:
+Either way, the rendered HTML will be:
 
 ``` html
-<base-layout>
-  <template v-slot:[dynamicSlotName]>
-    ...
-  </template>
+<div class="container">
+  <header>
+    <h1>Here might be a page title</h1>
+  </header>
+  <main>
+    <p>A paragraph for the main content.</p>
+    <p>And another one.</p>
+  </main>
+  <footer>
+    <p>Here's some contact info</p>
+  </footer>
+</div>
+```
 
-  <!-- shorthand equivalent -->
-  <template #[anotherSlotName]>
-    ...
-  </template>
-</base-layout>
+Note that **`v-slot` can only be added to a `<template>`** (with [one exception](#Abbreviated-Syntax-for-Lone-Default-Slots)), unlike the deprecated [`slot` attribute](#Deprecated-Syntax).
+
+## Scoped Slots
+
+> Updated in 2.6.0+. [See here](#Deprecated-Syntax) for the deprecated syntax using the `slot-props` attribute.
+
+Sometimes, it's useful for slot content to have access to data only available in the child component. For example, imagine a `<current-user>` component with the following template:
+
+```html
+<span>
+  <slot>{{ user.lastName }}</slot>
+</span>
 ```
 
-## Slot Props
+We might want to replace this fallback content to display the user's first name, instead of last, like this:
 
-So far we have seen that the slot feature allows a child component to compose content passed from the parent with its own template. However, in some cases the child component may wish to customize the slot content based on its own data, which the parent has no access to. It would be great if the child can pass props to `<slot>` outlets. Imagine we have a `<slot-example>` component with the following template:
+``` html
+<current-user>
+  {{ user.firstName }}
+</current-user>
+```
+
+That won't work, however, because only the `<current-user>` component has access to the `user` and the content we're providing is rendered in the parent.
+
+To make `user` available to the slot content in the parent, we can bind `user` as an attribute to the `<slot>` element:
 
 ``` html
-<!-- slot-example -->
 <span>
-  <slot v-bind:msg="myMessage"></slot>
+  <slot v-bind:user="user">
+    {{ user.lastName }}
+  </slot>
 </span>
 ```
 
-In order to receive and make use of the props being passed to a slot, the parent component declares the props received using the attribute value of the `v-slot` directive:
+Attributes bound to a `<slot>` element are called **slot props**. Now, in the parent scope, we can use `v-slot` with a value to define a name for the slot props we've been provided:
 
 ``` html
-<slot-example>
+<current-user>
   <template v-slot:default="slotProps">
-    {{ slotProps.msg }}
+    {{ slotProps.user.firstName }}
   </template>
-</slot-example>
+</current-user>
 ```
 
-Here you can name `slotProps` anything you like, just like declaring a function argument in JavaScript. The declared variable will become available inside the scope of the slot's `<template>`.
+In this example, we've chosen to name the object containing all our slot props `slotProps`, but you can use any name you like.
 
-Slots that expect props are also known as "scoped slots", as they create a "scope" within which the received props can be used.
+### Abbreviated Syntax for Lone Default Slots
 
-<p class="tip">The `v-slot` syntax is introduced in 2.6.0 and is not supported in older versions. The legacy `slot` and `slot-scope` syntax is still supported in 2.6, and is documented [here](#Legacy-Syntax).</p>
+In cases like above, when _only_ the default slot is provided content, the component's tags can be used as the slot's template. This allows us to use `v-slot` directly on the component:
 
-### Default Slot with Props
+``` html
+<current-user v-slot:default="slotProps">
+  {{ slotProps.user.firstName }}
+</current-user>
+```
 
-When there is only the default slot, the `v-slot` directive can be placed directly on the component itself, and the `default` argument can also be omitted. The above example can thus be simplified to:
+This can be shortened even further. Just as non-specified content is assumed to be for the default slot, `v-slot` without an argument is assumed to refer to the default slot:
 
 ``` html
-<slot-example v-slot="slotProps">
-  {{ slotProps.msg }}
-</slot-example>
+<current-user v-slot="slotProps">
+  {{ slotProps.user.firstName }}
+</current-user>
 ```
 
-### Slot Props Destructuring
+### Destructuring Slot Props
+
+Internally, scoped slots work by wrapping your slot content in a function passed a single argument:
+
+```js
+function (slotProps) {
+  // ... slot content ...
+}
+```
 
-The value of `v-slot` can actually accept any valid JavaScript expression that can appear in the argument position of a function definition. This means in supported environments ([single-file components](single-file-components.html) or [modern browsers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Browser_compatibility)) you can also use [ES2015 destructuring](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Object_destructuring) in the expression, like so:
+That means the value of `v-slot` can actually accept any valid JavaScript expression that can appear in the argument position of a function definition. So in supported environments ([single-file components](single-file-components.html) or [modern browsers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Browser_compatibility)), you can also use [ES2015 destructuring](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Object_destructuring) to pull out specific slot props, like so:
 
 ``` html
-<slot-example v-slot="{ msg }">
-  {{ msg }}
-</slot-example>
+<current-user v-slot="{ user }">
+  {{ user.firstName }}
+</current-user>
 ```
 
-This can make the template much cleaner when the slot expects a lot of props.
+This can make the template much cleaner, especially when the slot provides many props. It also opens other possibilities, such as renaming props, e.g. `user` to `person`:
 
-Conceptually, the syntax is similar to argument destructuring in JavaScript:
+``` html
+<current-user v-slot="{ user: person }">>
+  {{ person.firstName }}
+</current-user>
+```
 
-``` js
-function CustomText({ text }) {
-  return text
-}
+You can even define fallbacks, to be used in case a slot prop is undefined:
+
+``` html
+<current-user v-slot="{ user = { firstName: 'Guest' } }">>
+  {{ user.firstName }}
+</current-user>
 ```
 
-### Todo List Example
+## Dynamic Slot Names
+
+> New in 2.6.0+
+
+[Dynamic directive arguments](http://localhost:4000/v2/guide/syntax.html#Dynamic-Arguments) also work on `v-slot`, allowing the definition of dynamic slot names:
+
+``` html
+<base-layout>
+  <template v-slot:[dynamicSlotName]>
+    ...
+  </template>
+</base-layout>
+```
+
+## Named Slots Shorthand
+
+> New in 2.6.0+
+
+Similar to `v-on` and `v-bind`, `v-slot` also has a shorthand, replacing everything before the argument (`v-slot:`) with the special symbol `#`. For example, `v-slot:header` and be rewritten as `#header`:
+
+```html
+<base-layout>
+  <template #header>
+    <h1>Here might be a page title</h1>
+  </template>
+
+  <p>A paragraph for the main content.</p>
+  <p>And another one.</p>
+
+  <template #footer>
+    <p>Here's some contact info</p>
+  </template>
+</base-layout>
+```
+
+However, just as with other directives, the shorthand is only available when an argument is provided. That means the following syntax is invalid:
+
+``` html
+<!-- This will trigger a warning -->
+<current-user #="{ user }">
+  {{ user.firstName }}
+</current-user>
+```
+
+Instead, you must always specify the name of the slot if you wish to use the shorthand:
+
+``` html
+<current-user #default="{ user }">
+  {{ user.firstName }}
+</current-user>
+```
+
+## Other Examples
 
 **Slot props allow us to turn slots into reusable templates that can render different content based on input props.** This is most useful when you are designing a reusable component that encapsulates data logic while allowing the consuming parent component to customize part of its layout.
 
@@ -250,7 +388,7 @@ For example, we are implementing a `<todo-list>` component that contains the lay
 </ul>
 ```
 
-Instead of hard-coding how each todo looks like, we can let the parent component take control by making each todo a slot, and passing in the `todo` as a slot prop:
+Instead of hard-coding the content for each todo, we can let the parent component take control by making every todo a slot, then binding `todo` as a slot prop:
 
 ```html
 <ul>
@@ -258,8 +396,10 @@ Instead of hard-coding how each todo looks like, we can let the parent component
     v-for="todo in filteredTodos"
     v-bind:key="todo.id"
   >
-    <!-- We have a slot for each todo, passing it the -->
-    <!-- `todo` object as a slot prop.                -->
+    <!--
+    We have a slot for each todo, passing it the
+    `todo` object as a slot prop.
+    -->
     <slot name="todo" v-bind:todo="todo">
       <!-- Fallback content -->
       {{ todo.text }}
@@ -279,27 +419,17 @@ Now when we use the `<todo-list>` component, we can optionally define an alterna
 </todo-list>
 ```
 
-Admitted, the above example is still contrived. A more real-world use case would be a reusable list component that encapsulates the logic of fetching items from an API with infinite scroll, and lets the parent customize how each fetched item should be rendered:
+However, even this barely scratches the surface of what scoped slots are capable of. For real-life, powerful examples of scoped slot usage, we recommend browsing libraries such as [Vue Virtual Scroller](https://github.com/Akryum/vue-virtual-scroller), [Vue Promised](https://github.com/posva/vue-promised), and [Portal Vue](https://github.com/LinusBorg/portal-vue).
 
-``` html
-<infinite-scroll endpoint="/api/posts" :fetch-count="20">
-  <template v-slot:item="{ data }">
-    <div class="post">
-      <h2>{{ data.title }}</h2>
-      <p>by {{ data.author }} on {{ data.date }}</p>
-      <p>{{ data.content }}</p>
-    </div>
-  </template>
-</infinite-scroll>
-```
+## Deprecated Syntax
 
-## Legacy Syntax
+> The `v-slot` directive was introduced in Vue 2.6.0, offering an improved, alternative API to the still-supported `slot` and `slot-scope` attributes. The full rationale for introducing `v-slot` is described in this [RFC](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0001-new-slot-syntax.md). The `slot` and `slot-scope` attributes will continue to be supported in all future 2.x releases, but are officially deprecated and will eventually be removed in Vue 3.
 
-The `v-slot` directive was introduced in Vue 2.6.0, replacing the legacy `slot` + `slot-scope` syntax. The rationale for introducing the new syntax is described in this [RFC](https://github.com/vuejs/rfcs/blob/master/active-rfcs/0001-new-slot-syntax.md). The legacy syntax is still supported in 2.6 and will continue to be supported in all future 2.x releases, but is marked for deprecation and will eventually be removed in a future major release.
+### Named Slots with the `slot` Attribute
 
-### Named Slots with `slot`
+> <abbr title="Still supported in all 2.x versions of Vue, but no longer recommended.">Deprecated</abbr> in 2.6.0+. See [here](#Named-Slots) for the new, recommended syntax.
 
-To pass content to named slots from the parent, use the special `slot` attribute on `<template>` (Using the `<base-layout>` component described [here](#Named-Slots) as example):
+To pass content to named slots from the parent, use the special `slot` attribute on `<template>` (using the `<base-layout>` component described [here](#Named-Slots) as example):
 
 ```html
 <base-layout>
@@ -329,7 +459,7 @@ Or, the `slot` attribute can also be used directly on a normal element:
 </base-layout>
 ```
 
-There can still be one unnamed slot, which is the **default slot** that serves as a catch-all outlet for any unmatched content. In both examples above, the  rendered HTML would be:
+There can still be one unnamed slot, which is the **default slot** that serves as a catch-all for any unmatched content. In both examples above, the rendered HTML would be:
 
 ``` html
 <div class="container">
@@ -346,9 +476,11 @@ There can still be one unnamed slot, which is the **default slot** that serves a
 </div>
 ```
 
-### Scoped Slots with `slot-scope`
+### Scoped Slots with the `slot-scope` Attribute
+
+> <abbr title="Still supported in all 2.x versions of Vue, but no longer recommended.">Deprecated</abbr> in 2.6.0+. See [here](#Scoped-Slots) for the new, recommended syntax.
 
-To receive props passed to a slot, the parent component can use `<template>` with the `slot-scope` special attribute (Using the `<slot-example>` described [here](#Slot-Props) as example):
+To receive props passed to a slot, the parent component can use `<template>` with the `slot-scope` attribute (using the `<slot-example>` described [here](#Scoped-Slots) as example):
 
 ``` html
 <slot-example>
@@ -358,7 +490,7 @@ To receive props passed to a slot, the parent component can use `<template>` wit
 </slot-example>
 ```
 
-Here `slot-scope` declares the received props object as the `slotProps` variable, and makes it available inside the `<template>` scope. You can name `slotProps` anything you like similar to naming function arguments in JavaScript.
+Here, `slot-scope` declares the received props object as the `slotProps` variable, and makes it available inside the `<template>` scope. You can name `slotProps` anything you like similar to naming function arguments in JavaScript.
 
 Here `slot="default"` can be omitted as it is implied:
 
@@ -370,7 +502,7 @@ Here `slot="default"` can be omitted as it is implied:
 </slot-example>
 ```
 
-`slot-scope` can also be used directly on a non `<template>` element (including components):
+The `slot-scope` attribute can also be used directly on a non-`<template>` element (including components):
 
 ``` html
 <slot-example>
@@ -390,9 +522,9 @@ The value of `slot-scope` can accept any valid JavaScript expression that can ap
 </slot-example>
 ```
 
-Using the `<todo-list>` described [here](#Todo-List-Example) as example, here's the equivalent usage using `slot-scope`:
+Using the `<todo-list>` described [here](#Other-Examples) as an example, here's the equivalent usage using `slot-scope`:
 
-```html
+``` html
 <todo-list v-bind:todos="todos">
   <template slot="todo" slot-scope="{ todo }">
     <span v-if="todo.isComplete">✓</span>

From 77674dd3daab9bd1a85d2dcc6c8a4e13105546a0 Mon Sep 17 00:00:00 2001
From: Chris Fritz <chrisvfritz@gmail.com>
Date: Fri, 1 Feb 2019 16:50:03 -0500
Subject: [PATCH 23/25] mark scope as removed instead of replaced in api

---
 src/v2/api/index.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index 5343413e01..453ad6b6db 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -2439,7 +2439,7 @@ type: api
 
 - **See also:** [Scoped Slots with `slot-scope`](../guide/components.html#Scoped-Slots-with-slot-scope)
 
-### scope <sup style="color:#c92222">deprecated</sup>
+### scope <sup style="color:#c92222">removed</sup>
 
 **Replaced by [slot-scope](#slot-scope) in 2.5.0+. Prefer [v-slot](#v-slot) in 2.6.0+.**
 

From 845fff2929075b94a837a7d37b3b542fa1015fa7 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sat, 2 Feb 2019 10:52:29 -0500
Subject: [PATCH 24/25] Revert "2.6: document shorthand for v-bind .prop
 modifier"

This reverts commit f639b8310d33142f3710075db89799f429bae969.
---
 src/v2/api/index.md    |  3 ---
 src/v2/guide/syntax.md | 12 ------------
 2 files changed, 15 deletions(-)

diff --git a/src/v2/api/index.md b/src/v2/api/index.md
index 453ad6b6db..292b598393 100644
--- a/src/v2/api/index.md
+++ b/src/v2/api/index.md
@@ -2169,9 +2169,6 @@ type: api
   <!-- DOM attribute binding with prop modifier -->
   <div v-bind:text-content.prop="text"></div>
 
-  <!-- shorthand for DOM prop modifier (2.6.0+) -->
-  <div .text-content="text"></div>
-
   <!-- prop binding. "prop" must be declared in my-component. -->
   <my-component :prop="someThing"></my-component>
 
diff --git a/src/v2/guide/syntax.md b/src/v2/guide/syntax.md
index 3a59643ac9..a0693af2c2 100644
--- a/src/v2/guide/syntax.md
+++ b/src/v2/guide/syntax.md
@@ -192,18 +192,6 @@ The `v-` prefix serves as a visual cue for identifying Vue-specific attributes i
 <a :[key]="url"> ... </a>
 ```
 
-#### DOM Property Shorthand
-
-In 2.6.0+, a separate shorthand for explicit DOM property bindings (with the `.prop` modifier) have been introduced:
-
-``` html
-<!-- full syntax -->
-<video v-bind:muted.prop="isMuted"> ... </video>
-
-<!-- shorthand -->
-<video .muted="isMuted"> ... </video>
-```
-
 ### `v-on` Shorthand
 
 ``` html

From f39e3e016a08e51e21995c78447e13af3fe0aba3 Mon Sep 17 00:00:00 2001
From: Evan You <yyx990803@gmail.com>
Date: Sat, 2 Feb 2019 11:04:52 -0500
Subject: [PATCH 25/25] 2.6: add clarification about mixing abbreviated default
 slot w/ named slots

---
 src/v2/guide/components-slots.md | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/src/v2/guide/components-slots.md b/src/v2/guide/components-slots.md
index daf3f6c6c4..cf851aa561 100644
--- a/src/v2/guide/components-slots.md
+++ b/src/v2/guide/components-slots.md
@@ -285,6 +285,32 @@ This can be shortened even further. Just as non-specified content is assumed to
 </current-user>
 ```
 
+Note that the abbreviated syntax for default slot **cannot** be mixed with named slots, as it would lead to scope ambiguity:
+
+``` html
+<!-- INVALID, will result in warning -->
+<current-user v-slot="slotProps">
+  {{ slotProps.user.firstName }}
+  <template v-slot:other="otherSlotProps">
+    slotProps is NOT available here
+  </template>
+</current-user>
+```
+
+Whenever there are multiple slots, use the full `<template>` based syntax for _all_ slots:
+
+``` html
+<current-user>
+  <template v-slot:default="slotProps">
+    {{ slotProps.user.firstName }}
+  </template>
+
+  <template v-slot:other="otherSlotProps">
+    ...
+  </template>
+</current-user>
+```
+
 ### Destructuring Slot Props
 
 Internally, scoped slots work by wrapping your slot content in a function passed a single argument: