progress

Author: yyx990803

Diff for: flow/compiler.js

@@ -132,6 +132,10 @@ declare type ASTElement = {
   onceProcessed?: boolean;
   wrapData?: (code: string) => string;
 
+  // 2.4 ssr optimization
+  ssrOptimizable?: boolean;
+  ssrOptimizableRoot?: boolean;
+
   // weex specific
   appendAsTree?: boolean;
 }
@@ -141,12 +145,18 @@ declare type ASTExpression = {
   expression: string;
   text: string;
   static?: boolean;
+  // 2.4 ssr optimization
+  ssrOptimizable?: boolean;
+  ssrOptimizableRoot?: boolean;
 }
 
 declare type ASTText = {
   type: 3;
   text: string;
   static?: boolean;
+  // 2.4 ssr optimization
+  ssrOptimizable?: boolean;
+  ssrOptimizableRoot?: boolean;
 }
 
 // SFC-parser related declarations

Diff for: src/compiler/codegen/index.js

@@ -9,7 +9,7 @@ type TransformFunction = (el: ASTElement, code: string) => string;
 type DataGenFunction = (el: ASTElement) => string;
 type DirectiveFunction = (el: ASTElement, dir: ASTDirective, warn: Function) => boolean;
 
-class CodegenState {
+export class CodegenState {
   options: CompilerOptions;
   warn: Function;
   transforms: Array<TransformFunction>;
@@ -19,7 +19,7 @@ class CodegenState {
   onceId: number;
   staticRenderFns: Array<string>;
 
-  constructor (options = {}) {
+  constructor (options: CompilerOptions) {
     this.options = options
     this.warn = options.warn || baseWarn
     this.transforms = pluckModuleFunction(options.modules, 'transformCode')
@@ -32,13 +32,15 @@ class CodegenState {
   }
 }
 
+type CodegenResult = {
+  render: string,
+  staticRenderFns: Array<string>
+};
+
 export function generate (
   ast: ASTElement | void,
   options: CompilerOptions
-): {
-  render: string,
-  staticRenderFns: Array<string>
-} {
+): CodegenResult {
   const state = new CodegenState(options)
   const code = ast ? genElement(ast, state) : '_c("div")'
   return {

Diff for: src/server/optimizing-compiler/codegen.js

@@ -0,0 +1,36 @@
+/* @flow */
+
+// import * as directives from './directives'
+import { CodegenState } from 'compiler/codegen/index'
+
+type SSRCompileResult = {
+  render: string;
+  staticRenderFns: Array<string>;
+  stringRenderFns: Array<string>;
+};
+
+class SSRCodegenState extends CodegenState {
+  stringRenderFns: Array<string>;
+
+  constructor (options: CompilerOptions) {
+    super(options)
+    this.stringRenderFns = []
+  }
+}
+
+export function generate (
+  ast: ASTElement | void,
+  options: CompilerOptions
+): SSRCompileResult {
+  const state = new SSRCodegenState(options)
+  const code = ast ? genElement(ast, state) : '_c("div")'
+  return {
+    render: `with(this){return ${code}}`,
+    staticRenderFns: state.staticRenderFns,
+    stringRenderFns: state.stringRenderFns
+  }
+}
+
+function genElement (el: ASTElement, state: SSRCodegenState): string {
+
+}

Diff for: src/server/optimizing-compiler/directives.js

@@ -0,0 +1,64 @@
+/* @flow */
+
+import { extend } from 'shared/util'
+import { parse } from 'compiler/parser/index'
+import { detectErrors } from 'compiler/error-detector'
+
+import { generate } from './codegen'
+import { optimize } from './optimizer'
+
+function baseCompile (
+  template: string,
+  options: CompilerOptions
+): CompiledResult {
+  const ast = parse(template.trim(), options)
+  optimize(ast, options)
+  const code = generate(ast, options)
+  return {
+    ast,
+    render: code.render,
+    staticRenderFns: code.staticRenderFns
+  }
+}
+
+export function createCompiler (baseOptions: CompilerOptions) {
+  return function compile (
+    template: string,
+    options?: CompilerOptions
+  ): CompiledResult {
+    const finalOptions = Object.create(baseOptions)
+    const errors = []
+    const tips = []
+    finalOptions.warn = (msg, tip) => {
+      (tip ? tips : errors).push(msg)
+    }
+
+    if (options) {
+      // merge custom modules
+      if (options.modules) {
+        finalOptions.modules = (baseOptions.modules || []).concat(options.modules)
+      }
+      // merge custom directives
+      if (options.directives) {
+        finalOptions.directives = extend(
+          Object.create(baseOptions.directives),
+          options.directives
+        )
+      }
+      // copy other options
+      for (const key in options) {
+        if (key !== 'modules' && key !== 'directives') {
+          finalOptions[key] = options[key]
+        }
+      }
+    }
+
+    const compiled = baseCompile(template, finalOptions)
+    if (process.env.NODE_ENV !== 'production') {
+      errors.push.apply(errors, detectErrors(compiled.ast))
+    }
+    compiled.errors = errors
+    compiled.tips = tips
+    return compiled
+  }
+}

Diff for: src/server/optimizing-compiler/index.js

@@ -0,0 +1,85 @@
+/* @flow */
+
+import { no, isBuiltInTag } from 'shared/util'
+
+let isPlatformReservedTag
+
+/**
+ * In SSR, the vdom tree is generated only once and never patched, so
+ * we can optimize most element / trees into plain string render functions.
+ * The SSR optimizer walks the AST tree to detect optimizable elements and trees.
+ *
+ * The criteria for SSR optimizability is quite a bit looser than static tree
+ * detection (which is designed for client re-render). In SSR we bail only for
+ * components/slots/custom directives.
+ */
+export function optimize (root: ?ASTElement, options: CompilerOptions) {
+  if (!root) return
+  isPlatformReservedTag = options.isReservedTag || no
+  // first pass: mark all non-optimizable nodes.
+  markNonOptimizable(root)
+  // second pass: mark optimizable trees.
+  markOptimizableTrees(root, false)
+}
+
+function markNonOptimizable (node: ASTNode) {
+  node.ssrOptimizable = isOptimizable(node)
+  if (node.type === 1) {
+    // do not make component slot content optimizable so that render fns can
+    // still manipulate the nodes.
+    if (
+      !isPlatformReservedTag(node.tag) &&
+      node.tag !== 'slot' &&
+      node.attrsMap['inline-template'] == null
+    ) {
+      return
+    }
+    for (let i = 0, l = node.children.length; i < l; i++) {
+      const child = node.children[i]
+      markNonOptimizable(child)
+      if (!child.ssrOptimizable) {
+        node.ssrOptimizable = false
+      }
+    }
+    if (node.ifConditions) {
+      for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+        const block = node.ifConditions[i].block
+        markNonOptimizable(block)
+        if (!block.ssrOptimizable) {
+          node.ssrOptimizable = false
+        }
+      }
+    }
+  }
+}
+
+function isOptimizable (node: ASTNode): boolean {
+  if (node.type === 2 || node.type === 3) { // text or expression
+    return true
+  }
+  return (
+    !isBuiltInTag(node.tag) && // not a built-in (slot, component)
+    !!isPlatformReservedTag(node.tag) // not a component
+  )
+}
+
+function markOptimizableTrees (node: ASTNode) {
+  if (node.type === 1) {
+    if (node.ssrOptimizable) {
+      node.ssrOptimizableRoot = true
+      return
+    } else {
+      node.ssrOptimizableRoot = false
+    }
+    if (node.children) {
+      for (let i = 0, l = node.children.length; i < l; i++) {
+        markOptimizableTrees(node.children[i])
+      }
+    }
+    if (node.ifConditions) {
+      for (let i = 1, l = node.ifConditions.length; i < l; i++) {
+        markOptimizableTrees(node.ifConditions[i].block)
+      }
+    }
+  }
+}