@glimmer/compiler
Version:
175 lines (142 loc) • 17.8 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.convertPathToCallIfKeyword = convertPathToCallIfKeyword;
exports.VISIT_EXPRS = exports.NormalizeExpressions = void 0;
var _syntax = require("@glimmer/syntax");
var _util = require("@glimmer/util");
var _result = require("../../../shared/result");
var mir = _interopRequireWildcard(require("../../2-encoding/mir"));
var _keywords = require("../keywords");
var _isNode = require("../utils/is-node");
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
class NormalizeExpressions {
visit(node, state) {
switch (node.type) {
case 'Literal':
return (0, _result.Ok)(this.Literal(node));
case 'Interpolate':
return this.Interpolate(node, state);
case 'Path':
return this.PathExpression(node);
case 'Call':
let translated = _keywords.CALL_KEYWORDS.translate(node, state);
if (translated !== null) {
return translated;
}
return this.CallExpression(node, state);
case 'DeprecatedCall':
return this.DeprecaedCallExpression(node, state);
}
}
visitList(nodes, state) {
return new _result.ResultArray(nodes.map(e => VISIT_EXPRS.visit(e, state))).toOptionalList();
}
/**
* Normalize paths into `hir.Path` or a `hir.Expr` that corresponds to the ref.
*
* TODO since keywords don't support tails anyway, distinguish PathExpression from
* VariableReference in ASTv2.
*/
PathExpression(path) {
let ref = this.VariableReference(path.ref);
let {
tail
} = path;
if ((0, _util.isPresent)(tail)) {
let tailLoc = tail[0].loc.extend(tail[tail.length - 1].loc);
return (0, _result.Ok)(new mir.PathExpression({
loc: path.loc,
head: ref,
tail: new mir.Tail({
loc: tailLoc,
members: tail
})
}));
} else {
return (0, _result.Ok)(ref);
}
}
VariableReference(ref) {
return ref;
}
Literal(literal) {
return literal;
}
Interpolate(expr, state) {
let parts = expr.parts.map(convertPathToCallIfKeyword);
return VISIT_EXPRS.visitList(parts, state).mapOk(parts => new mir.InterpolateExpression({
loc: expr.loc,
parts: parts
}));
}
CallExpression(expr, state) {
if (!(0, _isNode.hasPath)(expr)) {
throw new Error(`unimplemented subexpression at the head of a subexpression`);
} else {
return _result.Result.all(VISIT_EXPRS.visit(expr.callee, state), VISIT_EXPRS.Args(expr.args, state)).mapOk(([callee, args]) => new mir.CallExpression({
loc: expr.loc,
callee,
args
}));
}
}
DeprecaedCallExpression({
arg,
callee,
loc
}, _state) {
return (0, _result.Ok)(new mir.DeprecatedCallExpression({
loc,
arg,
callee
}));
}
Args({
positional,
named,
loc
}, state) {
return _result.Result.all(this.Positional(positional, state), this.NamedArguments(named, state)).mapOk(([positional, named]) => new mir.Args({
loc,
positional,
named
}));
}
Positional(positional, state) {
return VISIT_EXPRS.visitList(positional.exprs, state).mapOk(list => new mir.Positional({
loc: positional.loc,
list
}));
}
NamedArguments(named, state) {
let pairs = named.entries.map(arg => {
let value = convertPathToCallIfKeyword(arg.value);
return VISIT_EXPRS.visit(value, state).mapOk(value => new mir.NamedArgument({
loc: arg.loc,
key: arg.name,
value
}));
});
return new _result.ResultArray(pairs).toOptionalList().mapOk(pairs => new mir.NamedArguments({
loc: named.loc,
entries: pairs
}));
}
}
exports.NormalizeExpressions = NormalizeExpressions;
function convertPathToCallIfKeyword(path) {
if (path.type === 'Path' && path.ref.type === 'Free' && path.ref.name in _syntax.KEYWORDS_TYPES) {
return new _syntax.ASTv2.CallExpression({
callee: path,
args: _syntax.ASTv2.Args.empty(path.loc),
loc: path.loc
});
}
return path;
}
const VISIT_EXPRS = new NormalizeExpressions();
exports.VISIT_EXPRS = VISIT_EXPRS;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../../../packages/@glimmer/compiler/lib/passes/1-normalization/visitors/expressions.ts"],"names":[],"mappings":"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","sourcesContent":["import { PresentArray } from '@glimmer/interfaces';\nimport { ASTv2, KEYWORDS_TYPES } from '@glimmer/syntax';\nimport { isPresent } from '@glimmer/util';\n\nimport { AnyOptionalList, PresentList } from '../../../shared/list';\nimport { Ok, Result, ResultArray } from '../../../shared/result';\nimport * as mir from '../../2-encoding/mir';\nimport { NormalizationState } from '../context';\nimport { CALL_KEYWORDS } from '../keywords';\nimport { hasPath } from '../utils/is-node';\n\nexport class NormalizeExpressions {\n  visit(node: ASTv2.ExpressionNode, state: NormalizationState): Result<mir.ExpressionNode> {\n    switch (node.type) {\n      case 'Literal':\n        return Ok(this.Literal(node));\n      case 'Interpolate':\n        return this.Interpolate(node, state);\n      case 'Path':\n        return this.PathExpression(node);\n      case 'Call':\n        let translated = CALL_KEYWORDS.translate(node, state);\n\n        if (translated !== null) {\n          return translated;\n        }\n\n        return this.CallExpression(node, state);\n      case 'DeprecatedCall':\n        return this.DeprecaedCallExpression(node, state);\n    }\n  }\n\n  visitList(\n    nodes: PresentArray<ASTv2.ExpressionNode>,\n    state: NormalizationState\n  ): Result<PresentList<mir.ExpressionNode>>;\n  visitList(\n    nodes: readonly ASTv2.ExpressionNode[],\n    state: NormalizationState\n  ): Result<AnyOptionalList<mir.ExpressionNode>>;\n  visitList(\n    nodes: readonly ASTv2.ExpressionNode[],\n    state: NormalizationState\n  ): Result<AnyOptionalList<mir.ExpressionNode>> {\n    return new ResultArray(nodes.map((e) => VISIT_EXPRS.visit(e, state))).toOptionalList();\n  }\n\n  /**\n   * Normalize paths into `hir.Path` or a `hir.Expr` that corresponds to the ref.\n   *\n   * TODO since keywords don't support tails anyway, distinguish PathExpression from\n   * VariableReference in ASTv2.\n   */\n  PathExpression(path: ASTv2.PathExpression): Result<mir.ExpressionNode> {\n    let ref = this.VariableReference(path.ref);\n    let { tail } = path;\n\n    if (isPresent(tail)) {\n      let tailLoc = tail[0].loc.extend(tail[tail.length - 1].loc);\n      return Ok(\n        new mir.PathExpression({\n          loc: path.loc,\n          head: ref,\n          tail: new mir.Tail({ loc: tailLoc, members: tail }),\n        })\n      );\n    } else {\n      return Ok(ref);\n    }\n  }\n\n  VariableReference(ref: ASTv2.VariableReference): ASTv2.VariableReference {\n    return ref;\n  }\n\n  Literal(literal: ASTv2.LiteralExpression): ASTv2.LiteralExpression {\n    return literal;\n  }\n\n  Interpolate(\n    expr: ASTv2.InterpolateExpression,\n    state: NormalizationState\n  ): Result<mir.InterpolateExpression> {\n    let parts = expr.parts.map(convertPathToCallIfKeyword) as PresentArray<ASTv2.ExpressionNode>;\n\n    return VISIT_EXPRS.visitList(parts, state).mapOk(\n      (parts) => new mir.InterpolateExpression({ loc: expr.loc, parts: parts })\n    );\n  }\n\n  CallExpression(\n    expr: ASTv2.CallExpression,\n    state: NormalizationState\n  ): Result<mir.ExpressionNode> {\n    if (!hasPath(expr)) {\n      throw new Error(`unimplemented subexpression at the head of a subexpression`);\n    } else {\n      return Result.all(\n        VISIT_EXPRS.visit(expr.callee, state),\n        VISIT_EXPRS.Args(expr.args, state)\n      ).mapOk(\n        ([callee, args]) =>\n          new mir.CallExpression({\n            loc: expr.loc,\n            callee,\n            args,\n          })\n      );\n    }\n  }\n\n  DeprecaedCallExpression(\n    { arg, callee, loc }: ASTv2.DeprecatedCallExpression,\n    _state: NormalizationState\n  ): Result<mir.ExpressionNode> {\n    return Ok(new mir.DeprecatedCallExpression({ loc, arg, callee }));\n  }\n\n  Args({ positional, named, loc }: ASTv2.Args, state: NormalizationState): Result<mir.Args> {\n    return Result.all(this.Positional(positional, state), this.NamedArguments(named, state)).mapOk(\n      ([positional, named]) =>\n        new mir.Args({\n          loc,\n          positional,\n          named,\n        })\n    );\n  }\n\n  Positional(\n    positional: ASTv2.PositionalArguments,\n    state: NormalizationState\n  ): Result<mir.Positional> {\n    return VISIT_EXPRS.visitList(positional.exprs, state).mapOk(\n      (list) =>\n        new mir.Positional({\n          loc: positional.loc,\n          list,\n        })\n    );\n  }\n\n  NamedArguments(\n    named: ASTv2.NamedArguments,\n    state: NormalizationState\n  ): Result<mir.NamedArguments> {\n    let pairs = named.entries.map((arg) => {\n      let value = convertPathToCallIfKeyword(arg.value);\n\n      return VISIT_EXPRS.visit(value, state).mapOk(\n        (value) =>\n          new mir.NamedArgument({\n            loc: arg.loc,\n            key: arg.name,\n            value,\n          })\n      );\n    });\n\n    return new ResultArray(pairs)\n      .toOptionalList()\n      .mapOk((pairs) => new mir.NamedArguments({ loc: named.loc, entries: pairs }));\n  }\n}\n\nexport function convertPathToCallIfKeyword(path: ASTv2.ExpressionNode): ASTv2.ExpressionNode {\n  if (path.type === 'Path' && path.ref.type === 'Free' && path.ref.name in KEYWORDS_TYPES) {\n    return new ASTv2.CallExpression({\n      callee: path,\n      args: ASTv2.Args.empty(path.loc),\n      loc: path.loc,\n    });\n  }\n\n  return path;\n}\n\nexport const VISIT_EXPRS = new NormalizeExpressions();\n"],"sourceRoot":""}