theluyuan/vue3-yuanma
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

feat(compiler): basic transform implementation

Browse Source
This commit is contained in:
Evan You 2019-09-17 19:08:47 -04:00
parent a5c1b3283d
commit bbb57c26a2
11 changed files with 1889 additions and 1500 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2351
packages/compiler-core/__tests__/__snapshots__/parse.spec.ts.snap
View File

File diff suppressed because it is too large Load Diff

421
packages/compiler-core/__tests__/parse.spec.ts
View File

File diff suppressed because it is too large Load Diff

51
packages/compiler-core/src/ast.ts
View File

@ -8,20 +8,23 @@ export const enum Namespaces {
}
export const enum NodeTypes {
ROOT,
ELEMENT,
TEXT,
COMMENT,
ELEMENT,
ATTRIBUTE,
EXPRESSION,
ATTRIBUTE,
DIRECTIVE,
ROOT
IF,
IF_BRANCH,
FOR
}
export const enum ElementTypes {
ELEMENT,
COMPONENT,
SLOT, // slot
TEMPLATE // template, component
SLOT,
TEMPLATE
}
export interface Node {
@ -29,9 +32,18 @@ export interface Node {
loc: SourceLocation
}
export type ParentNode = RootNode | ElementNode | IfBranchNode | ForNode
export type ChildNode =
| ElementNode
| ExpressionNode
| TextNode
| CommentNode
| IfNode
| ForNode
export interface RootNode extends Node {
type: NodeTypes.ROOT
children: Array<ElementNode | ExpressionNode | TextNode | CommentNode>
children: ChildNode[]
}
export interface ElementNode extends Node {
@ -40,8 +52,9 @@ export interface ElementNode extends Node {
tag: string
tagType: ElementTypes
isSelfClosing: boolean
props: Array<AttributeNode | DirectiveNode>
children: Array<ElementNode | ExpressionNode | TextNode | CommentNode>
attrs: AttributeNode[]
directives: DirectiveNode[]
children: ChildNode[]
}
export interface TextNode extends Node {
@ -75,8 +88,28 @@ export interface ExpressionNode extends Node {
isStatic: boolean
}
export interface IfNode extends Node {
type: NodeTypes.IF
branches: IfBranchNode[]
}
export interface IfBranchNode extends Node {
type: NodeTypes.IF_BRANCH
condition: ExpressionNode | undefined // else
children: ChildNode[]
}
export interface ForNode extends Node {
type: NodeTypes.FOR
source: ExpressionNode
valueAlias: ExpressionNode
keyAlias: ExpressionNode
objectIndexAlias: ExpressionNode
children: ChildNode[]
}
export interface Position {
offset: number // from start of file
offset: number // from start of file (in SFCs)
line: number
column: number
}

57
packages/compiler-core/src/directives/vIf.ts
View File

@ -1 +1,56 @@
// TODO
import { createDirectiveTransform } from '../transform'
import {
NodeTypes,
ElementTypes,
ElementNode,
DirectiveNode,
IfBranchNode
} from '../ast'
import { createCompilerError, ErrorCodes } from '../errors'
export const transformIf = createDirectiveTransform(
/^(if|else|else-if)$/,
(node, dir, context) => {
if (dir.name === 'if') {
context.replaceNode({
type: NodeTypes.IF,
loc: node.loc,
branches: [createIfBranch(node, dir)]
})
} else {
// locate the adjacent v-if
const siblings = context.parent.children
let i = context.childIndex
while (i--) {
const sibling = siblings[i]
if (sibling.type === NodeTypes.COMMENT) {
continue
}
if (sibling.type === NodeTypes.IF) {
// move the node to the if node's branches
context.removeNode()
sibling.branches.push(createIfBranch(node, dir))
} else {
context.onError(
createCompilerError(
dir.name === 'else'
? ErrorCodes.X_ELSE_NO_ADJACENT_IF
: ErrorCodes.X_ELSE_IF_NO_ADJACENT_IF,
node.loc.start
)
)
}
break
}
}
}
)
function createIfBranch(node: ElementNode, dir: DirectiveNode): IfBranchNode {
return {
type: NodeTypes.IF_BRANCH,
loc: node.loc,
condition: dir.name === 'else' ? undefined : dir.exp,
children: node.tagType === ElementTypes.TEMPLATE ? node.children : [node]
}
}

89
packages/compiler-core/src/errorTypes.ts
View File

@ -1,89 +0,0 @@
export const enum ParserErrorTypes {
ABRUPT_CLOSING_OF_EMPTY_COMMENT,
ABSENCE_OF_DIGITS_IN_NUMERIC_CHARACTER_REFERENCE,
CDATA_IN_HTML_CONTENT,
CHARACTER_REFERENCE_OUTSIDE_UNICODE_RANGE,
CONTROL_CHARACTER_REFERENCE,
DUPLICATE_ATTRIBUTE,
END_TAG_WITH_ATTRIBUTES,
END_TAG_WITH_TRAILING_SOLIDUS,
EOF_BEFORE_TAG_NAME,
EOF_IN_CDATA,
EOF_IN_COMMENT,
EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT,
EOF_IN_TAG,
INCORRECTLY_CLOSED_COMMENT,
INCORRECTLY_OPENED_COMMENT,
INVALID_FIRST_CHARACTER_OF_TAG_NAME,
MISSING_ATTRIBUTE_VALUE,
MISSING_END_TAG_NAME,
MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE,
MISSING_WHITESPACE_BETWEEN_ATTRIBUTES,
NESTED_COMMENT,
NONCHARACTER_CHARACTER_REFERENCE,
NULL_CHARACTER_REFERENCE,
SURROGATE_CHARACTER_REFERENCE,
UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME,
UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE,
UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME,
UNEXPECTED_NULL_CHARACTER,
UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME,
UNEXPECTED_SOLIDUS_IN_TAG,
UNKNOWN_NAMED_CHARACTER_REFERENCE,
X_INVALID_END_TAG,
X_MISSING_END_TAG,
X_MISSING_INTERPOLATION_END,
X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END
}
export const errorMessages: { [code: number]: string } = {
[ParserErrorTypes.ABRUPT_CLOSING_OF_EMPTY_COMMENT]: 'Illegal comment.',
[ParserErrorTypes.ABSENCE_OF_DIGITS_IN_NUMERIC_CHARACTER_REFERENCE]:
'Illegal numeric character reference: invalid character.',
[ParserErrorTypes.CDATA_IN_HTML_CONTENT]:
'CDATA section is allowed only in XML context.',
[ParserErrorTypes.CHARACTER_REFERENCE_OUTSIDE_UNICODE_RANGE]:
'Illegal numeric character reference: too big.',
[ParserErrorTypes.CONTROL_CHARACTER_REFERENCE]:
'Illegal numeric character reference: control character.',
[ParserErrorTypes.DUPLICATE_ATTRIBUTE]: 'Duplicate attribute.',
[ParserErrorTypes.END_TAG_WITH_ATTRIBUTES]: 'End tag cannot have attributes.',
[ParserErrorTypes.END_TAG_WITH_TRAILING_SOLIDUS]: "Illegal '/' in tags.",
[ParserErrorTypes.EOF_BEFORE_TAG_NAME]: 'Unexpected EOF in tag.',
[ParserErrorTypes.EOF_IN_CDATA]: 'Unexpected EOF in CDATA section.',
[ParserErrorTypes.EOF_IN_COMMENT]: 'Unexpected EOF in comment.',
[ParserErrorTypes.EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT]:
'Unexpected EOF in script.',
[ParserErrorTypes.EOF_IN_TAG]: 'Unexpected EOF in tag.',
[ParserErrorTypes.INCORRECTLY_CLOSED_COMMENT]: 'Incorrectly closed comment.',
[ParserErrorTypes.INCORRECTLY_OPENED_COMMENT]: 'Incorrectly opened comment.',
[ParserErrorTypes.INVALID_FIRST_CHARACTER_OF_TAG_NAME]:
"Illegal tag name. Use '&lt;' to print '<'.",
[ParserErrorTypes.MISSING_ATTRIBUTE_VALUE]: 'Attribute value was expected.',
[ParserErrorTypes.MISSING_END_TAG_NAME]: 'End tag name was expected.',
[ParserErrorTypes.MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE]:
'Semicolon was expected.',
[ParserErrorTypes.MISSING_WHITESPACE_BETWEEN_ATTRIBUTES]:
'Whitespace was expected.',
[ParserErrorTypes.NESTED_COMMENT]: "Unexpected '<!--' in comment.",
[ParserErrorTypes.NONCHARACTER_CHARACTER_REFERENCE]:
'Illegal numeric character reference: non character.',
[ParserErrorTypes.NULL_CHARACTER_REFERENCE]:
'Illegal numeric character reference: null character.',
[ParserErrorTypes.SURROGATE_CHARACTER_REFERENCE]:
'Illegal numeric character reference: non-pair surrogate.',
[ParserErrorTypes.UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME]:
'Attribute name cannot contain U+0022 ("), U+0027 (\'), and U+003C (<).',
[ParserErrorTypes.UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE]:
'Unquoted attribute value cannot contain U+0022 ("), U+0027 (\'), U+003C (<), U+003D (=), and U+0060 (`).',
[ParserErrorTypes.UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME]:
"Attribute name cannot start with '='.",
[ParserErrorTypes.UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME]:
"'<?' is allowed only in XML context.",
[ParserErrorTypes.UNEXPECTED_SOLIDUS_IN_TAG]: "Illegal '/' in tags.",
[ParserErrorTypes.UNKNOWN_NAMED_CHARACTER_REFERENCE]: 'Unknown entity name.',
[ParserErrorTypes.X_INVALID_END_TAG]: 'Invalid end tag.',
[ParserErrorTypes.X_MISSING_END_TAG]: 'End tag was not found.',
[ParserErrorTypes.X_MISSING_INTERPOLATION_END]:
'Interpolation end sign was not found.'
}

120
packages/compiler-core/src/errors.ts Normal file
View File

@ -0,0 +1,120 @@
import { Position } from './ast'
export interface CompilerError extends SyntaxError {
code: ErrorCodes
loc: Position
}
export function createCompilerError(
code: ErrorCodes,
loc: Position
): CompilerError {
const error = new SyntaxError(
`${__DEV__ || !__BROWSER__ ? errorMessages[code] : code} (${loc.line}:${
loc.column
})`
) as CompilerError
error.code = code
error.loc = loc
return error
}
export const enum ErrorCodes {
// parse errors
ABRUPT_CLOSING_OF_EMPTY_COMMENT,
ABSENCE_OF_DIGITS_IN_NUMERIC_CHARACTER_REFERENCE,
CDATA_IN_HTML_CONTENT,
CHARACTER_REFERENCE_OUTSIDE_UNICODE_RANGE,
CONTROL_CHARACTER_REFERENCE,
DUPLICATE_ATTRIBUTE,
END_TAG_WITH_ATTRIBUTES,
END_TAG_WITH_TRAILING_SOLIDUS,
EOF_BEFORE_TAG_NAME,
EOF_IN_CDATA,
EOF_IN_COMMENT,
EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT,
EOF_IN_TAG,
INCORRECTLY_CLOSED_COMMENT,
INCORRECTLY_OPENED_COMMENT,
INVALID_FIRST_CHARACTER_OF_TAG_NAME,
MISSING_ATTRIBUTE_VALUE,
MISSING_END_TAG_NAME,
MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE,
MISSING_WHITESPACE_BETWEEN_ATTRIBUTES,
NESTED_COMMENT,
NONCHARACTER_CHARACTER_REFERENCE,
NULL_CHARACTER_REFERENCE,
SURROGATE_CHARACTER_REFERENCE,
UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME,
UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE,
UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME,
UNEXPECTED_NULL_CHARACTER,
UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME,
UNEXPECTED_SOLIDUS_IN_TAG,
UNKNOWN_NAMED_CHARACTER_REFERENCE,
X_INVALID_END_TAG,
X_MISSING_END_TAG,
X_MISSING_INTERPOLATION_END,
X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END,
// transform errors
X_ELSE_IF_NO_ADJACENT_IF,
X_ELSE_NO_ADJACENT_IF
}
export const errorMessages: { [code: number]: string } = {
// parse errors
[ErrorCodes.ABRUPT_CLOSING_OF_EMPTY_COMMENT]: 'Illegal comment.',
[ErrorCodes.ABSENCE_OF_DIGITS_IN_NUMERIC_CHARACTER_REFERENCE]:
'Illegal numeric character reference: invalid character.',
[ErrorCodes.CDATA_IN_HTML_CONTENT]:
'CDATA section is allowed only in XML context.',
[ErrorCodes.CHARACTER_REFERENCE_OUTSIDE_UNICODE_RANGE]:
'Illegal numeric character reference: too big.',
[ErrorCodes.CONTROL_CHARACTER_REFERENCE]:
'Illegal numeric character reference: control character.',
[ErrorCodes.DUPLICATE_ATTRIBUTE]: 'Duplicate attribute.',
[ErrorCodes.END_TAG_WITH_ATTRIBUTES]: 'End tag cannot have attributes.',
[ErrorCodes.END_TAG_WITH_TRAILING_SOLIDUS]: "Illegal '/' in tags.",
[ErrorCodes.EOF_BEFORE_TAG_NAME]: 'Unexpected EOF in tag.',
[ErrorCodes.EOF_IN_CDATA]: 'Unexpected EOF in CDATA section.',
[ErrorCodes.EOF_IN_COMMENT]: 'Unexpected EOF in comment.',
[ErrorCodes.EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT]:
'Unexpected EOF in script.',
[ErrorCodes.EOF_IN_TAG]: 'Unexpected EOF in tag.',
[ErrorCodes.INCORRECTLY_CLOSED_COMMENT]: 'Incorrectly closed comment.',
[ErrorCodes.INCORRECTLY_OPENED_COMMENT]: 'Incorrectly opened comment.',
[ErrorCodes.INVALID_FIRST_CHARACTER_OF_TAG_NAME]:
"Illegal tag name. Use '&lt;' to print '<'.",
[ErrorCodes.MISSING_ATTRIBUTE_VALUE]: 'Attribute value was expected.',
[ErrorCodes.MISSING_END_TAG_NAME]: 'End tag name was expected.',
[ErrorCodes.MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE]:
'Semicolon was expected.',
[ErrorCodes.MISSING_WHITESPACE_BETWEEN_ATTRIBUTES]:
'Whitespace was expected.',
[ErrorCodes.NESTED_COMMENT]: "Unexpected '<!--' in comment.",
[ErrorCodes.NONCHARACTER_CHARACTER_REFERENCE]:
'Illegal numeric character reference: non character.',
[ErrorCodes.NULL_CHARACTER_REFERENCE]:
'Illegal numeric character reference: null character.',
[ErrorCodes.SURROGATE_CHARACTER_REFERENCE]:
'Illegal numeric character reference: non-pair surrogate.',
[ErrorCodes.UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME]:
'Attribute name cannot contain U+0022 ("), U+0027 (\'), and U+003C (<).',
[ErrorCodes.UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE]:
'Unquoted attribute value cannot contain U+0022 ("), U+0027 (\'), U+003C (<), U+003D (=), and U+0060 (`).',
[ErrorCodes.UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME]:
"Attribute name cannot start with '='.",
[ErrorCodes.UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME]:
"'<?' is allowed only in XML context.",
[ErrorCodes.UNEXPECTED_SOLIDUS_IN_TAG]: "Illegal '/' in tags.",
[ErrorCodes.UNKNOWN_NAMED_CHARACTER_REFERENCE]: 'Unknown entity name.',
[ErrorCodes.X_INVALID_END_TAG]: 'Invalid end tag.',
[ErrorCodes.X_MISSING_END_TAG]: 'End tag was not found.',
[ErrorCodes.X_MISSING_INTERPOLATION_END]:
'Interpolation end sign was not found.',
// transform errors
[ErrorCodes.X_ELSE_IF_NO_ADJACENT_IF]: `v-else-if has no adjacent v-if`,
[ErrorCodes.X_ELSE_NO_ADJACENT_IF]: `v-else has no adjacent v-if`
}

7
packages/compiler-core/src/index.ts
View File

@ -1,3 +1,6 @@
export { parse, ParserOptions, TextModes } from './parser'
export { ParserErrorTypes } from './errorTypes'
export { parse, ParserOptions, TextModes } from './parse'
export { transform, Transform, TransformContext } from './transform'
export { ErrorCodes } from './errors'
export * from './ast'
export { transformIf } from './directives/vIf'

134
packages/compiler-core/src/parser.ts → packages/compiler-core/src/parse.ts
View File

@ -1,4 +1,4 @@
import { ParserErrorTypes, errorMessages } from './errorTypes'
import { ErrorCodes, CompilerError, createCompilerError } from './errors'
import {
Namespace,
Namespaces,
@ -12,7 +12,8 @@ import {
Position,
RootNode,
SourceLocation,
TextNode
TextNode,
ChildNode
} from './ast'
export interface ParserOptions {
@ -26,7 +27,7 @@ export interface ParserOptions {
// The full set is https://html.spec.whatwg.org/multipage/named-characters.html#named-character-references
namedCharacterReferences?: { [name: string]: string | undefined }
onError?: (type: ParserErrorTypes, loc: Position) => void
onError?: (error: CompilerError) => void
}
export const defaultParserOptions: Required<ParserOptions> = {
@ -42,14 +43,7 @@ export const defaultParserOptions: Required<ParserOptions> = {
'apos;': "'",
'quot;': '"'
},
onError(code: ParserErrorTypes, loc: Position): void {
const error: any = new SyntaxError(
`${__DEV__ || !__BROWSER__ ? errorMessages[code] : code} (${loc.line}:${
loc.column
})`
)
error.code = code
error.loc = loc
onError(error: CompilerError): void {
throw error
}
}
@ -106,10 +100,10 @@ function parseChildren(
context: ParserContext,
mode: TextModes,
ancestors: ElementNode[]
): RootNode['children'] {
): ChildNode[] {
const parent = last(ancestors)
const ns = parent ? parent.ns : Namespaces.HTML
const nodes: RootNode['children'] = []
const nodes: ChildNode[] = []
while (!isEnd(context, mode, ancestors)) {
__DEV__ && assert(context.source.length > 0)
@ -122,7 +116,7 @@ function parseChildren(
} else if (mode === TextModes.DATA && s[0] === '<') {
// https://html.spec.whatwg.org/multipage/parsing.html#tag-open-state
if (s.length === 1) {
emitError(context, ParserErrorTypes.EOF_BEFORE_TAG_NAME, 1)
emitError(context, ErrorCodes.EOF_BEFORE_TAG_NAME, 1)
} else if (s[1] === '!') {
// https://html.spec.whatwg.org/multipage/parsing.html#markup-declaration-open-state
if (startsWith(s, '<!--')) {
@ -134,31 +128,27 @@ function parseChildren(
if (ns !== Namespaces.HTML) {
node = parseCDATA(context, ancestors)
} else {
emitError(context, ParserErrorTypes.CDATA_IN_HTML_CONTENT)
emitError(context, ErrorCodes.CDATA_IN_HTML_CONTENT)
node = parseBogusComment(context)
}
} else {
emitError(context, ParserErrorTypes.INCORRECTLY_OPENED_COMMENT)
emitError(context, ErrorCodes.INCORRECTLY_OPENED_COMMENT)
node = parseBogusComment(context)
}
} else if (s[1] === '/') {
// https://html.spec.whatwg.org/multipage/parsing.html#end-tag-open-state
if (s.length === 2) {
emitError(context, ParserErrorTypes.EOF_BEFORE_TAG_NAME, 2)
emitError(context, ErrorCodes.EOF_BEFORE_TAG_NAME, 2)
} else if (s[2] === '>') {
emitError(context, ParserErrorTypes.MISSING_END_TAG_NAME, 2)
emitError(context, ErrorCodes.MISSING_END_TAG_NAME, 2)
advanceBy(context, 3)
continue
} else if (/[a-z]/i.test(s[2])) {
emitError(context, ParserErrorTypes.X_INVALID_END_TAG)
emitError(context, ErrorCodes.X_INVALID_END_TAG)
parseTag(context, TagType.End, parent)
continue
} else {
emitError(
context,
ParserErrorTypes.INVALID_FIRST_CHARACTER_OF_TAG_NAME,
2
)
emitError(context, ErrorCodes.INVALID_FIRST_CHARACTER_OF_TAG_NAME, 2)
node = parseBogusComment(context)
}
} else if (/[a-z]/i.test(s[1])) {
@ -166,16 +156,12 @@ function parseChildren(
} else if (s[1] === '?') {
emitError(
context,
ParserErrorTypes.UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME,
ErrorCodes.UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME,
1
)
node = parseBogusComment(context)
} else {
emitError(
context,
ParserErrorTypes.INVALID_FIRST_CHARACTER_OF_TAG_NAME,
1
)
emitError(context, ErrorCodes.INVALID_FIRST_CHARACTER_OF_TAG_NAME, 1)
}
}
if (!node) {
@ -183,7 +169,9 @@ function parseChildren(
}
if (Array.isArray(node)) {
node.forEach(pushNode.bind(null, context, nodes))
for (let i = 0; i < node.length; i++) {
pushNode(context, nodes, node[i])
}
} else {
pushNode(context, nodes, node)
}
@ -194,8 +182,8 @@ function parseChildren(
function pushNode(
context: ParserContext,
nodes: RootNode['children'],
node: RootNode['children'][0]
nodes: ChildNode[],
node: ChildNode
): void {
if (context.ignoreSpaces && node.type === NodeTypes.TEXT && node.isEmpty) {
return
@ -222,7 +210,7 @@ function pushNode(
function parseCDATA(
context: ParserContext,
ancestors: ElementNode[]
): RootNode['children'] {
): ChildNode[] {
__DEV__ &&
assert(last(ancestors) == null || last(ancestors)!.ns !== Namespaces.HTML)
__DEV__ && assert(startsWith(context.source, '<![CDATA['))
@ -230,7 +218,7 @@ function parseCDATA(
advanceBy(context, 9)
const nodes = parseChildren(context, TextModes.CDATA, ancestors)
if (context.source.length === 0) {
emitError(context, ParserErrorTypes.EOF_IN_CDATA)
emitError(context, ErrorCodes.EOF_IN_CDATA)
} else {
__DEV__ && assert(startsWith(context.source, ']]>'))
advanceBy(context, 3)
@ -250,13 +238,13 @@ function parseComment(context: ParserContext): CommentNode {
if (!match) {
content = context.source.slice(4)
advanceBy(context, context.source.length)
emitError(context, ParserErrorTypes.EOF_IN_COMMENT)
emitError(context, ErrorCodes.EOF_IN_COMMENT)
} else {
if (match.index <= 3) {
emitError(context, ParserErrorTypes.ABRUPT_CLOSING_OF_EMPTY_COMMENT)
emitError(context, ErrorCodes.ABRUPT_CLOSING_OF_EMPTY_COMMENT)
}
if (match[1]) {
emitError(context, ParserErrorTypes.INCORRECTLY_CLOSED_COMMENT)
emitError(context, ErrorCodes.INCORRECTLY_CLOSED_COMMENT)
}
content = context.source.slice(4, match.index)
@ -267,7 +255,7 @@ function parseComment(context: ParserContext): CommentNode {
while ((nestedIndex = s.indexOf('<!--', prevIndex)) !== -1) {
advanceBy(context, nestedIndex - prevIndex + 1)
if (nestedIndex + 4 < s.length) {
emitError(context, ParserErrorTypes.NESTED_COMMENT)
emitError(context, ErrorCodes.NESTED_COMMENT)
}
prevIndex = nestedIndex + 1
}
@ -333,14 +321,11 @@ function parseElement(
if (startsWithEndTagOpen(context.source, element.tag)) {
parseTag(context, TagType.End, parent)
} else {
emitError(context, ParserErrorTypes.X_MISSING_END_TAG)
emitError(context, ErrorCodes.X_MISSING_END_TAG)
if (context.source.length === 0 && element.tag.toLowerCase() === 'script') {
const first = children[0]
if (first && startsWith(first.loc.source, '<!--')) {
emitError(
context,
ParserErrorTypes.EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT
)
emitError(context, ErrorCodes.EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT)
}
}
}
@ -372,7 +357,8 @@ function parseTag(
const start = getCursor(context)
const match = /^<\/?([a-z][^\t\r\n\f />]*)/i.exec(context.source)!
const tag = match[1]
const props = []
const attrs = []
const directives = []
const ns = context.getNamespace(tag, parent)
advanceBy(context, match[0].length)
@ -386,22 +372,26 @@ function parseTag(
!startsWith(context.source, '/>')
) {
if (startsWith(context.source, '/')) {
emitError(context, ParserErrorTypes.UNEXPECTED_SOLIDUS_IN_TAG)
emitError(context, ErrorCodes.UNEXPECTED_SOLIDUS_IN_TAG)
advanceBy(context, 1)
advanceSpaces(context)
continue
}
if (type === TagType.End) {
emitError(context, ParserErrorTypes.END_TAG_WITH_ATTRIBUTES)
emitError(context, ErrorCodes.END_TAG_WITH_ATTRIBUTES)
}
const attr = parseAttribute(context, attributeNames)
if (type === TagType.Start) {
props.push(attr)
if (attr.type === NodeTypes.DIRECTIVE) {
directives.push(attr)
} else {
attrs.push(attr)
}
}
if (/^[^\t\r\n\f />]/.test(context.source)) {
emitError(context, ParserErrorTypes.MISSING_WHITESPACE_BETWEEN_ATTRIBUTES)
emitError(context, ErrorCodes.MISSING_WHITESPACE_BETWEEN_ATTRIBUTES)
}
advanceSpaces(context)
}
@ -409,11 +399,11 @@ function parseTag(
// Tag close.
let isSelfClosing = false
if (context.source.length === 0) {
emitError(context, ParserErrorTypes.EOF_IN_TAG)
emitError(context, ErrorCodes.EOF_IN_TAG)
} else {
isSelfClosing = startsWith(context.source, '/>')
if (type === TagType.End && isSelfClosing) {
emitError(context, ParserErrorTypes.END_TAG_WITH_TRAILING_SOLIDUS)
emitError(context, ErrorCodes.END_TAG_WITH_TRAILING_SOLIDUS)
}
advanceBy(context, isSelfClosing ? 2 : 1)
}
@ -429,7 +419,8 @@ function parseTag(
ns,
tag,
tagType,
props,
attrs,
directives,
isSelfClosing,
children: [],
loc: getSelection(context, start)
@ -448,15 +439,12 @@ function parseAttribute(
const name = match[0]
if (nameSet.has(name)) {
emitError(context, ParserErrorTypes.DUPLICATE_ATTRIBUTE)
emitError(context, ErrorCodes.DUPLICATE_ATTRIBUTE)
}
nameSet.add(name)
if (name[0] === '=') {
emitError(
context,
ParserErrorTypes.UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME
)
emitError(context, ErrorCodes.UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME)
}
{
const pattern = /["'<]/g
@ -464,7 +452,7 @@ function parseAttribute(
while ((m = pattern.exec(name)) !== null) {
emitError(
context,
ParserErrorTypes.UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME,
ErrorCodes.UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME,
m.index
)
}
@ -480,7 +468,7 @@ function parseAttribute(
advanceSpaces(context)
value = parseAttributeValue(context)
if (!value) {
emitError(context, ParserErrorTypes.MISSING_ATTRIBUTE_VALUE)
emitError(context, ErrorCodes.MISSING_ATTRIBUTE_VALUE)
}
}
const loc = getSelection(context, start)
@ -508,7 +496,7 @@ function parseAttribute(
if (!content.endsWith(']')) {
emitError(
context,
ParserErrorTypes.X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END
ErrorCodes.X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END
)
}
@ -590,7 +578,7 @@ function parseAttributeValue(
while ((m = unexpectedChars.exec(match[0])) !== null) {
emitError(
context,
ParserErrorTypes.UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE,
ErrorCodes.UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE,
m.index
)
}
@ -609,7 +597,7 @@ function parseInterpolation(
const closeIndex = context.source.indexOf(close, open.length)
if (closeIndex === -1) {
emitError(context, ParserErrorTypes.X_MISSING_INTERPOLATION_END)
emitError(context, ErrorCodes.X_MISSING_INTERPOLATION_END)
return undefined
}
@ -712,12 +700,12 @@ function parseTextData(
if (!semi) {
emitError(
context,
ParserErrorTypes.MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE
ErrorCodes.MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE
)
}
}
} else {
emitError(context, ParserErrorTypes.UNKNOWN_NAMED_CHARACTER_REFERENCE)
emitError(context, ErrorCodes.UNKNOWN_NAMED_CHARACTER_REFERENCE)
text += '&'
text += name
advanceBy(context, 1 + name.length)
@ -735,33 +723,33 @@ function parseTextData(
text += head[0]
emitError(
context,
ParserErrorTypes.ABSENCE_OF_DIGITS_IN_NUMERIC_CHARACTER_REFERENCE
ErrorCodes.ABSENCE_OF_DIGITS_IN_NUMERIC_CHARACTER_REFERENCE
)
advanceBy(context, head[0].length)
} else {
// https://html.spec.whatwg.org/multipage/parsing.html#numeric-character-reference-end-state
let cp = Number.parseInt(body[1], hex ? 16 : 10)
if (cp === 0) {
emitError(context, ParserErrorTypes.NULL_CHARACTER_REFERENCE)
emitError(context, ErrorCodes.NULL_CHARACTER_REFERENCE)
cp = 0xfffd
} else if (cp > 0x10ffff) {
emitError(
context,
ParserErrorTypes.CHARACTER_REFERENCE_OUTSIDE_UNICODE_RANGE
ErrorCodes.CHARACTER_REFERENCE_OUTSIDE_UNICODE_RANGE
)
cp = 0xfffd
} else if (cp >= 0xd800 && cp <= 0xdfff) {
emitError(context, ParserErrorTypes.SURROGATE_CHARACTER_REFERENCE)
emitError(context, ErrorCodes.SURROGATE_CHARACTER_REFERENCE)
cp = 0xfffd
} else if ((cp >= 0xfdd0 && cp <= 0xfdef) || (cp & 0xfffe) === 0xfffe) {
emitError(context, ParserErrorTypes.NONCHARACTER_CHARACTER_REFERENCE)
emitError(context, ErrorCodes.NONCHARACTER_CHARACTER_REFERENCE)
} else if (
(cp >= 0x01 && cp <= 0x08) ||
cp === 0x0b ||
(cp >= 0x0d && cp <= 0x1f) ||
(cp >= 0x7f && cp <= 0x9f)
) {
emitError(context, ParserErrorTypes.CONTROL_CHARACTER_REFERENCE)
emitError(context, ErrorCodes.CONTROL_CHARACTER_REFERENCE)
cp = CCR_REPLACEMENTS[cp] || cp
}
text += String.fromCodePoint(cp)
@ -769,7 +757,7 @@ function parseTextData(
if (!body![0].endsWith(';')) {
emitError(
context,
ParserErrorTypes.MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE
ErrorCodes.MISSING_SEMICOLON_AFTER_CHARACTER_REFERENCE
)
}
}
@ -854,7 +842,7 @@ function getNewPosition(
function emitError(
context: ParserContext,
type: ParserErrorTypes,
code: ErrorCodes,
offset?: number
): void {
const loc = getCursor(context)
@ -862,7 +850,7 @@ function emitError(
loc.offset += offset
loc.column += offset
}
context.onError(type, loc)
context.onError(createCompilerError(code, loc))
}
function isEnd(

144
packages/compiler-core/src/transform.ts
View File

@ -1 +1,143 @@
// TODO
import {
RootNode,
NodeTypes,
ParentNode,
ChildNode,
ElementNode,
DirectiveNode
} from './ast'
import { isString } from '@vue/shared'
import { CompilerError } from './errors'
export type Transform = (node: ChildNode, context: TransformContext) => void
export type DirectiveTransform = (
node: ElementNode,
dir: DirectiveNode,
context: TransformContext
) => false | void
export interface TransformOptions {
transforms: Transform[]
onError?: (error: CompilerError) => void
}
export interface TransformContext extends Required<TransformOptions> {
parent: ParentNode
ancestors: ParentNode[]
childIndex: number
replaceNode(node: ChildNode): void
removeNode(): void
nodeRemoved: boolean
}
export function transform(root: RootNode, options: TransformOptions) {
const context = createTransformContext(root, options)
traverseChildren(root, context, context.ancestors)
}
function createTransformContext(
root: RootNode,
options: TransformOptions
): TransformContext {
const context: TransformContext = {
onError(error: CompilerError) {
throw error
},
...options,
parent: root,
ancestors: [root],
childIndex: 0,
replaceNode(node) {
context.parent.children[context.childIndex] = node
},
removeNode() {
context.parent.children.splice(context.childIndex, 1)
context.nodeRemoved = true
},
nodeRemoved: false
}
return context
}
function traverseChildren(
parent: ParentNode,
context: TransformContext,
ancestors: ParentNode[]
) {
ancestors = ancestors.concat(parent)
for (let i = 0; i < parent.children.length; i++) {
context.parent = parent
context.ancestors = ancestors
context.childIndex = i
traverseNode(parent.children[i], context, ancestors)
if (context.nodeRemoved) {
i--
}
}
}
function traverseNode(
node: ChildNode,
context: TransformContext,
ancestors: ParentNode[]
) {
// apply transform plugins
const transforms = context.transforms
for (let i = 0; i < transforms.length; i++) {
const transform = transforms[i]
context.nodeRemoved = false
transform(node, context)
if (context.nodeRemoved) {
return
} else {
// node may have been replaced
node = context.parent.children[context.childIndex]
}
}
// further traverse downwards
switch (node.type) {
case NodeTypes.IF:
for (let i = 0; i < node.branches.length; i++) {
traverseChildren(node.branches[i], context, ancestors)
}
break
case NodeTypes.FOR:
case NodeTypes.ELEMENT:
traverseChildren(node, context, ancestors)
break
}
}
const identity = <T>(_: T): T => _
export function createDirectiveTransform(
name: string | RegExp,
fn: DirectiveTransform
): Transform {
const matches = isString(name)
? (n: string) => n === name
: (n: string) => name.test(n)
return (node, context) => {
if (node.type === NodeTypes.ELEMENT) {
const dirs = node.directives
let didRemove = false
for (let i = 0; i < dirs.length; i++) {
if (matches(dirs[i].name)) {
const res = fn(node, dirs[i], context)
// Directives are removed after transformation by default. A transform
// returning false means the directive should not be removed.
if (res !== false) {
;(dirs as any)[i] = undefined
didRemove = true
}
}
}
if (didRemove) {
node.directives = dirs.filter(identity)
}
}
}
}

11
packages/compiler-dom/__tests__/parse.spec.ts
View File

@ -3,7 +3,7 @@ import {
NodeTypes,
ElementNode,
TextNode,
ParserErrorTypes,
ErrorCodes,
ExpressionNode,
ElementTypes
} from '@vue/compiler-core'
@ -134,7 +134,8 @@ describe('DOM parser', () => {
ns: DOMNamespaces.HTML,
tag: 'img',
tagType: ElementTypes.ELEMENT,
props: [],
attrs: [],
directives: [],
isSelfClosing: false,
children: [],
loc: {
@ -150,9 +151,9 @@ describe('DOM parser', () => {
'<textarea>hello</textarea</textarea0></texTArea a="<>">',
{
...parserOptions,
onError: type => {
if (type !== ParserErrorTypes.END_TAG_WITH_ATTRIBUTES) {
throw new Error(String(type))
onError: err => {
if (err.code !== ErrorCodes.END_TAG_WITH_ATTRIBUTES) {
throw err
}
}
}

4
packages/compiler-dom/src/parserOptionsMinimal.ts
View File

@ -1,5 +1,4 @@
import {
NodeTypes,
TextModes,
ParserOptions,
ElementNode,
@ -23,9 +22,8 @@ export const parserOptionsMinimal: ParserOptions = {
return DOMNamespaces.SVG
}
if (
parent.props.some(
parent.attrs.some(
a =>
a.type === NodeTypes.ATTRIBUTE &&
a.name === 'encoding' &&
a.value != null &&
(a.value.content === 'text/html' ||