@glimmer/compiler
Version:
242 lines (209 loc) • 26 kB
JavaScript
import { generateSyntaxError, isKeyword, KEYWORDS_TYPES } from '@glimmer/syntax';
import { exhausted } from '@glimmer/util';
import { Err } from '../../../shared/result';
class KeywordImpl {
constructor(keyword, type, delegate) {
this.keyword = keyword;
this.delegate = delegate;
let nodes = new Set();
for (let nodeType of KEYWORD_NODES[type]) {
nodes.add(nodeType);
}
this.types = nodes;
}
match(node) {
if (!this.types.has(node.type)) {
return false;
}
let path = getCalleeExpression(node);
if (path !== null && path.type === 'Path' && path.ref.type === 'Free') {
if (path.tail.length > 0) {
if (path.ref.resolution.serialize() === 'Loose') {
// cannot be a keyword reference, keywords do not allow paths (must be
// relying on implicit this fallback)
return false;
}
}
return path.ref.name === this.keyword;
} else {
return false;
}
}
translate(node, state) {
if (this.match(node)) {
let path = getCalleeExpression(node);
if (path !== null && path.type === 'Path' && path.tail.length > 0) {
return Err(generateSyntaxError(`The \`${this.keyword}\` keyword was used incorrectly. It was used as \`${path.loc.asString()}\`, but it cannot be used with additional path segments. \n\nError caused by`, node.loc));
}
let param = this.delegate.assert(node, state);
return param.andThen(param => this.delegate.translate({
node,
state
}, param));
} else {
return null;
}
}
}
export const KEYWORD_NODES = {
Call: ['Call'],
Block: ['InvokeBlock'],
Append: ['AppendContent'],
Modifier: ['ElementModifier']
};
export function keyword(keyword, type, delegate) {
return new KeywordImpl(keyword, type, delegate);
}
function getCalleeExpression(node) {
switch (node.type) {
// This covers the inside of attributes and expressions, as well as the callee
// of call nodes
case 'Path':
return node;
case 'AppendContent':
return getCalleeExpression(node.value);
case 'Call':
case 'InvokeBlock':
case 'ElementModifier':
return node.callee;
default:
return null;
}
}
export class Keywords {
constructor(type) {
this._keywords = [];
this._type = type;
}
kw(name, delegate) {
this._keywords.push(keyword(name, this._type, delegate));
return this;
}
translate(node, state) {
for (let keyword of this._keywords) {
let result = keyword.translate(node, state);
if (result !== null) {
return result;
}
}
let path = getCalleeExpression(node);
if (path && path.type === 'Path' && path.ref.type === 'Free' && isKeyword(path.ref.name)) {
let {
name
} = path.ref;
let usedType = this._type;
let validTypes = KEYWORDS_TYPES[name];
if (validTypes.indexOf(usedType) === -1) {
return Err(generateSyntaxError(`The \`${name}\` keyword was used incorrectly. It was used as ${typesToReadableName[usedType]}, but its valid usages are:\n\n${generateTypesMessage(name, validTypes)}\n\nError caused by`, node.loc));
}
}
return null;
}
}
const typesToReadableName = {
Append: 'an append statement',
Block: 'a block statement',
Call: 'a call expression',
Modifier: 'a modifier'
};
function generateTypesMessage(name, types) {
return types.map(type => {
switch (type) {
case 'Append':
return `- As an append statement, as in: {{${name}}}`;
case 'Block':
return `- As a block statement, as in: {{#${name}}}{{/${name}}}`;
case 'Call':
return `- As an expression, as in: (${name})`;
case 'Modifier':
return `- As a modifier, as in: <div {{${name}}}></div>`;
default:
return exhausted(type);
}
}).join('\n\n');
}
/**
* This function builds keyword definitions for a particular type of AST node (`KeywordType`).
*
* You can build keyword definitions for:
*
* - `Expr`: A `SubExpression` or `PathExpression`
* - `Block`: A `BlockStatement`
* - A `BlockStatement` is a keyword candidate if its head is a
* `PathExpression`
* - `Append`: An `AppendStatement`
*
* A node is a keyword candidate if:
*
* - A `PathExpression` is a keyword candidate if it has no tail, and its
* head expression is a `LocalVarHead` or `FreeVarHead` whose name is
* the keyword's name.
* - A `SubExpression`, `AppendStatement`, or `BlockStatement` is a keyword
* candidate if its head is a keyword candidate.
*
* The keyword infrastructure guarantees that:
*
* - If a node is not a keyword candidate, it is never passed to any keyword's
* `assert` method.
* - If a node is not the `KeywordType` for a particular keyword, it will not
* be passed to the keyword's `assert` method.
*
* `Expr` keywords are used in expression positions and should return HIR
* expressions. `Block` and `Append` keywords are used in statement
* positions and should return HIR statements.
*
* A keyword definition has two parts:
*
* - `match`, which determines whether an AST node matches the keyword, and can
* optionally return some information extracted from the AST node.
* - `translate`, which takes a matching AST node as well as the extracted
* information and returns an appropriate HIR instruction.
*
* # Example
*
* This keyword:
*
* - turns `(hello)` into `"hello"`
* - as long as `hello` is not in scope
* - makes it an error to pass any arguments (such as `(hello world)`)
*
* ```ts
* keywords('SubExpr').kw('hello', {
* assert(node: ExprKeywordNode): Result<void> | false {
* // we don't want to transform `hello` as a `PathExpression`
* if (node.type !== 'SubExpression') {
* return false;
* }
*
* // node.head would be `LocalVarHead` if `hello` was in scope
* if (node.head.type !== 'FreeVarHead') {
* return false;
* }
*
* if (node.params.length || node.hash) {
* return Err(generateSyntaxError(`(hello) does not take any arguments`), node.loc);
* } else {
* return Ok();
* }
* },
*
* translate(node: ASTv2.SubExpression): hir.Expression {
* return ASTv2.builders.literal("hello", node.loc)
* }
* })
* ```
*
* The keyword infrastructure checks to make sure that the node is the right
* type before calling `assert`, so you only need to consider `SubExpression`
* and `PathExpression` here. It also checks to make sure that the node passed
* to `assert` has the keyword name in the right place.
*
* Note the important difference between returning `false` from `assert`,
* which just means that the node didn't match, and returning `Err`, which
* means that the node matched, but there was a keyword-specific syntax
* error.
*/
export function keywords(type) {
return new Keywords(type);
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../../../packages/@glimmer/compiler/lib/passes/1-normalization/keywords/impl.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ASTv2,\n  generateSyntaxError,\n  isKeyword,\n  KEYWORDS_TYPES,\n  KeywordType,\n} from '@glimmer/syntax';\nimport { exhausted } from '@glimmer/util';\n\nimport { Err, Result } from '../../../shared/result';\nimport { NormalizationState } from '../context';\n\nexport interface KeywordDelegate<Match extends KeywordMatch, V, Out> {\n  assert(options: Match, state: NormalizationState): Result<V>;\n  translate(options: { node: Match; state: NormalizationState }, param: V): Result<Out>;\n}\n\nexport interface Keyword<K extends KeywordType = KeywordType, Out = unknown> {\n  translate(node: KeywordCandidates[K], state: NormalizationState): Result<Out> | null;\n}\n\nexport interface BlockKeyword<Out = unknown> {\n  translate(node: ASTv2.InvokeBlock, state: NormalizationState): Result<Out> | null;\n}\n\nclass KeywordImpl<\n  K extends KeywordType,\n  S extends string = string,\n  Param = unknown,\n  Out = unknown\n> {\n  protected types: Set<KeywordCandidates[K]['type']>;\n\n  constructor(\n    protected keyword: S,\n    type: KeywordType,\n    private delegate: KeywordDelegate<KeywordMatches[K], Param, Out>\n  ) {\n    let nodes = new Set<KeywordNode['type']>();\n    for (let nodeType of KEYWORD_NODES[type]) {\n      nodes.add(nodeType);\n    }\n\n    this.types = nodes;\n  }\n\n  protected match(node: KeywordCandidates[K]): node is KeywordMatches[K] {\n    if (!this.types.has(node.type)) {\n      return false;\n    }\n\n    let path = getCalleeExpression(node);\n\n    if (path !== null && path.type === 'Path' && path.ref.type === 'Free') {\n      if (path.tail.length > 0) {\n        if (path.ref.resolution.serialize() === 'Loose') {\n          // cannot be a keyword reference, keywords do not allow paths (must be\n          // relying on implicit this fallback)\n          return false;\n        }\n      }\n\n      return path.ref.name === this.keyword;\n    } else {\n      return false;\n    }\n  }\n\n  translate(node: KeywordMatches[K], state: NormalizationState): Result<Out> | null {\n    if (this.match(node)) {\n      let path = getCalleeExpression(node);\n\n      if (path !== null && path.type === 'Path' && path.tail.length > 0) {\n        return Err(\n          generateSyntaxError(\n            `The \\`${\n              this.keyword\n            }\\` keyword was used incorrectly. It was used as \\`${path.loc.asString()}\\`, but it cannot be used with additional path segments. \\n\\nError caused by`,\n            node.loc\n          )\n        );\n      }\n\n      let param = this.delegate.assert(node, state);\n      return param.andThen((param) => this.delegate.translate({ node, state }, param));\n    } else {\n      return null;\n    }\n  }\n}\n\nexport type PossibleNode =\n  | ASTv2.PathExpression\n  | ASTv2.AppendContent\n  | ASTv2.CallExpression\n  | ASTv2.InvokeBlock;\n\nexport const KEYWORD_NODES = {\n  Call: ['Call'],\n  Block: ['InvokeBlock'],\n  Append: ['AppendContent'],\n  Modifier: ['ElementModifier'],\n} as const;\n\nexport interface KeywordCandidates {\n  Call: ASTv2.ExpressionNode;\n  Block: ASTv2.InvokeBlock;\n  Append: ASTv2.AppendContent;\n  Modifier: ASTv2.ElementModifier;\n}\n\nexport type KeywordCandidate = KeywordCandidates[keyof KeywordCandidates];\n\nexport interface KeywordMatches {\n  Call: ASTv2.CallExpression;\n  Block: ASTv2.InvokeBlock;\n  Append: ASTv2.AppendContent;\n  Modifier: ASTv2.ElementModifier;\n}\n\nexport type KeywordMatch = KeywordMatches[keyof KeywordMatches];\n\n/**\n * A \"generic\" keyword is something like `has-block`, which makes sense in the context\n * of sub-expression or append\n */\nexport type GenericKeywordNode = ASTv2.AppendContent | ASTv2.CallExpression;\n\nexport type KeywordNode =\n  | GenericKeywordNode\n  | ASTv2.CallExpression\n  | ASTv2.InvokeBlock\n  | ASTv2.ElementModifier;\n\nexport function keyword<\n  K extends KeywordType,\n  D extends KeywordDelegate<KeywordMatches[K], unknown, Out>,\n  Out = unknown\n>(keyword: string, type: K, delegate: D): Keyword<K, Out> {\n  return new KeywordImpl(keyword, type, delegate as KeywordDelegate<KeywordMatch, unknown, Out>);\n}\n\nexport type PossibleKeyword = KeywordNode;\ntype OutFor<K extends Keyword | BlockKeyword> = K extends BlockKeyword<infer Out>\n  ? Out\n  : K extends Keyword<KeywordType, infer Out>\n  ? Out\n  : never;\n\nfunction getCalleeExpression(\n  node: KeywordNode | ASTv2.ExpressionNode\n): ASTv2.ExpressionNode | null {\n  switch (node.type) {\n    // This covers the inside of attributes and expressions, as well as the callee\n    // of call nodes\n    case 'Path':\n      return node;\n    case 'AppendContent':\n      return getCalleeExpression(node.value);\n    case 'Call':\n    case 'InvokeBlock':\n    case 'ElementModifier':\n      return node.callee;\n    default:\n      return null;\n  }\n}\n\nexport class Keywords<K extends KeywordType, KeywordList extends Keyword<K> = never>\n  implements Keyword<K, OutFor<KeywordList>> {\n  _keywords: Keyword[] = [];\n  _type: K;\n\n  constructor(type: K) {\n    this._type = type;\n  }\n\n  kw<S extends string = string, Out = unknown>(\n    name: S,\n    delegate: KeywordDelegate<KeywordMatches[K], unknown, Out>\n  ): Keywords<K, KeywordList | Keyword<K, Out>> {\n    this._keywords.push(keyword(name, this._type, delegate));\n\n    return this;\n  }\n\n  translate(\n    node: KeywordCandidates[K],\n    state: NormalizationState\n  ): Result<OutFor<KeywordList>> | null {\n    for (let keyword of this._keywords) {\n      let result = keyword.translate(node, state) as Result<OutFor<KeywordList>>;\n      if (result !== null) {\n        return result;\n      }\n    }\n\n    let path = getCalleeExpression(node);\n\n    if (path && path.type === 'Path' && path.ref.type === 'Free' && isKeyword(path.ref.name)) {\n      let { name } = path.ref;\n\n      let usedType = this._type;\n      let validTypes = KEYWORDS_TYPES[name];\n\n      if (validTypes.indexOf(usedType) === -1) {\n        return Err(\n          generateSyntaxError(\n            `The \\`${name}\\` keyword was used incorrectly. It was used as ${\n              typesToReadableName[usedType]\n            }, but its valid usages are:\\n\\n${generateTypesMessage(\n              name,\n              validTypes\n            )}\\n\\nError caused by`,\n            node.loc\n          )\n        );\n      }\n    }\n\n    return null;\n  }\n}\n\nconst typesToReadableName = {\n  Append: 'an append statement',\n  Block: 'a block statement',\n  Call: 'a call expression',\n  Modifier: 'a modifier',\n};\n\nfunction generateTypesMessage(name: string, types: KeywordType[]): string {\n  return types\n    .map((type) => {\n      switch (type) {\n        case 'Append':\n          return `- As an append statement, as in: {{${name}}}`;\n        case 'Block':\n          return `- As a block statement, as in: {{#${name}}}{{/${name}}}`;\n        case 'Call':\n          return `- As an expression, as in: (${name})`;\n        case 'Modifier':\n          return `- As a modifier, as in: <div {{${name}}}></div>`;\n        default:\n          return exhausted(type);\n      }\n    })\n    .join('\\n\\n');\n}\n\n/**\n * This function builds keyword definitions for a particular type of AST node (`KeywordType`).\n *\n * You can build keyword definitions for:\n *\n * - `Expr`: A `SubExpression` or `PathExpression`\n * - `Block`: A `BlockStatement`\n *   - A `BlockStatement` is a keyword candidate if its head is a\n *     `PathExpression`\n * - `Append`: An `AppendStatement`\n *\n * A node is a keyword candidate if:\n *\n * - A `PathExpression` is a keyword candidate if it has no tail, and its\n *   head expression is a `LocalVarHead` or `FreeVarHead` whose name is\n *   the keyword's name.\n * - A `SubExpression`, `AppendStatement`, or `BlockStatement` is a keyword\n *   candidate if its head is a keyword candidate.\n *\n * The keyword infrastructure guarantees that:\n *\n * - If a node is not a keyword candidate, it is never passed to any keyword's\n *   `assert` method.\n * - If a node is not the `KeywordType` for a particular keyword, it will not\n *   be passed to the keyword's `assert` method.\n *\n * `Expr` keywords are used in expression positions and should return HIR\n * expressions. `Block` and `Append` keywords are used in statement\n * positions and should return HIR statements.\n *\n * A keyword definition has two parts:\n *\n * - `match`, which determines whether an AST node matches the keyword, and can\n *   optionally return some information extracted from the AST node.\n * - `translate`, which takes a matching AST node as well as the extracted\n *   information and returns an appropriate HIR instruction.\n *\n * # Example\n *\n * This keyword:\n *\n * - turns `(hello)` into `\"hello\"`\n *   - as long as `hello` is not in scope\n * - makes it an error to pass any arguments (such as `(hello world)`)\n *\n * ```ts\n * keywords('SubExpr').kw('hello', {\n *   assert(node: ExprKeywordNode): Result<void> | false {\n *     // we don't want to transform `hello` as a `PathExpression`\n *     if (node.type !== 'SubExpression') {\n *       return false;\n *     }\n *\n *     // node.head would be `LocalVarHead` if `hello` was in scope\n *     if (node.head.type !== 'FreeVarHead') {\n *       return false;\n *     }\n *\n *     if (node.params.length || node.hash) {\n *       return Err(generateSyntaxError(`(hello) does not take any arguments`), node.loc);\n *     } else {\n *       return Ok();\n *     }\n *   },\n *\n *   translate(node: ASTv2.SubExpression): hir.Expression {\n *     return ASTv2.builders.literal(\"hello\", node.loc)\n *   }\n * })\n * ```\n *\n * The keyword infrastructure checks to make sure that the node is the right\n * type before calling `assert`, so you only need to consider `SubExpression`\n * and `PathExpression` here. It also checks to make sure that the node passed\n * to `assert` has the keyword name in the right place.\n *\n * Note the important difference between returning `false` from `assert`,\n * which just means that the node didn't match, and returning `Err`, which\n * means that the node matched, but there was a keyword-specific syntax\n * error.\n */\nexport function keywords<K extends KeywordType>(type: K): Keywords<K> {\n  return new Keywords(type);\n}\n"],"sourceRoot":""}