@glimmer/compiler
Version:
259 lines (219 loc) • 27.8 kB
JavaScript
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } it = o[Symbol.iterator](); return it.next.bind(it); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
import { generateSyntaxError, isKeyword, KEYWORDS_TYPES } from '@glimmer/syntax';
import { exhausted } from '@glimmer/util';
import { Err } from '../../../shared/result';
var KeywordImpl = /*#__PURE__*/function () {
function KeywordImpl(keyword, type, delegate) {
this.keyword = keyword;
this.delegate = delegate;
var nodes = new Set();
for (var _iterator = _createForOfIteratorHelperLoose(KEYWORD_NODES[type]), _step; !(_step = _iterator()).done;) {
var nodeType = _step.value;
nodes.add(nodeType);
}
this.types = nodes;
}
var _proto = KeywordImpl.prototype;
_proto.match = function match(node) {
if (!this.types.has(node.type)) {
return false;
}
var 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;
}
};
_proto.translate = function translate(node, state) {
var _this = this;
if (this.match(node)) {
var 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));
}
var param = this.delegate.assert(node, state);
return param.andThen(function (param) {
return _this.delegate.translate({
node: node,
state: state
}, param);
});
} else {
return null;
}
};
return KeywordImpl;
}();
export var 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 var Keywords = /*#__PURE__*/function () {
function Keywords(type) {
this._keywords = [];
this._type = type;
}
var _proto2 = Keywords.prototype;
_proto2.kw = function kw(name, delegate) {
this._keywords.push(keyword(name, this._type, delegate));
return this;
};
_proto2.translate = function translate(node, state) {
for (var _iterator2 = _createForOfIteratorHelperLoose(this._keywords), _step2; !(_step2 = _iterator2()).done;) {
var _keyword = _step2.value;
var result = _keyword.translate(node, state);
if (result !== null) {
return result;
}
}
var path = getCalleeExpression(node);
if (path && path.type === 'Path' && path.ref.type === 'Free' && isKeyword(path.ref.name)) {
var name = path.ref.name;
var usedType = this._type;
var 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;
};
return Keywords;
}();
var typesToReadableName = {
Append: 'an append statement',
Block: 'a block statement',
Call: 'a call expression',
Modifier: 'a modifier'
};
function generateTypesMessage(name, types) {
return types.map(function (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":""}