remove <render> tag

flow/compiler.js

@@ -84,10 +84,6 @@ declare type ASTElement = {
   ref?: string,
   refInFor?: boolean,
 
-  render?: true,
-  renderMethod?: ?string,
-  renderArgs?: ?string,
-
   if?: string,
   ifProcessed?: boolean,
   else?: true,

src/compiler/codegen.js

@@ -45,8 +45,6 @@ function genElement (el: ASTElement): string {
     return genIf(el)
   } else if (el.tag === 'template' && !el.slotTarget) {
     return genChildren(el) || 'void 0'
-  } else if (el.tag === 'render') {
-    return genRender(el)
   } else if (el.tag === 'slot') {
     return genSlot(el)
   } else {
@@ -245,18 +243,6 @@ function genText (text: ASTText | ASTExpression): string {
     : '_t(' + JSON.stringify(text.text) + ')'
 }
 
-function genRender (el: ASTElement): string {
-  if (!el.renderMethod) {
-    return 'void 0'
-  }
-  const children = genChildren(el)
-  return `${el.renderMethod}(${
-    el.renderArgs || ''
-  }${
-    children ? (el.renderArgs ? ',' : '') + children : ''
-  })`
-}
-
 function genSlot (el: ASTElement): string {
   const slot = `$slots[${el.slotName || '"default"'}]`
   const children = genChildren(el)

src/compiler/parser/index.js

@@ -123,7 +123,6 @@ export function parse (
         // determine whether this is a plain element after
         // removing if/for/once attributes
         element.plain = !element.key && !attrs.length
-        processRender(element)
         processSlot(element)
         processComponent(element)
         for (let i = 0; i < transforms.length; i++) {
@@ -145,8 +144,8 @@ export function parse (
           }
           if (element.attrsMap.hasOwnProperty('v-for')) {
             warn(
-              'Cannot use v-for on component root element because it renders ' +
-              'multiple elements:\n' + template
+              'Cannot use v-for on stateful component root element because ' +
+              'it renders multiple elements:\n' + template
             )
           }
         }
@@ -306,24 +305,6 @@ function processOnce (el) {
   }
 }
 
-function processRender (el) {
-  if (el.tag === 'render') {
-    el.render = true
-    el.renderMethod = el.attrsMap[':method'] || el.attrsMap['v-bind:method']
-    el.renderArgs = el.attrsMap[':args'] || el.attrsMap['v-bind:args']
-    if (process.env.NODE_ENV !== 'production') {
-      if (el.attrsMap.method) {
-        warn('<render> method should use a dynamic binding, e.g. `:method="..."`.')
-      } else if (!el.renderMethod) {
-        warn('method attribute is required on <render>.')
-      }
-      if (el.attrsMap.args) {
-        warn('<render> args should use a dynamic binding, e.g. `:args="..."`.')
-      }
-    }
-  }
-}
-
 function processSlot (el) {
   if (el.tag === 'slot') {
     el.slotName = getBindingAttr(el, 'name')

test/unit/modules/compiler/codegen.spec.js

@@ -113,28 +113,6 @@ describe('codegen', () => {
     )
   })
 
-  it('generate render tag', () => {
-    assertCodegen(
-      '<render :method="onRender" :args="params"></render>',
-      `with(this){return onRender(params)}`
-    )
-  })
-
-  it('generate render tag that have children', () => {
-    assertCodegen(
-      '<render :method="onRender"><p>hello</p></render>',
-      `with(this){return onRender([_m(0)])}`,
-      [`with(this){return _h(_e('p'),[_t("hello")])}`]
-    )
-  })
-
-  it('generate render tag with `method` is not dynamic binding', () => {
-    assertCodegen(
-      '<render method="onRender"></render>',
-      `with(this){return void 0}`
-    )
-  })
-
   it('generate single slot', () => {
     assertCodegen(
       '<slot></slot>',

test/unit/modules/compiler/parser.spec.js

@@ -89,7 +89,7 @@ describe('parser', () => {
 
   it('warn v-for on root element', () => {
     parse('<div v-for="item in items"></div>', baseOptions)
-    expect('Cannot use v-for on component root element').toHaveBeenWarned()
+    expect('Cannot use v-for on stateful component root element').toHaveBeenWarned()
   })
 
   it('v-pre directive', () => {
@@ -162,28 +162,6 @@ describe('parser', () => {
     expect(ast.once).toBe(true)
   })
 
-  it('render tag syntax', () => {
-    const ast = parse('<render :method="onRender", :args="params"></render>', baseOptions)
-    expect(ast.render).toBe(true)
-    expect(ast.renderMethod).toBe('onRender')
-    expect(ast.renderArgs).toBe('params')
-  })
-
-  it('render tag invalid syntax', () => {
-    // method nothing
-    const invalidAst1 = parse('<render></render>', baseOptions)
-    expect('method attribute is required on <render>.').toHaveBeenWarned()
-    expect(invalidAst1.render).toBe(true)
-    expect(invalidAst1.renderMethod).toBeUndefined()
-    expect(invalidAst1.renderArgs).toBeUndefined()
-    // method no dynamic binding
-    parse('<render method="onRender"></render>', baseOptions)
-    expect('<render> method should use a dynamic binding').toHaveBeenWarned()
-    // args no dynamic binding
-    parse('<render :method="onRender" args="params"></render>', baseOptions)
-    expect('<render> args should use a dynamic binding').toHaveBeenWarned()
-  })
-
   it('slot tag single syntax', () => {
     const ast = parse('<slot></slot>', baseOptions)
     expect(ast.tag).toBe('slot')