From fc86247f7e2972e42e519db6d956fca0830aba74 Mon Sep 17 00:00:00 2001 From: Bei Zhang - Ikarienator Date: Fri, 12 Dec 2014 23:26:06 -0800 Subject: [PATCH] initial commit --- .gitignore | 5 + LICENSE | 202 ++++++++++++ README.md | 54 ++++ lib/index.js | 756 ++++++++++++++++++++++++++++++++++++++++++++ lib/token_stream.js | 61 ++++ package.json | 51 +++ src/index.js | 700 ++++++++++++++++++++++++++++++++++++++++ src/token_stream.js | 73 +++++ test/simple.js | 440 ++++++++++++++++++++++++++ 9 files changed, 2342 insertions(+) create mode 100644 .gitignore create mode 100644 LICENSE create mode 100644 README.md create mode 100644 lib/index.js create mode 100644 lib/token_stream.js create mode 100644 package.json create mode 100644 src/index.js create mode 100644 src/token_stream.js create mode 100644 test/simple.js diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..bf207ce --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +.idea +*.iml +node_modules/ +coverage/ +shift-codegen.js diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d645695 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md new file mode 100644 index 0000000..821b67a --- /dev/null +++ b/README.md @@ -0,0 +1,54 @@ +Shift Code Generator +==================== + +## About + +This module provides a code generator for [Shift format](https://github.com/shapesecurity/shift-spec) ASTs. + +## Status + +[Stable](http://nodejs.org/api/documentation.html#documentation_stability_index). + + +## Installation + +```sh +npm install shift-codegen +``` + + +## Usage + +```js +import codegen from "shift-codegen" +let programSource = codegen(/* Shift format AST */); +``` + + +## Contributing + +* Open a Github issue with a description of your desired change. If one exists already, leave a message stating that you are working on it with the date you expect it to be complete. +* Fork this repo, and clone the forked repo. +* Install dependencies with `npm install`. +* Build and test in your environment with `npm run build && npm test`. +* Create a feature branch. Make your changes. Add tests. +* Build and test in your environment with `npm run build && npm test`. +* Make a commit that includes the text "fixes #*XX*" where *XX* is the Github issue. +* Open a Pull Request on Github. + + +## License + + Copyright 2014 Shape Security, Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/lib/index.js b/lib/index.js new file mode 100644 index 0000000..51d797c --- /dev/null +++ b/lib/index.js @@ -0,0 +1,756 @@ +"use strict"; + +var _slice = Array.prototype.slice; +var _toArray = function (arr) { + return Array.isArray(arr) ? arr : Array.from(arr); +}; + +var _extends = function (child, parent) { + child.prototype = Object.create(parent.prototype, { + constructor: { + value: child, + enumerable: false, + writable: true, + configurable: true + } + }); + child.__proto__ = parent; +}; + +var reduce = require("shift-reducer")["default"]; +var objectAssign = require("object-assign"); + +var TokenStream = require("./token_stream").TokenStream; +function codeGen(script) { + var ts = new TokenStream(); + var rep = reduce(INSTANCE, script); + rep.emit(ts); + return ts.result; +} + +exports["default"] = codeGen; +var Precedence = { + Sequence: 0, + Yield: 1, + Assignment: 1, + Conditional: 2, + ArrowFunction: 2, + LogicalOR: 3, + LogicalAND: 4, + BitwiseOR: 5, + BitwiseXOR: 6, + BitwiseAND: 7, + Equality: 8, + Relational: 9, + BitwiseSHIFT: 10, + Additive: 11, + Multiplicative: 12, + Prefix: 13, + Postfix: 14, + New: 15, + Call: 16, + TaggedTemplate: 17, + Member: 18, + Primary: 19 +}; + +var BinaryPrecedence = { + ",": Precedence.Sequence, + "||": Precedence.LogicalOR, + "&&": Precedence.LogicalAND, + "|": Precedence.BitwiseOR, + "^": Precedence.BitwiseXOR, + "&": Precedence.BitwiseAND, + "==": Precedence.Equality, + "!=": Precedence.Equality, + "===": Precedence.Equality, + "!==": Precedence.Equality, + "<": Precedence.Relational, + ">": Precedence.Relational, + "<=": Precedence.Relational, + ">=": Precedence.Relational, + "in": Precedence.Relational, + "instanceof": Precedence.Relational, + "<<": Precedence.BitwiseSHIFT, + ">>": Precedence.BitwiseSHIFT, + ">>>": Precedence.BitwiseSHIFT, + "+": Precedence.Additive, + "-": Precedence.Additive, + "*": Precedence.Multiplicative, + "%": Precedence.Multiplicative, + "/": Precedence.Multiplicative +}; + +function getPrecedence(node) { + switch (node.type) { + case "ArrayExpression": + case "FunctionExpression": + case "IdentifierExpression": + case "LiteralBooleanExpression": + case "LiteralNullExpression": + case "LiteralNumericExpression": + case "LiteralRegExpExpression": + case "LiteralStringExpression": + case "ObjectExpression": + return Precedence.Primary; + + case "AssignmentExpression": + return Precedence.Assignment; + + case "ConditionalExpression": + return Precedence.Conditional; + + case "ComputedMemberExpression": + case "StaticMemberExpression": + switch (node.object.type) { + case "CallExpression": + case "ComputedMemberExpression": + case "StaticMemberExpression": + return getPrecedence(node.object); + default: + return Precedence.Member; + } + + case "BinaryExpression": + return BinaryPrecedence[node.operator]; + + case "CallExpression": + return Precedence.Call; + case "NewExpression": + return node.arguments.length === 0 ? Precedence.New : Precedence.Member; + case "PostfixExpression": + return Precedence.Postfix; + case "PrefixExpression": + return Precedence.Prefix; + } +} + +function escapeStringLiteral(stringValue) { + var result = ""; + result += ("\""); + for (var i = 0; i < stringValue.length; i++) { + var ch = stringValue.charAt(i); + switch (ch) { + case "\b": + result += "\\b"; + break; + case "\t": + result += "\\t"; + break; + case "\n": + result += "\\n"; + break; + case "\u000b": + result += "\\v"; + break; + case "\f": + result += "\\f"; + break; + case "\r": + result += "\\r"; + break; + case "\"": + result += "\\\""; + break; + case "\\": + result += "\\\\"; + break; + case "\u2028": + result += "\\u2028"; + break; + case "\u2029": + result += "\\u2029"; + break; + default: + result += ch; + break; + } + } + result += "\""; + return result.toString(); +} + +function p(node, precedence, a) { + return getPrecedence(node) < precedence ? paren(a) : a; +} + +var CodeRep = (function () { + var CodeRep = function CodeRep() { + this.containsIn = false; + this.containsGroup = false; + this.startsWithFunctionOrCurly = false; + this.endsWithMissingElse = false; + }; + + CodeRep.prototype.emit = function (stream, noIn) { + throw new Error("Not implemented"); + }; + + return CodeRep; +})(); + +var Empty = (function (CodeRep) { + var Empty = function Empty() { + CodeRep.apply(this, arguments); + }; + + _extends(Empty, CodeRep); + + Empty.prototype.emit = function () {}; + + return Empty; +})(CodeRep); + +var Token = (function (CodeRep) { + var Token = function Token(token) { + CodeRep.call(this); + this.token = token; + }; + + _extends(Token, CodeRep); + + Token.prototype.emit = function (ts) { + ts.put(this.token); + }; + + return Token; +})(CodeRep); + +var NumberCodeRep = (function (CodeRep) { + var NumberCodeRep = function NumberCodeRep(number) { + CodeRep.call(this); + this.number = number; + }; + + _extends(NumberCodeRep, CodeRep); + + NumberCodeRep.prototype.emit = function (ts) { + ts.putNumber(this.number); + }; + + return NumberCodeRep; +})(CodeRep); + +var Paren = (function (CodeRep) { + var Paren = function Paren(expr) { + CodeRep.call(this); + this.expr = expr; + }; + + _extends(Paren, CodeRep); + + Paren.prototype.emit = function (ts) { + ts.put("("); + this.expr.emit(ts, false); + ts.put(")"); + }; + + return Paren; +})(CodeRep); + +var Bracket = (function (CodeRep) { + var Bracket = function Bracket(expr) { + CodeRep.call(this); + this.expr = expr; + }; + + _extends(Bracket, CodeRep); + + Bracket.prototype.emit = function (ts) { + ts.put("["); + this.expr.emit(ts, false); + ts.put("]"); + }; + + return Bracket; +})(CodeRep); + +var Brace = (function (CodeRep) { + var Brace = function Brace(expr) { + CodeRep.call(this); + this.expr = expr; + }; + + _extends(Brace, CodeRep); + + Brace.prototype.emit = function (ts) { + ts.put("{"); + this.expr.emit(ts, false); + ts.put("}"); + }; + + return Brace; +})(CodeRep); + +var NoIn = (function (CodeRep) { + var NoIn = function NoIn(expr) { + CodeRep.call(this); + this.expr = expr; + }; + + _extends(NoIn, CodeRep); + + NoIn.prototype.emit = function (ts) { + this.expr.emit(ts, true); + }; + + return NoIn; +})(CodeRep); + +var ContainsIn = (function (CodeRep) { + var ContainsIn = function ContainsIn(expr) { + CodeRep.call(this); + this.expr = expr; + }; + + _extends(ContainsIn, CodeRep); + + ContainsIn.prototype.emit = function (ts, noIn) { + if (noIn) { + ts.put("("); + this.expr.emit(ts, false); + ts.put(")"); + } else { + this.expr.emit(ts, false); + } + }; + + return ContainsIn; +})(CodeRep); + +var Seq = (function (CodeRep) { + var Seq = function Seq(children) { + CodeRep.call(this); + this.children = children; + }; + + _extends(Seq, CodeRep); + + Seq.prototype.emit = function (ts, noIn) { + this.children.forEach(function (cr) { + return cr.emit(ts, noIn); + }); + }; + + return Seq; +})(CodeRep); + +var Semi = (function (Token) { + var Semi = function Semi() { + Token.call(this, ";"); + }; + + _extends(Semi, Token); + + return Semi; +})(Token); + +var CommaSep = (function (CodeRep) { + var CommaSep = function CommaSep(children) { + CodeRep.call(this); + this.children = children; + }; + + _extends(CommaSep, CodeRep); + + CommaSep.prototype.emit = function (ts, noIn) { + var first = true; + this.children.forEach(function (cr) { + if (first) { + first = false; + } else { + ts.put(","); + } + cr.emit(ts, noIn); + }); + }; + + return CommaSep; +})(CodeRep); + +var SemiOp = (function (CodeRep) { + var SemiOp = function SemiOp() { + CodeRep.apply(this, arguments); + }; + + _extends(SemiOp, CodeRep); + + SemiOp.prototype.emit = function (ts) { + ts.putOptionalSemi(); + }; + + return SemiOp; +})(CodeRep); + +var Init = (function (CodeRep) { + var Init = function Init(binding, init) { + CodeRep.call(this); + this.binding = binding; + this.init = init; + }; + + _extends(Init, CodeRep); + + Init.prototype.emit = function (ts, noIn) { + this.binding.emit(ts); + if (this.init != null) { + ts.put("="); + this.init.emit(ts, noIn); + } + }; + + return Init; +})(CodeRep); + +function t(token) { + return new Token(token); +} + +function paren(rep) { + return new Paren(rep); +} + +function bracket(rep) { + return new Bracket(rep); +} + +function noIn(rep) { + return new NoIn(rep); +} + +function markContainsIn(state) { + return state.containsIn ? new ContainsIn(state) : state; +} + +function seq() { + var reps = _slice.call(arguments); + + return new Seq(reps); +} + +function semi() { + return new Semi(); +} + +function empty() { + return new Empty(); +} + +function commaSep(pieces) { + return new CommaSep(pieces); +} + +function brace(rep) { + return new Brace(rep); +} + +function semiOp() { + return new SemiOp(); +} + +function parenToAvoidBeingDirective(element, original) { + if (element && element.type === "ExpressionStatement" && element.expression.type === "LiteralStringExpression") { + return seq(paren(original.children[0]), semiOp()); + } + return original; +} + +function getAssignmentExpr(state) { + return state ? (state.containsGroup ? paren(state) : state) : empty(); +} + +var CodeGen = (function () { + var CodeGen = function CodeGen() {}; + + CodeGen.prototype.reduceScript = function (node, body) { + return body; + }; + + CodeGen.prototype.reduceIdentifier = function (node) { + return t(node.name); + }; + + CodeGen.prototype.reduceIdentifierExpression = function (node, name) { + return name; + }; + + CodeGen.prototype.reduceThisExpression = function (node) { + return t("this"); + }; + + CodeGen.prototype.reduceLiteralBooleanExpression = function (node) { + return t(node.value.toString()); + }; + + CodeGen.prototype.reduceLiteralStringExpression = function (node) { + return t(escapeStringLiteral(node.value)); + }; + + CodeGen.prototype.reduceLiteralRegExpExpression = function (node) { + return t(node.value); + }; + + CodeGen.prototype.reduceLiteralNumericExpression = function (node) { + return new NumberCodeRep(node.value); + }; + + CodeGen.prototype.reduceLiteralNullExpression = function (node) { + return t("null"); + }; + + CodeGen.prototype.reduceFunctionExpression = function (node, id, params, body) { + var argBody = seq(paren(commaSep(params)), brace(body)); + var state = seq(t("function"), id ? seq(id, argBody) : argBody); + state.startsWithFunctionOrCurly = true; + return state; + }; + + CodeGen.prototype.reduceStaticMemberExpression = function (node, object, property) { + var state = seq(p(node.object, getPrecedence(node), object), t("."), property); + state.startsWithFunctionOrCurly = object.startsWithFunctionOrCurly; + return state; + }; + + CodeGen.prototype.reduceComputedMemberExpression = function (node, object, expression) { + return objectAssign(seq(p(node.object, getPrecedence(node), object), bracket(expression)), { startsWithFunctionOrCurly: object.startsWithFunctionOrCurly }); + }; + + CodeGen.prototype.reduceObjectExpression = function (node, properties) { + var state = brace(commaSep(properties)); + state.startsWithFunctionOrCurly = true; + return state; + }; + + CodeGen.prototype.reduceBinaryExpression = function (node, left, right) { + var leftCode = left; + var startsWithFunctionOrCurly = left.startsWithFunctionOrCurly; + var leftContainsIn = left.containsIn; + if (getPrecedence(node.left) < getPrecedence(node)) { + leftCode = paren(leftCode); + startsWithFunctionOrCurly = false; + leftContainsIn = false; + } + var rightCode = right; + var rightContainsIn = right.containsIn; + if (getPrecedence(node.right) <= getPrecedence(node)) { + rightCode = paren(rightCode); + rightContainsIn = false; + } + + return objectAssign(seq(leftCode, t(node.operator), rightCode), { + containsIn: leftContainsIn || rightContainsIn || node.operator === "in", + containsGroup: node.operator == ",", + startsWithFunctionOrCurly: startsWithFunctionOrCurly + }); + }; + + CodeGen.prototype.reduceAssignmentExpression = function (node, binding, expression) { + var rightCode = expression; + var containsIn = expression.containsIn; + var startsWithFunctionOrCurly = binding.startsWithFunctionOrCurly; + if (getPrecedence(node.expression) < getPrecedence(node)) { + rightCode = paren(rightCode); + containsIn = false; + } + return objectAssign(seq(binding, t(node.operator), rightCode), { containsIn: containsIn, startsWithFunctionOrCurly: startsWithFunctionOrCurly }); + }; + + CodeGen.prototype.reduceArrayExpression = function (node, elements) { + if (elements.length === 0) { + return bracket(empty()); + } + + var content = commaSep(elements.map(getAssignmentExpr)); + if (elements.length > 0 && elements[elements.length - 1] == null) { + content = seq(content, t(",")); + } + return bracket(content); + }; + + CodeGen.prototype.reduceNewExpression = function (node, callee, args) { + var calleeRep = getPrecedence(node.callee) == Precedence.Call ? paren(callee) : p(node.callee, getPrecedence(node), callee); + return seq(t("new"), calleeRep, args.length === 0 ? empty() : paren(commaSep(args))); + }; + + CodeGen.prototype.reduceCallExpression = function (node, callee, args) { + return objectAssign(seq(p(node.callee, getPrecedence(node), callee), paren(commaSep(args))), { startsWithFunctionOrCurly: callee.startsWithFunctionOrCurly }); + }; + + CodeGen.prototype.reducePostfixExpression = function (node, operand) { + return objectAssign(seq(p(node.operand, getPrecedence(node), operand), t(node.operator)), { startsWithFunctionOrCurly: operand.startsWithFunctionOrCurly }); + }; + + CodeGen.prototype.reducePrefixExpression = function (node, operand) { + return seq(t(node.operator), p(node.operand, getPrecedence(node), operand)); + }; + + CodeGen.prototype.reduceConditionalExpression = function (node, test, consequent, alternate) { + var containsIn = test.containsIn || alternate.containsIn; + var startsWithFunctionOrCurly = test.startsWithFunctionOrCurly; + return objectAssign(seq(p(node.test, Precedence.LogicalOR, test), t("?"), p(node.consequent, Precedence.Assignment, consequent), t(":"), p(node.alternate, Precedence.Assignment, alternate)), { + containsIn: containsIn, + startsWithFunctionOrCurly: startsWithFunctionOrCurly + }); + }; + + CodeGen.prototype.reduceFunctionDeclaration = function (node, id, params, body) { + return seq(t("function"), id, paren(commaSep(params)), brace(body)); + }; + + CodeGen.prototype.reduceUseStrictDirective = function (node) { + return seq(t("\"use strict\""), semiOp()); + }; + + CodeGen.prototype.reduceUnknownDirective = function (node) { + var name = "use strict" === node.value ? "use\\u0020strict" : node.value; + return seq(t("\"" + name + "\""), semiOp()); + }; + + CodeGen.prototype.reduceBlockStatement = function (node, block) { + return block; + }; + + CodeGen.prototype.reduceBreakStatement = function (node, label) { + return seq(t("break"), label || empty(), semiOp()); + }; + + CodeGen.prototype.reduceCatchClause = function (node, param, body) { + return seq(t("catch"), paren(param), body); + }; + + CodeGen.prototype.reduceContinueStatement = function (node, label) { + return seq(t("continue"), label || empty(), semiOp()); + }; + + CodeGen.prototype.reduceDebuggerStatement = function (node) { + return seq(t("debugger"), semiOp()); + }; + + CodeGen.prototype.reduceDoWhileStatement = function (node, body, test) { + return seq(t("do"), body, t("while"), paren(test), semiOp()); + }; + + CodeGen.prototype.reduceEmptyStatement = function (node) { + return semi(); + }; + + CodeGen.prototype.reduceExpressionStatement = function (node, expression) { + return seq((expression.startsWithFunctionOrCurly ? paren(expression) : expression), semiOp()); + }; + + CodeGen.prototype.reduceForInStatement = function (node, left, right, body) { + return objectAssign(seq(t("for"), paren(seq(noIn(markContainsIn(left)), t("in"), right)), body), { endsWithMissingElse: body.endsWithMissingElse }); + }; + + CodeGen.prototype.reduceForStatement = function (node, init, test, update, body) { + return objectAssign(seq(t("for"), paren(seq(init ? noIn(markContainsIn(init)) : empty(), semi(), test || empty(), semi(), update || empty())), body), { + endsWithMissingElse: body.endsWithMissingElse + }); + }; + + CodeGen.prototype.reduceIfStatement = function (node, test, consequent, alternate) { + if (alternate && consequent.endsWithMissingElse) { + consequent = brace(consequent); + } + return objectAssign(seq(t("if"), paren(test), consequent, alternate ? seq(t("else"), alternate) : empty()), { endsWithMissingElse: alternate ? alternate.endsWithMissingElse : true }); + }; + + CodeGen.prototype.reduceLabeledStatement = function (node, label, body) { + return objectAssign(seq(label, t(":"), body), { endsWithMissingElse: body.endsWithMissingElse }); + }; + + CodeGen.prototype.reduceReturnStatement = function (node, argument) { + return seq(t("return"), argument || empty(), semiOp()); + }; + + CodeGen.prototype.reduceSwitchCase = function (node, test, consequent) { + return seq(t("case"), test, t(":"), seq.apply(null, _toArray(consequent))); + }; + + CodeGen.prototype.reduceSwitchDefault = function (node, consequent) { + return seq(t("default"), t(":"), seq.apply(null, _toArray(consequent))); + }; + + CodeGen.prototype.reduceSwitchStatement = function (node, discriminant, cases) { + return seq(t("switch"), paren(discriminant), brace(seq.apply(null, _toArray(cases)))); + }; + + CodeGen.prototype.reduceSwitchStatementWithDefault = function (node, discriminant, cases, defaultCase, postDefaultCases) { + return seq(t("switch"), paren(discriminant), brace(seq.apply(null, _toArray(cases).concat([defaultCase], _toArray(postDefaultCases))))); + }; + + CodeGen.prototype.reduceThrowStatement = function (node, argument) { + return seq(t("throw"), argument, semiOp()); + }; + + CodeGen.prototype.reduceTryCatchStatement = function (node, block, catchClause) { + return seq(t("try"), block, catchClause); + }; + + CodeGen.prototype.reduceTryFinallyStatement = function (node, block, catchClause, finalizer) { + return seq(t("try"), block, catchClause || empty(), t("finally"), finalizer); + }; + + CodeGen.prototype.reduceVariableDeclarationStatement = function (node, declaration) { + return seq(declaration, semiOp()); + }; + + CodeGen.prototype.reduceVariableDeclaration = function (node, declarators) { + return seq(t(node.kind), commaSep(declarators)); + }; + + CodeGen.prototype.reduceWhileStatement = function (node, test, body) { + return objectAssign(seq(t("while"), paren(test), body), { endsWithMissingElse: body.endsWithMissingElse }); + }; + + CodeGen.prototype.reduceWithStatement = function (node, object, body) { + return objectAssign(seq(t("with"), paren(object), body), { endsWithMissingElse: body.endsWithMissingElse }); + }; + + CodeGen.prototype.reduceDataProperty = function (node, key, value) { + return seq(key, t(":"), getAssignmentExpr(value)); + }; + + CodeGen.prototype.reduceGetter = function (node, key, body) { + return seq(t("get"), key, paren(empty()), brace(body)); + }; + + CodeGen.prototype.reduceSetter = function (node, key, parameter, body) { + return seq(t("set"), key, paren(parameter), brace(body)); + }; + + CodeGen.prototype.reducePropertyName = function (node) { + if (node.kind == "number" || node.kind == "identifier") { + return t(node.value.toString()); + } + return t(Utils.escapeStringLiteral(node.value)); + }; + + CodeGen.prototype.reduceFunctionBody = function (node, directives, sourceElements) { + if (sourceElements.length) { + sourceElements[0] = parenToAvoidBeingDirective(node.statements[0], sourceElements[0]); + } + return seq.apply(null, _toArray(directives).concat(_toArray(sourceElements))); + }; + + CodeGen.prototype.reduceVariableDeclarator = function (node, id, init) { + var containsIn = init && init.containsIn && !init.containsGroup; + if (init) { + if (init.containsGroup) { + init = paren(init); + } else { + init = markContainsIn(init); + } + } + return objectAssign(new Init(id, init), { containsIn: containsIn }); + }; + + CodeGen.prototype.reduceBlock = function (node, statements) { + return brace(seq.apply(null, _toArray(statements))); + }; + + return CodeGen; +})(); + +var INSTANCE = new CodeGen(); +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/index.js"],"names":[],"mappings":"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","file":"src/index.js","sourcesContent":["import reduce from \"shift-reducer\";\nimport * as objectAssign from \"object-assign\";\nimport {TokenStream} from \"./token_stream\";\n\nexport default function codeGen(script) {\n  let ts = new TokenStream();\n  let rep = reduce(INSTANCE, script);\n  rep.emit(ts);\n  return ts.result;\n}\n\nconst Precedence = {\n  Sequence: 0,\n  Yield: 1,\n  Assignment: 1,\n  Conditional: 2,\n  ArrowFunction: 2,\n  LogicalOR: 3,\n  LogicalAND: 4,\n  BitwiseOR: 5,\n  BitwiseXOR: 6,\n  BitwiseAND: 7,\n  Equality: 8,\n  Relational: 9,\n  BitwiseSHIFT: 10,\n  Additive: 11,\n  Multiplicative: 12,\n  Prefix: 13,\n  Postfix: 14,\n  New: 15,\n  Call: 16,\n  TaggedTemplate: 17,\n  Member: 18,\n  Primary: 19\n};\n\nconst BinaryPrecedence = {\n  \",\": Precedence.Sequence,\n  \"||\": Precedence.LogicalOR,\n  \"&&\": Precedence.LogicalAND,\n  \"|\": Precedence.BitwiseOR,\n  \"^\": Precedence.BitwiseXOR,\n  \"&\": Precedence.BitwiseAND,\n  \"==\": Precedence.Equality,\n  \"!=\": Precedence.Equality,\n  \"===\": Precedence.Equality,\n  \"!==\": Precedence.Equality,\n  \"<\": Precedence.Relational,\n  \">\": Precedence.Relational,\n  \"<=\": Precedence.Relational,\n  \">=\": Precedence.Relational,\n  \"in\": Precedence.Relational,\n  \"instanceof\": Precedence.Relational,\n  \"<<\": Precedence.BitwiseSHIFT,\n  \">>\": Precedence.BitwiseSHIFT,\n  \">>>\": Precedence.BitwiseSHIFT,\n  \"+\": Precedence.Additive,\n  \"-\": Precedence.Additive,\n  \"*\": Precedence.Multiplicative,\n  \"%\": Precedence.Multiplicative,\n  \"/\": Precedence.Multiplicative\n};\n\nfunction getPrecedence(node) {\n  switch (node.type) {\n    case \"ArrayExpression\":\n    case \"FunctionExpression\":\n    case \"IdentifierExpression\":\n    case \"LiteralBooleanExpression\":\n    case \"LiteralNullExpression\":\n    case \"LiteralNumericExpression\":\n    case \"LiteralRegExpExpression\":\n    case \"LiteralStringExpression\":\n    case \"ObjectExpression\":\n      return Precedence.Primary;\n\n    case \"AssignmentExpression\":\n      return Precedence.Assignment;\n\n    case \"ConditionalExpression\":\n      return Precedence.Conditional;\n\n    case \"ComputedMemberExpression\":\n    case \"StaticMemberExpression\":\n      switch (node.object.type) {\n        case \"CallExpression\":\n        case \"ComputedMemberExpression\":\n        case \"StaticMemberExpression\":\n          return getPrecedence(node.object);\n        default:\n          return Precedence.Member;\n      }\n\n    case \"BinaryExpression\":\n      return BinaryPrecedence[node.operator];\n\n    case \"CallExpression\":\n      return Precedence.Call;\n    case \"NewExpression\":\n      return node.arguments.length === 0 ? Precedence.New : Precedence.Member;\n    case \"PostfixExpression\":\n      return Precedence.Postfix;\n    case \"PrefixExpression\":\n      return Precedence.Prefix;\n  }\n}\n\nfunction escapeStringLiteral(stringValue) {\n  let result = \"\";\n  result += ('\"');\n  for (let i = 0; i < stringValue.length; i++) {\n    let ch = stringValue.charAt(i);\n    switch (ch) {\n      case \"\\b\":\n        result += \"\\\\b\";\n        break;\n      case \"\\t\":\n        result += \"\\\\t\";\n        break;\n      case \"\\n\":\n        result += \"\\\\n\";\n        break;\n      case \"\\u000B\":\n        result += \"\\\\v\";\n        break;\n      case \"\\u000C\":\n        result += \"\\\\f\";\n        break;\n      case \"\\r\":\n        result += \"\\\\r\";\n        break;\n      case \"\\\"\":\n        result += \"\\\\\\\"\";\n        break;\n      case \"\\\\\":\n        result += \"\\\\\\\\\";\n        break;\n      case \"\\u2028\":\n        result += \"\\\\u2028\";\n        break;\n      case \"\\u2029\":\n        result += \"\\\\u2029\";\n        break;\n      default:\n        result += ch;\n        break;\n    }\n  }\n  result += '\"';\n  return result.toString();\n}\n\nfunction p(node, precedence, a) {\n  return getPrecedence(node) < precedence ? paren(a) : a;\n}\n\nclass CodeRep {\n  constructor() {\n    this.containsIn = false;\n    this.containsGroup = false;\n    this.startsWithFunctionOrCurly = false;\n    this.endsWithMissingElse = false;\n  }\n\n  emit(stream, noIn) {\n    throw new Error(\"Not implemented\");\n  }\n}\n\nclass Empty extends CodeRep {\n  emit() {\n  }\n}\n\nclass Token extends CodeRep {\n  constructor(token) {\n    super();\n    this.token = token;\n  }\n\n  emit(ts) {\n    ts.put(this.token);\n  }\n}\n\nclass NumberCodeRep extends CodeRep {\n  constructor(number) {\n    super();\n    this.number = number;\n  }\n\n  emit(ts) {\n    ts.putNumber(this.number);\n  }\n}\n\nclass Paren extends CodeRep {\n  constructor(expr) {\n    super();\n    this.expr = expr;\n  }\n\n  emit(ts) {\n    ts.put(\"(\");\n    this.expr.emit(ts, false);\n    ts.put(\")\");\n  }\n}\n\nclass Bracket extends CodeRep {\n  constructor(expr) {\n    super();\n    this.expr = expr;\n  }\n\n  emit(ts) {\n    ts.put(\"[\");\n    this.expr.emit(ts, false);\n    ts.put(\"]\");\n  }\n}\n\nclass Brace extends CodeRep {\n  constructor(expr) {\n    super();\n    this.expr = expr;\n  }\n\n  emit(ts) {\n    ts.put(\"{\");\n    this.expr.emit(ts, false);\n    ts.put(\"}\");\n  }\n}\n\nclass NoIn extends CodeRep {\n  constructor(expr) {\n    super();\n    this.expr = expr;\n  }\n\n  emit(ts) {\n    this.expr.emit(ts, true);\n  }\n}\n\nclass ContainsIn extends CodeRep {\n  constructor(expr) {\n    super();\n    this.expr = expr;\n  }\n\n  emit(ts, noIn) {\n    if (noIn) {\n      ts.put(\"(\");\n      this.expr.emit(ts, false);\n      ts.put(\")\");\n    } else {\n      this.expr.emit(ts, false);\n    }\n  }\n}\n\nclass Seq extends CodeRep {\n  constructor(children) {\n    super();\n    this.children = children;\n  }\n\n  emit(ts, noIn) {\n    this.children.forEach(cr => cr.emit(ts, noIn));\n  }\n}\n\nclass Semi extends Token {\n  constructor() {\n    super(\";\");\n  }\n}\n\nclass CommaSep extends CodeRep {\n  constructor(children) {\n    super();\n    this.children = children;\n  }\n\n  emit(ts, noIn) {\n    var first = true;\n    this.children.forEach(\n        (cr) => {\n          if (first) {\n            first = false;\n          } else {\n            ts.put(\",\");\n          }\n          cr.emit(ts, noIn);\n        });\n  }\n}\n\nclass SemiOp extends CodeRep {\n  emit(ts) {\n    ts.putOptionalSemi();\n  }\n}\n\nclass Init extends CodeRep {\n  constructor(binding, init) {\n    super();\n    this.binding = binding;\n    this.init = init;\n  }\n\n  emit(ts, noIn) {\n    this.binding.emit(ts);\n    if (this.init != null) {\n      ts.put(\"=\");\n      this.init.emit(ts, noIn);\n    }\n  }\n}\n\nfunction t(token) {\n  return new Token(token);\n}\n\nfunction paren(rep) {\n  return new Paren(rep);\n}\n\nfunction bracket(rep) {\n  return new Bracket(rep);\n}\n\nfunction noIn(rep) {\n  return new NoIn(rep);\n}\n\nfunction markContainsIn(state) {\n  return state.containsIn ? new ContainsIn(state) : state;\n}\n\nfunction seq(...reps) {\n  return new Seq(reps);\n}\n\nfunction semi() {\n  return new Semi();\n}\n\nfunction empty() {\n  return new Empty();\n}\n\nfunction commaSep(pieces) {\n  return new CommaSep(pieces);\n}\n\nfunction brace(rep) {\n  return new Brace(rep);\n}\n\nfunction semiOp() {\n  return new SemiOp();\n}\n\nfunction parenToAvoidBeingDirective(element, original) {\n  if (element && element.type === \"ExpressionStatement\" && element.expression.type === \"LiteralStringExpression\") {\n    return seq(paren(original.children[0]), semiOp());\n  }\n  return original;\n}\n\nfunction getAssignmentExpr(state) {\n  return state ? (state.containsGroup ? paren(state) : state) : empty();\n}\n\nclass CodeGen {\n\n  reduceScript(node, body) {\n    return body;\n  }\n\n  reduceIdentifier(node) {\n    return t(node.name);\n  }\n\n  reduceIdentifierExpression(node, name) {\n    return name;\n  }\n\n  reduceThisExpression(node) {\n    return t(\"this\");\n  }\n\n  reduceLiteralBooleanExpression(node) {\n    return t(node.value.toString());\n  }\n\n  reduceLiteralStringExpression(node) {\n    return t(escapeStringLiteral(node.value));\n  }\n\n  reduceLiteralRegExpExpression(node) {\n    return t(node.value);\n  }\n\n  reduceLiteralNumericExpression(node) {\n    return new NumberCodeRep(node.value);\n  }\n\n  reduceLiteralNullExpression(node) {\n    return t(\"null\");\n  }\n\n  reduceFunctionExpression(node, id, params, body) {\n    const argBody = seq(paren(commaSep(params)), brace(body));\n    let state = seq(t(\"function\"), id ? seq(id, argBody) : argBody);\n    state.startsWithFunctionOrCurly = true;\n    return state;\n  }\n\n  reduceStaticMemberExpression(node, object, property) {\n    const state = seq(p(node.object, getPrecedence(node), object), t(\".\"), property);\n    state.startsWithFunctionOrCurly = object.startsWithFunctionOrCurly;\n    return state;\n  }\n\n  reduceComputedMemberExpression(node, object, expression) {\n    return objectAssign(\n        seq(p(node.object, getPrecedence(node), object), bracket(expression)),\n        {startsWithFunctionOrCurly: object.startsWithFunctionOrCurly});\n  }\n\n  reduceObjectExpression(node, properties) {\n    let state = brace(commaSep(properties));\n    state.startsWithFunctionOrCurly = true;\n    return state;\n  }\n\n  reduceBinaryExpression(node, left, right) {\n    let leftCode = left;\n    let startsWithFunctionOrCurly = left.startsWithFunctionOrCurly;\n    let leftContainsIn = left.containsIn;\n    if (getPrecedence(node.left) < getPrecedence(node)) {\n      leftCode = paren(leftCode);\n      startsWithFunctionOrCurly = false;\n      leftContainsIn = false;\n    }\n    let rightCode = right;\n    let rightContainsIn = right.containsIn;\n    if (getPrecedence(node.right) <= getPrecedence(node)) {\n      rightCode = paren(rightCode);\n      rightContainsIn = false;\n    }\n\n    return objectAssign(\n        seq(leftCode, t(node.operator), rightCode),\n        {\n          containsIn: leftContainsIn || rightContainsIn || node.operator === \"in\",\n          containsGroup: node.operator == \",\",\n          startsWithFunctionOrCurly\n        });\n  }\n\n  reduceAssignmentExpression(node, binding, expression) {\n    let rightCode = expression;\n    let containsIn = expression.containsIn;\n    let startsWithFunctionOrCurly = binding.startsWithFunctionOrCurly;\n    if (getPrecedence(node.expression) < getPrecedence(node)) {\n      rightCode = paren(rightCode);\n      containsIn = false;\n    }\n    return objectAssign(seq(binding, t(node.operator), rightCode), {containsIn, startsWithFunctionOrCurly});\n  }\n\n  reduceArrayExpression(node, elements) {\n    if (elements.length === 0) {\n      return bracket(empty());\n    }\n\n    let content = commaSep(elements.map(getAssignmentExpr));\n    if (elements.length > 0 && elements[elements.length - 1] == null) {\n      content = seq(content, t(\",\"));\n    }\n    return bracket(content);\n  }\n\n  reduceNewExpression(node, callee, args) {\n    let calleeRep = getPrecedence(node.callee) == Precedence.Call ? paren(callee) :\n        p(node.callee, getPrecedence(node), callee);\n    return seq(t(\"new\"), calleeRep, args.length === 0 ? empty() : paren(commaSep(args)));\n  }\n\n  reduceCallExpression(node, callee, args) {\n    return objectAssign(\n        seq(p(node.callee, getPrecedence(node), callee), paren(commaSep(args))),\n        {startsWithFunctionOrCurly: callee.startsWithFunctionOrCurly});\n  }\n\n  reducePostfixExpression(node, operand) {\n    return objectAssign(\n        seq(p(node.operand, getPrecedence(node), operand), t(node.operator)),\n        {startsWithFunctionOrCurly: operand.startsWithFunctionOrCurly});\n  }\n\n  reducePrefixExpression(node, operand) {\n    return seq(t(node.operator), p(node.operand, getPrecedence(node), operand));\n  }\n\n  reduceConditionalExpression(node, test, consequent, alternate) {\n    let containsIn = test.containsIn || alternate.containsIn;\n    let startsWithFunctionOrCurly = test.startsWithFunctionOrCurly;\n    return objectAssign(\n        seq(\n            p(node.test, Precedence.LogicalOR, test), t(\"?\"),\n            p(node.consequent, Precedence.Assignment, consequent), t(\":\"),\n            p(node.alternate, Precedence.Assignment, alternate)), {\n          containsIn,\n          startsWithFunctionOrCurly\n        });\n  }\n\n  reduceFunctionDeclaration(node, id, params, body) {\n    return seq(t(\"function\"), id, paren(commaSep(params)), brace(body));\n  }\n\n  reduceUseStrictDirective(node) {\n    return seq(t(\"\\\"use strict\\\"\"), semiOp());\n  }\n\n  reduceUnknownDirective(node) {\n    var name = \"use strict\" === node.value ? \"use\\\\u0020strict\" : node.value;\n    return seq(t(\"\\\"\" + name + \"\\\"\"), semiOp());\n  }\n\n  reduceBlockStatement(node, block) {\n    return block;\n  }\n\n  reduceBreakStatement(node, label) {\n    return seq(t(\"break\"), label || empty(), semiOp());\n  }\n\n  reduceCatchClause(node, param, body) {\n    return seq(t(\"catch\"), paren(param), body);\n  }\n\n  reduceContinueStatement(node, label) {\n    return seq(t(\"continue\"), label || empty(), semiOp());\n  }\n\n  reduceDebuggerStatement(node) {\n    return seq(t(\"debugger\"), semiOp());\n  }\n\n  reduceDoWhileStatement(node, body, test) {\n    return seq(t(\"do\"), body, t(\"while\"), paren(test), semiOp());\n  }\n\n  reduceEmptyStatement(node) {\n    return semi();\n  }\n\n  reduceExpressionStatement(node, expression) {\n    return seq((expression.startsWithFunctionOrCurly ? paren(expression) : expression), semiOp());\n  }\n\n  reduceForInStatement(node, left, right, body) {\n    return objectAssign(\n        seq(t(\"for\"), paren(seq(noIn(markContainsIn(left)), t(\"in\"), right)), body),\n        {endsWithMissingElse: body.endsWithMissingElse});\n  }\n\n  reduceForStatement(node, init, test, update, body) {\n    return objectAssign(\n        seq(\n            t(\"for\"),\n            paren(seq(init ? noIn(markContainsIn(init)) : empty(), semi(), test || empty(), semi(), update || empty())),\n            body),\n        {\n          endsWithMissingElse: body.endsWithMissingElse\n        });\n  }\n\n  reduceIfStatement(node, test, consequent, alternate) {\n    if (alternate && consequent.endsWithMissingElse) {\n      consequent = brace(consequent);\n    }\n    return objectAssign(\n        seq(t(\"if\"), paren(test), consequent, alternate ? seq(t(\"else\"), alternate) : empty()),\n        {endsWithMissingElse: alternate ? alternate.endsWithMissingElse : true});\n  }\n\n  reduceLabeledStatement(node, label, body) {\n    return objectAssign(seq(label, t(\":\"), body), {endsWithMissingElse: body.endsWithMissingElse});\n  }\n\n  reduceReturnStatement(node, argument) {\n    return seq(t(\"return\"), argument || empty(), semiOp());\n  }\n\n  reduceSwitchCase(node, test, consequent) {\n    return seq(t(\"case\"), test, t(\":\"), seq(...consequent));\n  }\n\n  reduceSwitchDefault(node, consequent) {\n    return seq(t(\"default\"), t(\":\"), seq(...consequent));\n  }\n\n  reduceSwitchStatement(node, discriminant, cases) {\n    return seq(t(\"switch\"), paren(discriminant), brace(seq(...cases)));\n  }\n\n  reduceSwitchStatementWithDefault(node, discriminant, cases, defaultCase, postDefaultCases) {\n    return seq(\n        t(\"switch\"),\n        paren(discriminant),\n        brace(seq(...cases, defaultCase, ...postDefaultCases)));\n  }\n\n  reduceThrowStatement(node, argument) {\n    return seq(t(\"throw\"), argument, semiOp());\n  }\n\n  reduceTryCatchStatement(node, block, catchClause) {\n    return seq(t(\"try\"), block, catchClause);\n  }\n\n  reduceTryFinallyStatement(node, block, catchClause, finalizer) {\n    return seq(\n        t(\"try\"),\n        block,\n        catchClause || empty(),\n        t(\"finally\"),\n        finalizer);\n  }\n\n  reduceVariableDeclarationStatement(node, declaration) {\n    return seq(declaration, semiOp());\n  }\n\n  reduceVariableDeclaration(node, declarators) {\n    return seq(t(node.kind), commaSep(declarators));\n  }\n\n  reduceWhileStatement(node, test, body) {\n    return objectAssign(seq(t(\"while\"), paren(test), body), {endsWithMissingElse: body.endsWithMissingElse});\n  }\n\n  reduceWithStatement(node, object, body) {\n    return objectAssign(\n        seq(t(\"with\"), paren(object), body),\n        {endsWithMissingElse: body.endsWithMissingElse});\n  }\n\n  reduceDataProperty(node, key, value) {\n    return seq(key, t(\":\"), getAssignmentExpr(value));\n  }\n\n  reduceGetter(node, key, body) {\n    return seq(t(\"get\"), key, paren(empty()), brace(body));\n  }\n\n  reduceSetter(node, key, parameter, body) {\n    return seq(t(\"set\"), key, paren(parameter), brace(body));\n  }\n\n  reducePropertyName(node) {\n    if (node.kind == \"number\" || node.kind == \"identifier\") {\n      return t(node.value.toString());\n    }\n    return t(Utils.escapeStringLiteral(node.value));\n  }\n\n  reduceFunctionBody(node, directives, sourceElements) {\n    if (sourceElements.length) {\n      sourceElements[0] = parenToAvoidBeingDirective(node.statements[0], sourceElements[0]);\n    }\n    return seq(...directives, ...sourceElements);\n  }\n\n  reduceVariableDeclarator(node, id, init) {\n    let containsIn = init && init.containsIn && !init.containsGroup;\n    if (init) {\n      if (init.containsGroup) {\n        init = paren(init);\n      } else {\n        init = markContainsIn(init);\n      }\n    }\n    return objectAssign(new Init(id, init), {containsIn});\n  }\n\n  reduceBlock(node, statements) {\n    return brace(seq(...statements));\n  }\n}\n\nconst INSTANCE = new CodeGen;\n"]} \ No newline at end of file diff --git a/lib/token_stream.js b/lib/token_stream.js new file mode 100644 index 0000000..baf23af --- /dev/null +++ b/lib/token_stream.js @@ -0,0 +1,61 @@ +"use strict"; + +var code = require("esutils").code; + + +function numberDot(fragment) { + if (fragment.indexOf(".") < 0 && fragment.indexOf("e") < 0) { + return ".."; + } + return "."; +} + +var TokenStream = (function () { + var TokenStream = function TokenStream() { + this.result = ""; + this.lastNumber = null; + this.lastChar = null; + this.optionalSemi = false; + }; + + TokenStream.prototype.putNumber = function (number) { + var tokenStr = number.toString(); + this.put(tokenStr); + this.lastNumber = tokenStr; + }; + + TokenStream.prototype.putOptionalSemi = function () { + this.optionalSemi = true; + }; + + TokenStream.prototype.put = function (tokenStr) { + if (this.optionalSemi) { + this.optionalSemi = false; + if (tokenStr !== "}") { + this.put(";"); + } + } + if (this.lastNumber !== null && tokenStr.length == 1) { + if (tokenStr === ".") { + this.result += numberDot(this.lastNumber); + this.lastNumber = null; + this.lastChar = "."; + return; + } + } + this.lastNumber = null; + var rightChar = tokenStr.charAt(0); + var lastChar = this.lastChar; + this.lastChar = tokenStr.charAt(tokenStr.length - 1); + if (lastChar && ((lastChar == "+" || lastChar == "-") && lastChar == rightChar || code.isIdentifierPart(lastChar.charCodeAt(0)) && code.isIdentifierPart(rightChar.charCodeAt(0)) || lastChar == "/" && rightChar == "i")) { + this.result += " "; + } + + this.result += tokenStr; + }; + + return TokenStream; +})(); + +exports.TokenStream = TokenStream; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/package.json b/package.json new file mode 100644 index 0000000..7f03907 --- /dev/null +++ b/package.json @@ -0,0 +1,51 @@ +{ + "name": "shift-codegen", + "version": "1.0.0", + "description": "code generator for Shift format ASTs", + "author": "Shape Security Labs", + "homepage": "https://github.com/shapesecurity/shift-codegen-js", + "repository": { + "type": "git", + "url": "https://github.com/shapesecurity/shift-codegen-js.git" + }, + "main": "lib/index.js", + "files": [ + "lib" + ], + "scripts": { + "test": "npm run-script coverage", + "build": "6to5 --source-maps-inline --out-dir lib src", + "coverage": "istanbul cover node_modules/.bin/_mocha -- --inline-diffs --check-leaks --ui tdd --reporter dot test", + "cjsify": "cjsify --export ShiftCodegen lib/index.js > shift-codegen.js" + }, + "dependencies": { + "esutils": "^1.1.6", + "object-assign": "^2.0.0", + "shift-reducer": "^1.0.2" + }, + "devDependencies": { + "6to5": "^1.15.0", + "commonjs-everywhere": "^0.9.7", + "expect.js": "^0.3.1", + "istanbul": "^0.3.5", + "mocha": "^2.0.1", + "shift-ast": "^1.0.1", + "shift-parser": "^1.0.0" + }, + "keywords": [ + "Shift", + "AST", + "node", + "codegen", + "code", + "generator", + "unparser", + "abstract", + "syntax", + "tree" + ], + "bugs": { + "url": "https://github.com/shapesecurity/shift-codegen-js/issues" + }, + "license": "Apache-2.0" +} diff --git a/src/index.js b/src/index.js new file mode 100644 index 0000000..2b4f194 --- /dev/null +++ b/src/index.js @@ -0,0 +1,700 @@ +import reduce from "shift-reducer"; +import * as objectAssign from "object-assign"; +import {TokenStream} from "./token_stream"; + +export default function codeGen(script) { + let ts = new TokenStream(); + let rep = reduce(INSTANCE, script); + rep.emit(ts); + return ts.result; +} + +const Precedence = { + Sequence: 0, + Yield: 1, + Assignment: 1, + Conditional: 2, + ArrowFunction: 2, + LogicalOR: 3, + LogicalAND: 4, + BitwiseOR: 5, + BitwiseXOR: 6, + BitwiseAND: 7, + Equality: 8, + Relational: 9, + BitwiseSHIFT: 10, + Additive: 11, + Multiplicative: 12, + Prefix: 13, + Postfix: 14, + New: 15, + Call: 16, + TaggedTemplate: 17, + Member: 18, + Primary: 19 +}; + +const BinaryPrecedence = { + ",": Precedence.Sequence, + "||": Precedence.LogicalOR, + "&&": Precedence.LogicalAND, + "|": Precedence.BitwiseOR, + "^": Precedence.BitwiseXOR, + "&": Precedence.BitwiseAND, + "==": Precedence.Equality, + "!=": Precedence.Equality, + "===": Precedence.Equality, + "!==": Precedence.Equality, + "<": Precedence.Relational, + ">": Precedence.Relational, + "<=": Precedence.Relational, + ">=": Precedence.Relational, + "in": Precedence.Relational, + "instanceof": Precedence.Relational, + "<<": Precedence.BitwiseSHIFT, + ">>": Precedence.BitwiseSHIFT, + ">>>": Precedence.BitwiseSHIFT, + "+": Precedence.Additive, + "-": Precedence.Additive, + "*": Precedence.Multiplicative, + "%": Precedence.Multiplicative, + "/": Precedence.Multiplicative +}; + +function getPrecedence(node) { + switch (node.type) { + case "ArrayExpression": + case "FunctionExpression": + case "IdentifierExpression": + case "LiteralBooleanExpression": + case "LiteralNullExpression": + case "LiteralNumericExpression": + case "LiteralRegExpExpression": + case "LiteralStringExpression": + case "ObjectExpression": + return Precedence.Primary; + + case "AssignmentExpression": + return Precedence.Assignment; + + case "ConditionalExpression": + return Precedence.Conditional; + + case "ComputedMemberExpression": + case "StaticMemberExpression": + switch (node.object.type) { + case "CallExpression": + case "ComputedMemberExpression": + case "StaticMemberExpression": + return getPrecedence(node.object); + default: + return Precedence.Member; + } + + case "BinaryExpression": + return BinaryPrecedence[node.operator]; + + case "CallExpression": + return Precedence.Call; + case "NewExpression": + return node.arguments.length === 0 ? Precedence.New : Precedence.Member; + case "PostfixExpression": + return Precedence.Postfix; + case "PrefixExpression": + return Precedence.Prefix; + } +} + +function escapeStringLiteral(stringValue) { + let result = ""; + result += ('"'); + for (let i = 0; i < stringValue.length; i++) { + let ch = stringValue.charAt(i); + switch (ch) { + case "\b": + result += "\\b"; + break; + case "\t": + result += "\\t"; + break; + case "\n": + result += "\\n"; + break; + case "\u000B": + result += "\\v"; + break; + case "\u000C": + result += "\\f"; + break; + case "\r": + result += "\\r"; + break; + case "\"": + result += "\\\""; + break; + case "\\": + result += "\\\\"; + break; + case "\u2028": + result += "\\u2028"; + break; + case "\u2029": + result += "\\u2029"; + break; + default: + result += ch; + break; + } + } + result += '"'; + return result.toString(); +} + +function p(node, precedence, a) { + return getPrecedence(node) < precedence ? paren(a) : a; +} + +class CodeRep { + constructor() { + this.containsIn = false; + this.containsGroup = false; + this.startsWithFunctionOrCurly = false; + this.endsWithMissingElse = false; + } + + emit(stream, noIn) { + throw new Error("Not implemented"); + } +} + +class Empty extends CodeRep { + emit() { + } +} + +class Token extends CodeRep { + constructor(token) { + super(); + this.token = token; + } + + emit(ts) { + ts.put(this.token); + } +} + +class NumberCodeRep extends CodeRep { + constructor(number) { + super(); + this.number = number; + } + + emit(ts) { + ts.putNumber(this.number); + } +} + +class Paren extends CodeRep { + constructor(expr) { + super(); + this.expr = expr; + } + + emit(ts) { + ts.put("("); + this.expr.emit(ts, false); + ts.put(")"); + } +} + +class Bracket extends CodeRep { + constructor(expr) { + super(); + this.expr = expr; + } + + emit(ts) { + ts.put("["); + this.expr.emit(ts, false); + ts.put("]"); + } +} + +class Brace extends CodeRep { + constructor(expr) { + super(); + this.expr = expr; + } + + emit(ts) { + ts.put("{"); + this.expr.emit(ts, false); + ts.put("}"); + } +} + +class NoIn extends CodeRep { + constructor(expr) { + super(); + this.expr = expr; + } + + emit(ts) { + this.expr.emit(ts, true); + } +} + +class ContainsIn extends CodeRep { + constructor(expr) { + super(); + this.expr = expr; + } + + emit(ts, noIn) { + if (noIn) { + ts.put("("); + this.expr.emit(ts, false); + ts.put(")"); + } else { + this.expr.emit(ts, false); + } + } +} + +class Seq extends CodeRep { + constructor(children) { + super(); + this.children = children; + } + + emit(ts, noIn) { + this.children.forEach(cr => cr.emit(ts, noIn)); + } +} + +class Semi extends Token { + constructor() { + super(";"); + } +} + +class CommaSep extends CodeRep { + constructor(children) { + super(); + this.children = children; + } + + emit(ts, noIn) { + var first = true; + this.children.forEach( + (cr) => { + if (first) { + first = false; + } else { + ts.put(","); + } + cr.emit(ts, noIn); + }); + } +} + +class SemiOp extends CodeRep { + emit(ts) { + ts.putOptionalSemi(); + } +} + +class Init extends CodeRep { + constructor(binding, init) { + super(); + this.binding = binding; + this.init = init; + } + + emit(ts, noIn) { + this.binding.emit(ts); + if (this.init != null) { + ts.put("="); + this.init.emit(ts, noIn); + } + } +} + +function t(token) { + return new Token(token); +} + +function paren(rep) { + return new Paren(rep); +} + +function bracket(rep) { + return new Bracket(rep); +} + +function noIn(rep) { + return new NoIn(rep); +} + +function markContainsIn(state) { + return state.containsIn ? new ContainsIn(state) : state; +} + +function seq(...reps) { + return new Seq(reps); +} + +function semi() { + return new Semi(); +} + +function empty() { + return new Empty(); +} + +function commaSep(pieces) { + return new CommaSep(pieces); +} + +function brace(rep) { + return new Brace(rep); +} + +function semiOp() { + return new SemiOp(); +} + +function parenToAvoidBeingDirective(element, original) { + if (element && element.type === "ExpressionStatement" && element.expression.type === "LiteralStringExpression") { + return seq(paren(original.children[0]), semiOp()); + } + return original; +} + +function getAssignmentExpr(state) { + return state ? (state.containsGroup ? paren(state) : state) : empty(); +} + +class CodeGen { + + reduceScript(node, body) { + return body; + } + + reduceIdentifier(node) { + return t(node.name); + } + + reduceIdentifierExpression(node, name) { + return name; + } + + reduceThisExpression(node) { + return t("this"); + } + + reduceLiteralBooleanExpression(node) { + return t(node.value.toString()); + } + + reduceLiteralStringExpression(node) { + return t(escapeStringLiteral(node.value)); + } + + reduceLiteralRegExpExpression(node) { + return t(node.value); + } + + reduceLiteralNumericExpression(node) { + return new NumberCodeRep(node.value); + } + + reduceLiteralNullExpression(node) { + return t("null"); + } + + reduceFunctionExpression(node, id, params, body) { + const argBody = seq(paren(commaSep(params)), brace(body)); + let state = seq(t("function"), id ? seq(id, argBody) : argBody); + state.startsWithFunctionOrCurly = true; + return state; + } + + reduceStaticMemberExpression(node, object, property) { + const state = seq(p(node.object, getPrecedence(node), object), t("."), property); + state.startsWithFunctionOrCurly = object.startsWithFunctionOrCurly; + return state; + } + + reduceComputedMemberExpression(node, object, expression) { + return objectAssign( + seq(p(node.object, getPrecedence(node), object), bracket(expression)), + {startsWithFunctionOrCurly: object.startsWithFunctionOrCurly}); + } + + reduceObjectExpression(node, properties) { + let state = brace(commaSep(properties)); + state.startsWithFunctionOrCurly = true; + return state; + } + + reduceBinaryExpression(node, left, right) { + let leftCode = left; + let startsWithFunctionOrCurly = left.startsWithFunctionOrCurly; + let leftContainsIn = left.containsIn; + if (getPrecedence(node.left) < getPrecedence(node)) { + leftCode = paren(leftCode); + startsWithFunctionOrCurly = false; + leftContainsIn = false; + } + let rightCode = right; + let rightContainsIn = right.containsIn; + if (getPrecedence(node.right) <= getPrecedence(node)) { + rightCode = paren(rightCode); + rightContainsIn = false; + } + + return objectAssign( + seq(leftCode, t(node.operator), rightCode), + { + containsIn: leftContainsIn || rightContainsIn || node.operator === "in", + containsGroup: node.operator == ",", + startsWithFunctionOrCurly + }); + } + + reduceAssignmentExpression(node, binding, expression) { + let rightCode = expression; + let containsIn = expression.containsIn; + let startsWithFunctionOrCurly = binding.startsWithFunctionOrCurly; + if (getPrecedence(node.expression) < getPrecedence(node)) { + rightCode = paren(rightCode); + containsIn = false; + } + return objectAssign(seq(binding, t(node.operator), rightCode), {containsIn, startsWithFunctionOrCurly}); + } + + reduceArrayExpression(node, elements) { + if (elements.length === 0) { + return bracket(empty()); + } + + let content = commaSep(elements.map(getAssignmentExpr)); + if (elements.length > 0 && elements[elements.length - 1] == null) { + content = seq(content, t(",")); + } + return bracket(content); + } + + reduceNewExpression(node, callee, args) { + let calleeRep = getPrecedence(node.callee) == Precedence.Call ? paren(callee) : + p(node.callee, getPrecedence(node), callee); + return seq(t("new"), calleeRep, args.length === 0 ? empty() : paren(commaSep(args))); + } + + reduceCallExpression(node, callee, args) { + return objectAssign( + seq(p(node.callee, getPrecedence(node), callee), paren(commaSep(args))), + {startsWithFunctionOrCurly: callee.startsWithFunctionOrCurly}); + } + + reducePostfixExpression(node, operand) { + return objectAssign( + seq(p(node.operand, getPrecedence(node), operand), t(node.operator)), + {startsWithFunctionOrCurly: operand.startsWithFunctionOrCurly}); + } + + reducePrefixExpression(node, operand) { + return seq(t(node.operator), p(node.operand, getPrecedence(node), operand)); + } + + reduceConditionalExpression(node, test, consequent, alternate) { + let containsIn = test.containsIn || alternate.containsIn; + let startsWithFunctionOrCurly = test.startsWithFunctionOrCurly; + return objectAssign( + seq( + p(node.test, Precedence.LogicalOR, test), t("?"), + p(node.consequent, Precedence.Assignment, consequent), t(":"), + p(node.alternate, Precedence.Assignment, alternate)), { + containsIn, + startsWithFunctionOrCurly + }); + } + + reduceFunctionDeclaration(node, id, params, body) { + return seq(t("function"), id, paren(commaSep(params)), brace(body)); + } + + reduceUseStrictDirective(node) { + return seq(t("\"use strict\""), semiOp()); + } + + reduceUnknownDirective(node) { + var name = "use strict" === node.value ? "use\\u0020strict" : node.value; + return seq(t("\"" + name + "\""), semiOp()); + } + + reduceBlockStatement(node, block) { + return block; + } + + reduceBreakStatement(node, label) { + return seq(t("break"), label || empty(), semiOp()); + } + + reduceCatchClause(node, param, body) { + return seq(t("catch"), paren(param), body); + } + + reduceContinueStatement(node, label) { + return seq(t("continue"), label || empty(), semiOp()); + } + + reduceDebuggerStatement(node) { + return seq(t("debugger"), semiOp()); + } + + reduceDoWhileStatement(node, body, test) { + return seq(t("do"), body, t("while"), paren(test), semiOp()); + } + + reduceEmptyStatement(node) { + return semi(); + } + + reduceExpressionStatement(node, expression) { + return seq((expression.startsWithFunctionOrCurly ? paren(expression) : expression), semiOp()); + } + + reduceForInStatement(node, left, right, body) { + return objectAssign( + seq(t("for"), paren(seq(noIn(markContainsIn(left)), t("in"), right)), body), + {endsWithMissingElse: body.endsWithMissingElse}); + } + + reduceForStatement(node, init, test, update, body) { + return objectAssign( + seq( + t("for"), + paren(seq(init ? noIn(markContainsIn(init)) : empty(), semi(), test || empty(), semi(), update || empty())), + body), + { + endsWithMissingElse: body.endsWithMissingElse + }); + } + + reduceIfStatement(node, test, consequent, alternate) { + if (alternate && consequent.endsWithMissingElse) { + consequent = brace(consequent); + } + return objectAssign( + seq(t("if"), paren(test), consequent, alternate ? seq(t("else"), alternate) : empty()), + {endsWithMissingElse: alternate ? alternate.endsWithMissingElse : true}); + } + + reduceLabeledStatement(node, label, body) { + return objectAssign(seq(label, t(":"), body), {endsWithMissingElse: body.endsWithMissingElse}); + } + + reduceReturnStatement(node, argument) { + return seq(t("return"), argument || empty(), semiOp()); + } + + reduceSwitchCase(node, test, consequent) { + return seq(t("case"), test, t(":"), seq(...consequent)); + } + + reduceSwitchDefault(node, consequent) { + return seq(t("default"), t(":"), seq(...consequent)); + } + + reduceSwitchStatement(node, discriminant, cases) { + return seq(t("switch"), paren(discriminant), brace(seq(...cases))); + } + + reduceSwitchStatementWithDefault(node, discriminant, cases, defaultCase, postDefaultCases) { + return seq( + t("switch"), + paren(discriminant), + brace(seq(...cases, defaultCase, ...postDefaultCases))); + } + + reduceThrowStatement(node, argument) { + return seq(t("throw"), argument, semiOp()); + } + + reduceTryCatchStatement(node, block, catchClause) { + return seq(t("try"), block, catchClause); + } + + reduceTryFinallyStatement(node, block, catchClause, finalizer) { + return seq( + t("try"), + block, + catchClause || empty(), + t("finally"), + finalizer); + } + + reduceVariableDeclarationStatement(node, declaration) { + return seq(declaration, semiOp()); + } + + reduceVariableDeclaration(node, declarators) { + return seq(t(node.kind), commaSep(declarators)); + } + + reduceWhileStatement(node, test, body) { + return objectAssign(seq(t("while"), paren(test), body), {endsWithMissingElse: body.endsWithMissingElse}); + } + + reduceWithStatement(node, object, body) { + return objectAssign( + seq(t("with"), paren(object), body), + {endsWithMissingElse: body.endsWithMissingElse}); + } + + reduceDataProperty(node, key, value) { + return seq(key, t(":"), getAssignmentExpr(value)); + } + + reduceGetter(node, key, body) { + return seq(t("get"), key, paren(empty()), brace(body)); + } + + reduceSetter(node, key, parameter, body) { + return seq(t("set"), key, paren(parameter), brace(body)); + } + + reducePropertyName(node) { + if (node.kind == "number" || node.kind == "identifier") { + return t(node.value.toString()); + } + return t(Utils.escapeStringLiteral(node.value)); + } + + reduceFunctionBody(node, directives, sourceElements) { + if (sourceElements.length) { + sourceElements[0] = parenToAvoidBeingDirective(node.statements[0], sourceElements[0]); + } + return seq(...directives, ...sourceElements); + } + + reduceVariableDeclarator(node, id, init) { + let containsIn = init && init.containsIn && !init.containsGroup; + if (init) { + if (init.containsGroup) { + init = paren(init); + } else { + init = markContainsIn(init); + } + } + return objectAssign(new Init(id, init), {containsIn}); + } + + reduceBlock(node, statements) { + return brace(seq(...statements)); + } +} + +const INSTANCE = new CodeGen; diff --git a/src/token_stream.js b/src/token_stream.js new file mode 100644 index 0000000..bb9bc31 --- /dev/null +++ b/src/token_stream.js @@ -0,0 +1,73 @@ +/** + * Copyright 2014 Shape Security, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License") + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import {code} from "esutils"; + +function numberDot(fragment) { + if (fragment.indexOf(".") < 0 && fragment.indexOf("e") < 0) { + return ".."; + } + return "."; +} + +export class TokenStream { + constructor() { + this.result = ""; + this.lastNumber = null; + this.lastChar = null; + this.optionalSemi = false; + } + + putNumber(number) { + let tokenStr = number.toString(); + this.put(tokenStr); + this.lastNumber = tokenStr; + } + + putOptionalSemi() { + this.optionalSemi = true; + } + + put(tokenStr) { + if (this.optionalSemi) { + this.optionalSemi = false; + if (tokenStr !== "}") { + this.put(";"); + } + } + if (this.lastNumber !== null && tokenStr.length == 1) { + if (tokenStr === ".") { + this.result += numberDot(this.lastNumber); + this.lastNumber = null; + this.lastChar = "."; + return; + } + } + this.lastNumber = null; + let rightChar = tokenStr.charAt(0); + let lastChar = this.lastChar; + this.lastChar = tokenStr.charAt(tokenStr.length - 1); + if (lastChar && + ((lastChar == "+" || lastChar == "-") && + lastChar == rightChar || + code.isIdentifierPart(lastChar.charCodeAt(0)) && code.isIdentifierPart(rightChar.charCodeAt(0)) || + lastChar == "/" && rightChar == "i")) { + this.result += " "; + } + + this.result += tokenStr; + } +} diff --git a/test/simple.js b/test/simple.js new file mode 100644 index 0000000..6759b06 --- /dev/null +++ b/test/simple.js @@ -0,0 +1,440 @@ +/** + * Copyright 2014 Shape Security, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License") + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +var expect = require("expect.js"); +var Shift = require("shift-ast"); +var codeGen = require("../")["default"]; +var parse = require("shift-parser")["default"]; + +describe("API", function () { + it("should exist", function () { + expect(typeof codeGen).be("function"); + }); +}); + +describe("Code generator", function () { + + var IdentifierExpression = Shift.IdentifierExpression; + var EmptyStatement = Shift.EmptyStatement; + var IfStatement = Shift.IfStatement; + var LabeledStatement = Shift.LabeledStatement; + var Identifier = Shift.Identifier; + var WhileStatement = Shift.WhileStatement; + var WithStatement = Shift.WithStatement; + var ForStatement = Shift.ForStatement; + var ForInStatement = Shift.ForInStatement; + + describe("generates simple ECMAScript", function () { + function statement(stmt) { + return new Shift.Script(new Shift.FunctionBody([], [stmt])); + } + + function testShift(to, tree) { + var dst = codeGen(tree); + expect(dst).be(to); + expect(codeGen(parse(to))).be(to); + expect(parse(to)).eql(tree); + } + + function test(source) { + expect(codeGen(parse(source))).be(source); + expect(parse(codeGen(parse(source)))).eql(parse(source)); + } + + function test2(expected, source) { + expect(codeGen(parse(source))).be(expected); + expect(codeGen(parse(expected))).be(expected); + } + + it("Directives", function () { + test("\"use strict\""); + test("\"use\\u0020strict\""); + testShift("\"use\\u0020strict\"", + new Shift.Script(new Shift.FunctionBody([new Shift.UnknownDirective("use strict")], []))); + test("\"use strict\""); + testShift("(\"use strict\")", + statement(new Shift.ExpressionStatement(new Shift.LiteralStringExpression("use strict", "\'use strict\'")))); + testShift("(\"use strict\");;", + new Shift.Script(new Shift.FunctionBody([], + [new Shift.ExpressionStatement(new Shift.LiteralStringExpression("use strict", "\'use strict\'")), new EmptyStatement()]))); + }); + + it("ArrayExpression", function () { + test("[]"); + test("[a]"); + test("[a]", "[a,]"); + test("[a,b,c]", "[a,b,c,]"); + test("[a,,]"); + test("[a,,,]"); + test("[[a]]"); + test("[(a,a)]"); + }); + + it("ObjectExpression", function () { + test("({})"); + test2("({a:1})", "({a:1,})"); + test("({}.a--)"); + test2("({1:1})", "({1.0:1})"); + test2("({a:b})", "({a:b})"); + test("({get a(){;}})"); + test("({set a(param){;}})"); + test("({get a(){;},set a(param){;},b:1})"); + test("({a:(a,b)})"); + }); + + it("Sequence", function () { + test("a,b,c,d"); + }); + + it("Assignment", function () { + test("a=b"); + test("a+=b"); + test("a*=b"); + test("a%=b"); + test("a<<=b"); + test("a>>=b"); + test("a>>>=b"); + test("a/=b"); + test("a|=b"); + test("a^=b"); + test("a,b^=b"); + test("b^=b,b"); + test("b^=(b,b)"); + }); + + it("Conditional", function () { + test("a?b:c"); + test("a?b?c:d:e"); + test("a?b:c?d:e"); + test("a?b?c:d:e?f:g"); + test("(a?b:c)?d:e"); + test("(a,b)?(c,d):(e,f)"); + test("a?b=c:d"); + test("a?b=c:d=e"); + test("a||b?c=d:e=f"); + test("(a=b)?c:d"); + test("a||(b?c:d)"); + test("a?b||c:d"); + test("a?b:c||d"); + }); + + it("LogicalOr", function () { + test("a||b"); + }); + + it("LogicalAnd", function () { + test("a||b"); + }); + + it("BitwiseOr", function () { + test("a|b"); + }); + + it("BitwiseAnd", function () { + test("a&b"); + }); + + it("BitwiseXor", function () { + test("a^b"); + test("a^b&b"); + test("(a^b)&b"); + }); + + it("Equality", function () { + test("a==b"); + test("a!=b"); + test("a==b"); + test("a!=b"); + test("a==b==c"); + test("a==(b==c)"); + }); + + it("Relational", function () { + test("ab"); + test("a>=b"); + test("a instanceof b"); + test("a in b"); + test("a==b>b"); + test("a>>>b"); + test("a<