@glimmer/compiler
Version:
257 lines (218 loc) • 26.1 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.keyword = keyword;
exports.keywords = keywords;
exports.Keywords = exports.KEYWORD_NODES = void 0;
var _syntax = require("@glimmer/syntax");
var _util = require("@glimmer/util");
var _result = require("../../../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 (0, _result.Err)((0, _syntax.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;
}
}
}
const KEYWORD_NODES = {
Call: ['Call'],
Block: ['InvokeBlock'],
Append: ['AppendContent'],
Modifier: ['ElementModifier']
};
exports.KEYWORD_NODES = KEYWORD_NODES;
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;
}
}
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' && (0, _syntax.isKeyword)(path.ref.name)) {
let {
name
} = path.ref;
let usedType = this._type;
let validTypes = _syntax.KEYWORDS_TYPES[name];
if (validTypes.indexOf(usedType) === -1) {
return (0, _result.Err)((0, _syntax.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;
}
}
exports.Keywords = Keywords;
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 (0, _util.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.
*/
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":";;;;;;;;;AAAA;;AAOA;;AAEA;;AAgBA,MAAA,WAAA,CAAiB;AAQf,EAAA,WAAA,CAAA,OAAA,EAAA,IAAA,EAAA,QAAA,EAGkE;AAFtD,SAAA,OAAA,GAAA,OAAA;AAEF,SAAA,QAAA,GAAA,QAAA;AAER,QAAI,KAAK,GAAG,IAAZ,GAAY,EAAZ;;AACA,SAAK,IAAL,QAAA,IAAqB,aAAa,CAAlC,IAAkC,CAAlC,EAA0C;AACxC,MAAA,KAAK,CAAL,GAAA,CAAA,QAAA;AACD;;AAED,SAAA,KAAA,GAAA,KAAA;AACD;;AAES,EAAA,KAAK,CAAA,IAAA,EAA2B;AACxC,QAAI,CAAC,KAAA,KAAA,CAAA,GAAA,CAAe,IAAI,CAAxB,IAAK,CAAL,EAAgC;AAC9B,aAAA,KAAA;AACD;;AAED,QAAI,IAAI,GAAG,mBAAmB,CAA9B,IAA8B,CAA9B;;AAEA,QAAI,IAAI,KAAJ,IAAA,IAAiB,IAAI,CAAJ,IAAA,KAAjB,MAAA,IAAyC,IAAI,CAAJ,GAAA,CAAA,IAAA,KAA7C,MAAA,EAAuE;AACrE,UAAI,IAAI,CAAJ,IAAA,CAAA,MAAA,GAAJ,CAAA,EAA0B;AACxB,YAAI,IAAI,CAAJ,GAAA,CAAA,UAAA,CAAA,SAAA,OAAJ,OAAA,EAAiD;AAC/C;AACA;AACA,iBAAA,KAAA;AACD;AACF;;AAED,aAAO,IAAI,CAAJ,GAAA,CAAA,IAAA,KAAkB,KAAzB,OAAA;AATF,KAAA,MAUO;AACL,aAAA,KAAA;AACD;AACF;;AAED,EAAA,SAAS,CAAA,IAAA,EAAA,KAAA,EAAmD;AAC1D,QAAI,KAAA,KAAA,CAAJ,IAAI,CAAJ,EAAsB;AACpB,UAAI,IAAI,GAAG,mBAAmB,CAA9B,IAA8B,CAA9B;;AAEA,UAAI,IAAI,KAAJ,IAAA,IAAiB,IAAI,CAAJ,IAAA,KAAjB,MAAA,IAAyC,IAAI,CAAJ,IAAA,CAAA,MAAA,GAA7C,CAAA,EAAmE;AACjE,eAAO,iBACL,iCACE,SACE,KAAK,OACP,qDAAqD,IAAI,CAAJ,GAAA,CAAA,QAAA,EAHpC,8EAAnB,EAIE,IAAI,CALR,GACE,CADK,CAAP;AAQD;;AAED,UAAI,KAAK,GAAG,KAAA,QAAA,CAAA,MAAA,CAAA,IAAA,EAAZ,KAAY,CAAZ;AACA,aAAO,KAAK,CAAL,OAAA,CAAe,KAAD,IAAW,KAAA,QAAA,CAAA,SAAA,CAAwB;AAAA,QAAA,IAAA;AAAQ,QAAA;AAAR,OAAxB,EAAhC,KAAgC,CAAzB,CAAP;AAfF,KAAA,MAgBO;AACL,aAAA,IAAA;AACD;AACF;;AA/Dc;;AAwEV,MAAM,aAAa,GAAG;AAC3B,EAAA,IAAI,EAAE,CADqB,MACrB,CADqB;AAE3B,EAAA,KAAK,EAAE,CAFoB,aAEpB,CAFoB;AAG3B,EAAA,MAAM,EAAE,CAHmB,eAGnB,CAHmB;AAI3B,EAAA,QAAQ,EAAE,CAAA,iBAAA;AAJiB,CAAtB;;;AAqCD,SAAA,OAAA,CAAA,OAAA,EAAA,IAAA,EAAA,QAAA,EAIiC;AACrC,SAAO,IAAA,WAAA,CAAA,OAAA,EAAA,IAAA,EAAP,QAAO,CAAP;AACD;;AASD,SAAA,mBAAA,CAAA,IAAA,EAC0C;AAExC,UAAQ,IAAI,CAAZ,IAAA;AACE;AACA;AACA,SAAA,MAAA;AACE,aAAA,IAAA;;AACF,SAAA,eAAA;AACE,aAAO,mBAAmB,CAAC,IAAI,CAA/B,KAA0B,CAA1B;;AACF,SAAA,MAAA;AACA,SAAA,aAAA;AACA,SAAA,iBAAA;AACE,aAAO,IAAI,CAAX,MAAA;;AACF;AACE,aAAA,IAAA;AAZJ;AAcD;;AAEK,MAAA,QAAA,CAAe;AAKnB,EAAA,WAAA,CAAA,IAAA,EAAmB;AAHnB,SAAA,SAAA,GAAA,EAAA;AAIE,SAAA,KAAA,GAAA,IAAA;AACD;;AAED,EAAA,EAAE,CAAA,IAAA,EAAA,QAAA,EAE0D;AAE1D,SAAA,SAAA,CAAA,IAAA,CAAoB,OAAO,CAAA,IAAA,EAAO,KAAP,KAAA,EAA3B,QAA2B,CAA3B;;AAEA,WAAA,IAAA;AACD;;AAED,EAAA,SAAS,CAAA,IAAA,EAAA,KAAA,EAEkB;AAEzB,SAAK,IAAL,OAAA,IAAoB,KAApB,SAAA,EAAoC;AAClC,UAAI,MAAM,GAAG,OAAO,CAAP,SAAA,CAAA,IAAA,EAAb,KAAa,CAAb;;AACA,UAAI,MAAM,KAAV,IAAA,EAAqB;AACnB,eAAA,MAAA;AACD;AACF;;AAED,QAAI,IAAI,GAAG,mBAAmB,CAA9B,IAA8B,CAA9B;;AAEA,QAAI,IAAI,IAAI,IAAI,CAAJ,IAAA,KAAR,MAAA,IAAgC,IAAI,CAAJ,GAAA,CAAA,IAAA,KAAhC,MAAA,IAA4D,uBAAU,IAAI,CAAJ,GAAA,CAA1E,IAAgE,CAAhE,EAA0F;AACxF,UAAI;AAAE,QAAA;AAAF,UAAW,IAAI,CAAnB,GAAA;AAEA,UAAI,QAAQ,GAAG,KAAf,KAAA;AACA,UAAI,UAAU,GAAG,uBAAjB,IAAiB,CAAjB;;AAEA,UAAI,UAAU,CAAV,OAAA,CAAA,QAAA,MAAiC,CAArC,CAAA,EAAyC;AACvC,eAAO,iBACL,iCACE,SAAS,IAAI,mDACX,mBAAmB,CAAA,QAAA,CACrB,kCAAkC,oBAAoB,CAAA,IAAA,EAAA,UAAA,CAHrC,qBAAnB,EAOE,IAAI,CARR,GACE,CADK,CAAP;AAWD;AACF;;AAED,WAAA,IAAA;AACD;;AArDkB;;;AAwDrB,MAAM,mBAAmB,GAAG;AAC1B,EAAA,MAAM,EADoB,qBAAA;AAE1B,EAAA,KAAK,EAFqB,mBAAA;AAG1B,EAAA,IAAI,EAHsB,mBAAA;AAI1B,EAAA,QAAQ,EAAE;AAJgB,CAA5B;;AAOA,SAAA,oBAAA,CAAA,IAAA,EAAA,KAAA,EAAgE;AAC9D,SAAO,KAAK,CAAL,GAAA,CACC,IAAD,IAAS;AACZ,YAAA,IAAA;AACE,WAAA,QAAA;AACE,eAAO,sCAAsC,IAA7C,IAAA;;AACF,WAAA,OAAA;AACE,eAAO,qCAAqC,IAAI,QAAQ,IAAxD,IAAA;;AACF,WAAA,MAAA;AACE,eAAO,+BAA+B,IAAtC,GAAA;;AACF,WAAA,UAAA;AACE,eAAO,kCAAkC,IAAzC,WAAA;;AACF;AACE,eAAO,qBAAP,IAAO,CAAP;AAVJ;AAFG,GAAA,EAAA,IAAA,CAAP,MAAO,CAAP;AAgBD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiFM,SAAA,QAAA,CAAA,IAAA,EAAiD;AACrD,SAAO,IAAA,QAAA,CAAP,IAAO,CAAP;AACD","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":""}