@glimmer/compiler
Version:
171 lines (150 loc) • 18.3 kB
JavaScript
import { ASTv2, KEYWORDS_TYPES } from '@glimmer/syntax';
import { isPresent } from '@glimmer/util';
import { Ok, Result, ResultArray } from '../../../shared/result';
import * as mir from '../../2-encoding/mir';
import { CALL_KEYWORDS } from '../keywords';
import { hasPath } from '../utils/is-node';
export var NormalizeExpressions = /*#__PURE__*/function () {
function NormalizeExpressions() {}
var _proto = NormalizeExpressions.prototype;
_proto.visit = function visit(node, state) {
switch (node.type) {
case 'Literal':
return Ok(this.Literal(node));
case 'Interpolate':
return this.Interpolate(node, state);
case 'Path':
return this.PathExpression(node);
case 'Call':
var translated = CALL_KEYWORDS.translate(node, state);
if (translated !== null) {
return translated;
}
return this.CallExpression(node, state);
case 'DeprecatedCall':
return this.DeprecaedCallExpression(node, state);
}
};
_proto.visitList = function visitList(nodes, state) {
return new ResultArray(nodes.map(function (e) {
return 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.
*/
;
_proto.PathExpression = function PathExpression(path) {
var ref = this.VariableReference(path.ref);
var tail = path.tail;
if (isPresent(tail)) {
var tailLoc = tail[0].loc.extend(tail[tail.length - 1].loc);
return Ok(new mir.PathExpression({
loc: path.loc,
head: ref,
tail: new mir.Tail({
loc: tailLoc,
members: tail
})
}));
} else {
return Ok(ref);
}
};
_proto.VariableReference = function VariableReference(ref) {
return ref;
};
_proto.Literal = function Literal(literal) {
return literal;
};
_proto.Interpolate = function Interpolate(expr, state) {
var parts = expr.parts.map(convertPathToCallIfKeyword);
return VISIT_EXPRS.visitList(parts, state).mapOk(function (parts) {
return new mir.InterpolateExpression({
loc: expr.loc,
parts: parts
});
});
};
_proto.CallExpression = function CallExpression(expr, state) {
if (!hasPath(expr)) {
throw new Error("unimplemented subexpression at the head of a subexpression");
} else {
return Result.all(VISIT_EXPRS.visit(expr.callee, state), VISIT_EXPRS.Args(expr.args, state)).mapOk(function (_ref) {
var callee = _ref[0],
args = _ref[1];
return new mir.CallExpression({
loc: expr.loc,
callee: callee,
args: args
});
});
}
};
_proto.DeprecaedCallExpression = function DeprecaedCallExpression(_ref2, _state) {
var arg = _ref2.arg,
callee = _ref2.callee,
loc = _ref2.loc;
return Ok(new mir.DeprecatedCallExpression({
loc: loc,
arg: arg,
callee: callee
}));
};
_proto.Args = function Args(_ref3, state) {
var positional = _ref3.positional,
named = _ref3.named,
loc = _ref3.loc;
return Result.all(this.Positional(positional, state), this.NamedArguments(named, state)).mapOk(function (_ref4) {
var positional = _ref4[0],
named = _ref4[1];
return new mir.Args({
loc: loc,
positional: positional,
named: named
});
});
};
_proto.Positional = function Positional(positional, state) {
return VISIT_EXPRS.visitList(positional.exprs, state).mapOk(function (list) {
return new mir.Positional({
loc: positional.loc,
list: list
});
});
};
_proto.NamedArguments = function NamedArguments(named, state) {
var pairs = named.entries.map(function (arg) {
var value = convertPathToCallIfKeyword(arg.value);
return VISIT_EXPRS.visit(value, state).mapOk(function (value) {
return new mir.NamedArgument({
loc: arg.loc,
key: arg.name,
value: value
});
});
});
return new ResultArray(pairs).toOptionalList().mapOk(function (pairs) {
return new mir.NamedArguments({
loc: named.loc,
entries: pairs
});
});
};
return NormalizeExpressions;
}();
export function convertPathToCallIfKeyword(path) {
if (path.type === 'Path' && path.ref.type === 'Free' && path.ref.name in KEYWORDS_TYPES) {
return new ASTv2.CallExpression({
callee: path,
args: ASTv2.Args.empty(path.loc),
loc: path.loc
});
}
return path;
}
export var VISIT_EXPRS = new NormalizeExpressions();
//# 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":""}