1
2
3
4
5
6

export const transformElement: NodeTransform = (node, context) => {
    return function postTransformElement() {
        // ...
        // 主函数，返回一个闭包函数
    }
}

1

  const isProp = findProp(node, 'is')

1
2
3
4
5
6
7
8

const exp =
        isProp.type === NodeTypes.ATTRIBUTE
          ? isProp.value && createSimpleExpression(isProp.value.content, true)
          : isProp.exp
if (exp) {
	return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT),			[ exp ]
	)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

 if (
      isProp.type === NodeTypes.ATTRIBUTE &&
      isProp.value!.content.startsWith('vue:')
    ) {
      // <button is="vue:xxx">
      // if not <component>, only is value that starts with "vue:" will be
      // treated as component by the parse phase and reach here, unless it's
      // compat mode where all is values are considered components
      tag = isProp.value!.content.slice(4)
}

1

const isDir = !isExplicitDynamic && findDir(node, 'is')

1
2
3
4
5

if (isDir && isDir.exp) {
    return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
      isDir.exp
    ])
  }

1

 const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag)

1
2
3
4
5
6

if (builtIn) {
    // built-ins are simply fallthroughs / have special handling during ssr
    // so we don't need to import their runtime equivalents
    if (!ssr) context.helper(builtIn)
    return builtIn
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

const fromSetup = resolveSetupReference(tag, context)
if (fromSetup) {
  return fromSetup
}
const dotIndex = tag.indexOf('.')
if (dotIndex > 0) {
  const ns = resolveSetupReference(tag.slice(0, dotIndex), context)
  if (ns) {
    return ns + tag.slice(dotIndex)
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

 if (
    !__BROWSER__ &&
    context.selfName &&
    capitalize(camelize(tag)) === context.selfName
  ) {
    context.helper(RESOLVE_COMPONENT)
    // codegen.ts has special check for __self postfix when generating
    // component imports, which will pass additional `maybeSelfReference` flag
    // to `resolveComponent`.
    context.components.add(tag + `__self`)
    return toValidAssetId(tag, `component`)
  }

1
2
3

  context.helper(RESOLVE_COMPONENT)
  context.components.add(tag)
  return toValidAssetId(tag, `component`)

1
2
3
4
5

for (let i = 0; i < props.length; i++) {
    // static attribute
    const prop = props[i]
    // ...
}

1
2
3

let isStatic = true
if (name === 'ref') {
hasRef = true

1
2
3
4
5
6
7
8

if (context.scopes.vFor > 0) {
          properties.push(
            createObjectProperty(
              createSimpleExpression('ref_for', true),
              createSimpleExpression('true')
            )
          )
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

if (
        name === 'is' &&
        (isComponentTag(tag) ||
          (value && value.content.startsWith('vue:')) ||
          (__COMPAT__ &&
            isCompatEnabled(
              CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT,
              context
            )))
      ) {
        continue
      }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

properties.push(
    createObjectProperty(
      createSimpleExpression(
        name,
        true,
        getInnerRange(loc, 0, name.length)
      ),
      createSimpleExpression(
        value ? value.content : '',
        isStatic,
        value ? value.loc : loc
      )
    )
 )

1
2
3

const { name, arg, exp, loc } = prop
const isVBind = name === 'bind'
const isVOn = name === 'on'

1
2
3
4
5
6
7
8

      if (name === 'slot') {
        if (!isComponent) {
          context.onError(
            createCompilerError(ErrorCodes.X_V_SLOT_MISPLACED, loc)
          )
        }
        continue
      }

1
2
3

if (name === 'once' || name === 'memo') {
        continue
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

if (
        name === 'is' ||
        (isVBind &&
          isStaticArgOf(arg, 'is') &&
          (isComponentTag(tag) ||
            (__COMPAT__ &&
              isCompatEnabled(
                CompilerDeprecationTypes.COMPILER_IS_ON_ELEMENT,
                context
              ))))
) {
        continue
}

1
2
3
4
5
6
7
8
9

if (
        // #938: elements with dynamic keys should be forced into blocks
        (isVBind && isStaticArgOf(arg, 'key')) ||
        // inline before-update hooks need to force block so that it is invoked
        // before children
        (isVOn && hasChildren && isStaticArgOf(arg, 'vue:before-update'))
      ) {
        shouldUseBlock = true
      }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

hasDynamicKeys = true
if (exp) {
  if (isVBind) {
    // have to merge early for compat build check
    pushMergeArg()

    mergeArgs.push(exp)
  } else {
    // v-on="obj" -> toHandlers(obj)
    pushMergeArg({
      type: NodeTypes.JS_CALL_EXPRESSION,
      loc,
      callee: context.helper(TO_HANDLERS),
      arguments: isComponent ? [exp] : [exp, `true`]
    })
  }
} 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

const directiveTransform = context.directiveTransforms[name]
if (directiveTransform) {
        // has built-in directive transform.
        const { props, needRuntime } = directiveTransform(prop, node, context)
        !ssr && props.forEach(analyzePatchFlag)
        if (isVOn && arg && !isStaticExp(arg)) {
          pushMergeArg(createObjectExpression(props, elementLoc))
        } else {
          properties.push(...props)
        }
        if (needRuntime) {
          runtimeDirectives.push(prop)
          if (isSymbol(needRuntime)) {
            directiveImportMap.set(prop, needRuntime)
          }
        }
      } else if (!isBuiltInDirective(name)) {
        // no built-in transform, this is a user custom directive.
        runtimeDirectives.push(prop)
        // custom dirs may use beforeUpdate so they need to force blocks
        // to ensure before-update gets called before children update
        if (hasChildren) {
          shouldUseBlock = true
        }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// has v-bind="object" or v-on="object", wrap with mergeProps
  if (mergeArgs.length) {
    // close up any not-yet-merged props
    pushMergeArg()
    if (mergeArgs.length > 1) {
      propsExpression = createCallExpression(
        context.helper(MERGE_PROPS),
        mergeArgs,
        elementLoc
      )
    } else {
      // single v-bind with nothing else - no need for a mergeProps call
      propsExpression = mergeArgs[0]
    }
  } else if (properties.length) {
    propsExpression = createObjectExpression(
      dedupeProperties(properties),
      elementLoc
    )
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

  // patchFlag analysis
  if (hasDynamicKeys) {
    patchFlag |= PatchFlags.FULL_PROPS
  } else {
    if (hasClassBinding && !isComponent) {
      patchFlag |= PatchFlags.CLASS
    }
    if (hasStyleBinding && !isComponent) {
      patchFlag |= PatchFlags.STYLE
    }
    if (dynamicPropNames.length) {
      patchFlag |= PatchFlags.PROPS
    }
    if (hasHydrationEventBinding) {
      patchFlag |= PatchFlags.HYDRATE_EVENTS
    }
  }
  if (
    !shouldUseBlock &&
    (patchFlag === 0 || patchFlag === PatchFlags.HYDRATE_EVENTS) &&
    (hasRef || hasVnodeHook || runtimeDirectives.length > 0)
  ) {
    patchFlag |= PatchFlags.NEED_PATCH
  }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

switch (propsExpression.type) {
  case NodeTypes.JS_OBJECT_EXPRESSION:
    // means that there is no v-bind,
    // but still need to deal with dynamic key binding
    let classKeyIndex = -1
    let styleKeyIndex = -1
    let hasDynamicKey = false

    for (let i = 0; i < propsExpression.properties.length; i++) {
      const key = propsExpression.properties[i].key
      if (isStaticExp(key)) {
        if (key.content === 'class') {
          classKeyIndex = i
        } else if (key.content === 'style') {
          styleKeyIndex = i
        }
      } else if (!key.isHandlerKey) {
        hasDynamicKey = true
      }
    }

    const classProp = propsExpression.properties[classKeyIndex]
    const styleProp = propsExpression.properties[styleKeyIndex]

    // no dynamic key
    if (!hasDynamicKey) {
      if (classProp && !isStaticExp(classProp.value)) {
        classProp.value = createCallExpression(
          context.helper(NORMALIZE_CLASS),
          [classProp.value]
        )
      }
      if (
        styleProp &&
        // the static style is compiled into an object,
        // so use `hasStyleBinding` to ensure that it is a dynamic style binding
        (hasStyleBinding ||
          (styleProp.value.type === NodeTypes.SIMPLE_EXPRESSION &&
            styleProp.value.content.trim()[0] === `[`) ||
          // v-bind:style and style both exist,
          // v-bind:style with static literal object
          styleProp.value.type === NodeTypes.JS_ARRAY_EXPRESSION)
      ) {
        styleProp.value = createCallExpression(
          context.helper(NORMALIZE_STYLE),
          [styleProp.value]
        )
      }
    } else {
      // dynamic key binding, wrap with `normalizeProps`
      propsExpression = createCallExpression(
        context.helper(NORMALIZE_PROPS),
        [propsExpression]
      )
    }
    break
  case NodeTypes.JS_CALL_EXPRESSION:
    // mergeProps call, do nothing
    break
  default:
    // single v-bind
    propsExpression = createCallExpression(
      context.helper(NORMALIZE_PROPS),
      [
        createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [
          propsExpression
        ])
      ]
    )
    break
}