API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 30th, 2013
10
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Diff 29.54 KB | None | 0 0
raw download clone embed print report
  1. diff --git a/escodegen.js b/escodegen.js
  2. index d5618c1..b94c73e 100644
  3. --- a/escodegen.js
  4. +++ b/escodegen.js
  5. @@ -81,7 +81,6 @@
  6.          DoWhileStatement: 'DoWhileStatement',
  7.          DebuggerStatement: 'DebuggerStatement',
  8.          EmptyStatement: 'EmptyStatement',
  9. -        EmptyExpression: 'EmptyExpression',
  10.          ExpressionStatement: 'ExpressionStatement',
  11.          ForStatement: 'ForStatement',
  12.          ForInStatement: 'ForInStatement',
  13. @@ -774,47 +773,98 @@
  14.          return result;
  15.      }
  16.  
  17. -    function addExtrasToNode(node, result) {
  18. +    function processExtras(extras, result, previousLineComment) {
  19. +        var i, len, extra;
  20.  
  21. -        function addExtras(extras, result) {
  22. -            var i, len, extra;
  23. -
  24. -            for (i = 0, len = extras.length; i < len; i += 1) {
  25. -                // was previous extra a line-comment?
  26. -                if (previousLineComment) {
  27. -                    // need to insert a new-line to delimit previous line-comment?
  28. -                    if (!startsWithLineTerminator(extras[i].value)) {
  29. -                        result.push('\n');
  30. -                    }
  31. +        for (i = 0, len = extras.length; i < len; i += 1) {
  32. +            // was previous extra a line-comment?
  33. +            if (previousLineComment) {
  34. +                // need to insert a new-line to delimit previous line-comment?
  35. +                if (!startsWithLineTerminator(extras[i].value)) {
  36. +                    result.push('\n');
  37.                  }
  38. +            }
  39.  
  40. -                extra = extras[i];
  41. +            extra = extras[i];
  42.  
  43. -                if (extra.type === 'Whitespace') {
  44. -                    result.push(extra.value);
  45. -                    previousLineComment = false;
  46. -                }
  47. -                else if (extra.type === 'LineComment') {
  48. -                    result.push((extra.marker || '//') + extra.value);
  49. -                    previousLineComment = true;
  50. -                }
  51. -                else if (extra.type === 'MultilineComment') {
  52. -                    result.push('/*' + extra.value + '*/');
  53. -                    previousLineComment = false;
  54. -                }
  55. +            if (extra.type === 'Whitespace') {
  56. +                result.push(extra.value);
  57. +                previousLineComment = false;
  58.              }
  59. +            else if (extra.type === 'LineComment') {
  60. +                result.push((extra.marker || '//') + extra.value);
  61. +                previousLineComment = true;
  62. +            }
  63. +            else if (extra.type === 'MultilineComment') {
  64. +                result.push('/*' + extra.value + '*/');
  65. +                previousLineComment = false;
  66. +            }
  67. +        }
  68.  
  69. -            return result;
  70. +        return {
  71. +            result: result,
  72. +            previousLineComment: previousLineComment
  73. +        };
  74. +    }
  75. +
  76. +    function extrasOrSpace(extras) {
  77. +        var result, ret;
  78. +
  79. +        if (extras) {
  80. +            ret = processExtras(extras, [], false);
  81. +            result = ret.result;
  82. +
  83. +            // was last extra a line-comment?
  84. +            if (ret.previousLineComment) {
  85. +                // insert a new-line to delimit previous line-comment
  86. +                result.push('\n');
  87. +            }
  88. +        }
  89. +        else {
  90. +            result = space;
  91. +        }
  92. +
  93. +        return result;
  94. +    }
  95. +
  96. +    function spaceIfNoExtras(extras) {
  97. +        if (!extras) {
  98. +            return space;
  99.          }
  100.  
  101. -        var save, previousLineComment = false;
  102. +        return '';
  103. +    }
  104. +
  105. +    function addBetweenExtrasToNode(node, result, firstBetweenChild) {
  106. +        var ret;
  107. +
  108. +        if (node && node.extras && node.extras.between && node.extras.between.length > 0) {
  109. +            ret = processExtras(node.extras.between, result, false);
  110. +            result = ret.result;
  111. +
  112. +            // was last extra a line-comment?
  113. +            if (ret.previousLineComment) {
  114. +                // need to insert a new-line to delimit previous line-comment?
  115. +                if (!firstBetweenChild || !startsWithLineTerminator(firstBetweenChild || '')) {
  116. +                    result.push('\n');
  117. +                }
  118. +            }
  119. +        }
  120. +
  121. +        return result;
  122. +    }
  123. +
  124. +    function addOuterExtrasToNode(node, result) {
  125. +        var save, ret, previousLineComment = false;
  126.  
  127.          if (node && node.extras) {
  128.              if (node.extras.leading && node.extras.leading.length > 0) {
  129.                  save = result;
  130.                  result = [];
  131.  
  132. -                result = addExtras(node.extras.leading, result);
  133. +                ret = processExtras(node.extras.leading, result, previousLineComment);
  134. +                result = ret.result;
  135. +                previousLineComment = ret.previousLineComment;
  136.  
  137.                  // was last extra a line-comment?
  138.                  if (previousLineComment) {
  139. @@ -833,7 +883,9 @@
  140.                  if (!Array.isArray(result)) {
  141.                      result = [result];
  142.                  }
  143. -                result = addExtras(node.extras.trailing, result);
  144. +                ret = processExtras(node.extras.trailing, result, previousLineComment);
  145. +                result = ret.result;
  146. +                previousLineComment = ret.previousLineComment;
  147.  
  148.                  // was last extra a line-comment?
  149.                  if (previousLineComment) {
  150. @@ -898,7 +950,7 @@
  151.      function generateIdentifier(node) {
  152.          var ret = toSourceNode(node.name, node);
  153.          if (node.extras) {
  154. -            ret = addExtrasToNode(node,ret);
  155. +            ret = addOuterExtrasToNode(node,ret);
  156.          }
  157.          return ret;
  158.      }
  159. @@ -913,10 +965,13 @@
  160.              result = [generateIdentifier(node.params[0])];
  161.          } else {
  162.              result = ['('];
  163. +            if (node.extras) {
  164. +                result = addBetweenExtrasToNode(node, result, (node.params[0] ? toSourceNode(generateIdentifier(node.params[0])).toString() : null));
  165. +            }
  166.              for (i = 0, len = node.params.length; i < len; i += 1) {
  167.                  result.push(generateIdentifier(node.params[i]));
  168.                  if (i + 1 < len) {
  169. -                    result.push(',' + space);
  170. +                    result.push(',', spaceIfNoExtras(node.params[i + 1].extras && node.params[i + 1].extras.leading));
  171.                  }
  172.              }
  173.              result.push(')');
  174. @@ -927,7 +982,7 @@
  175.          }
  176.  
  177.          if (node.expression) {
  178. -            result.push(space);
  179. +            result.push(spaceIfNoExtras(node.body.extras && node.body.extras.leading));
  180.              expr = generateExpression(node.body, {
  181.                  precedence: Precedence.Assignment,
  182.                  allowIn: true,
  183. @@ -971,15 +1026,6 @@
  184.          }
  185.  
  186.          switch (type) {
  187. -
  188. -        case Syntax.EmptyExpression:
  189. -            // 'EmptyExpression' is just a placeholder node for where only
  190. -            // extras are present.
  191. -            // Example: comment or whitespace extras in an otherwise empty
  192. -            //    arguments list of a call expression
  193. -            result = [];
  194. -            break;
  195. -
  196.          case Syntax.SequenceExpression:
  197.              result = [];
  198.              allowIn |= (Precedence.Sequence < precedence);
  199. @@ -990,7 +1036,7 @@
  200.                      allowCall: true
  201.                  }));
  202.                  if (i + 1 < len) {
  203. -                    result.push(',' + space);
  204. +                    result.push(',', spaceIfNoExtras(expr.expressions[i + 1].extras && expr.expressions[i + 1].extras.leading));
  205.                  }
  206.              }
  207.              result = parenthesize(result, Precedence.Sequence, precedence);
  208. @@ -1005,7 +1051,9 @@
  209.                          allowIn: allowIn,
  210.                          allowCall: true
  211.                      }),
  212. -                    space + expr.operator + space,
  213. +                    spaceIfNoExtras(expr.left.extras && expr.left.extras.trailing),
  214. +                    expr.operator,
  215. +                    spaceIfNoExtras(expr.right.extras && expr.right.extras.leading),
  216.                      generateExpression(expr.right, {
  217.                          precedence: Precedence.Assignment,
  218.                          allowIn: allowIn,
  219. @@ -1031,13 +1079,17 @@
  220.                          allowIn: allowIn,
  221.                          allowCall: true
  222.                      }),
  223. -                    space + '?' + space,
  224. +                    spaceIfNoExtras(expr.test.extras && expr.test.extras.trailing),
  225. +                    '?',
  226. +                    spaceIfNoExtras(expr.consequent.extras && expr.consequent.extras.leading),
  227.                      generateExpression(expr.consequent, {
  228.                          precedence: Precedence.Assignment,
  229.                          allowIn: allowIn,
  230.                          allowCall: true
  231.                      }),
  232. -                    space + ':' + space,
  233. +                    spaceIfNoExtras(expr.consequent.extras && expr.consequent.extras.trailing),
  234. +                    ':',
  235. +                    spaceIfNoExtras(expr.alternate.extras && expr.alternate.extras.leading),
  236.                      generateExpression(expr.alternate, {
  237.                          precedence: Precedence.Assignment,
  238.                          allowIn: allowIn,
  239. @@ -1064,7 +1116,11 @@
  240.              leftSource = fragment.toString();
  241.  
  242.              if (leftSource.charAt(leftSource.length - 1) === '/' && isIdentifierPart(expr.operator.charAt(0))) {
  243. -                result = [fragment, noEmptySpace(), expr.operator];
  244. +                result = [fragment];
  245. +                if (!(expr.left.extras && expr.left.extras.trailing)) {
  246. +                    result.push(noEmptySpace());
  247. +                }
  248. +                result.push(expr.operator);
  249.              } else {
  250.                  result = join(fragment, expr.operator);
  251.              }
  252. @@ -1078,7 +1134,10 @@
  253.              if (expr.operator === '/' && fragment.toString().charAt(0) === '/' ||
  254.              expr.operator.slice(-1) === '<' && fragment.toString().slice(0, 3) === '!--') {
  255.                  // If '/' concats with '/' or `<` concats with `!--`, it is interpreted as comment start
  256. -                result.push(noEmptySpace(), fragment);
  257. +                if (!(expr.right.extras && expr.right.extras.leading)) {
  258. +                    result.push(noEmptySpace());
  259. +                }
  260. +                result.push(fragment);
  261.              } else {
  262.                  result = join(result, fragment);
  263.              }
  264. @@ -1107,7 +1166,7 @@
  265.                      allowCall: true
  266.                  }));
  267.                  if (i + 1 < len) {
  268. -                    result.push(',' + space);
  269. +                    result.push(',', spaceIfNoExtras(expr['arguments'][i + 1].extras && expr['arguments'][i + 1].extras.leading));
  270.                  }
  271.              }
  272.              result.push(')');
  273. @@ -1142,7 +1201,7 @@
  274.                          allowCall: true
  275.                      }));
  276.                      if (i + 1 < len) {
  277. -                        result.push(',' + space);
  278. +                        result.push(',', spaceIfNoExtras(expr['arguments'][i + 1].extras && expr['arguments'][i + 1].extras.leading));
  279.                      }
  280.                  }
  281.                  result.push(')');
  282. @@ -1212,10 +1271,13 @@
  283.                      rightChar = fragment.toString().charAt(0);
  284.  
  285.                      if (((leftChar === '+' || leftChar === '-') && leftChar === rightChar) || (isIdentifierPart(leftChar) && isIdentifierPart(rightChar))) {
  286. -                        result.push(noEmptySpace(), fragment);
  287. -                    } else {
  288. -                        result.push(fragment);
  289. +                        // were leading-extras NOT already included in `fragment`?
  290. +                        if (!(expr.argument.extras && expr.argument.extras.leading)) {
  291. +                            // make sure there's a necessary space there instead
  292. +                            result.push(noEmptySpace());
  293. +                        }
  294.                      }
  295. +                    result.push(fragment);
  296.                  }
  297.              }
  298.              result = parenthesize(result, Precedence.Unary, precedence);
  299. @@ -1273,9 +1335,13 @@
  300.              result = 'function';
  301.  
  302.              if (expr.id) {
  303. -                result = [result, noEmptySpace(),
  304. -                          generateIdentifier(expr.id),
  305. -                          generateFunctionBody(expr)];
  306. +                result = [result];
  307. +                // leading-extras NOT already included in identifier?
  308. +                if (!(expr.id.extras && expr.id.extras.leading)) {
  309. +                    // make sure there's a necessary space there instead
  310. +                    result.push(noEmptySpace());
  311. +                }
  312. +                result.push(generateIdentifier(expr.id), generateFunctionBody(expr));
  313.              } else {
  314.                  result = [result + space, generateFunctionBody(expr)];
  315.              }
  316. @@ -1284,50 +1350,78 @@
  317.  
  318.          case Syntax.ArrayPattern:
  319.          case Syntax.ArrayExpression:
  320. +            if (expr.extras) {
  321. +                result = [];
  322. +                result.push('[');
  323. +                result = addBetweenExtrasToNode(expr, result);
  324. +            }
  325. +
  326.              if (!expr.elements.length) {
  327. -                result = '[]';
  328. +                result.push(']');
  329.                  break;
  330.              }
  331. -            multiline = expr.elements.length > 1;
  332. -            result = ['[', multiline ? newline : ''];
  333. -            withIndent(function (indent) {
  334. +
  335. +            if (expr.extras) {
  336.                  for (i = 0, len = expr.elements.length; i < len; i += 1) {
  337. -                    if (!expr.elements[i]) {
  338. -                        if (multiline) {
  339. -                            result.push(indent);
  340. -                        }
  341. -                        if (i + 1 === len) {
  342. -                            result.push(',');
  343. -                        }
  344. -                    } else {
  345. -                        result.push(multiline ? indent : '', generateExpression(expr.elements[i], {
  346. +                    if (expr.elements[i]) {
  347. +                        result.push(generateExpression(expr.elements[i], {
  348.                              precedence: Precedence.Assignment,
  349.                              allowIn: true,
  350.                              allowCall: true
  351.                          }));
  352.                      }
  353. +
  354.                      if (i + 1 < len) {
  355. -                        result.push(',' + (multiline ? newline : space));
  356. +                        result.push(',', spaceIfNoExtras(expr.elements[i + 1].extras && expr.elements[i + 1].extras.leading));
  357.                      }
  358.                  }
  359. -            });
  360. -            if (multiline && !endsWithLineTerminator(toSourceNode(result).toString())) {
  361. -                result.push(newline);
  362. +                result.push(']');
  363. +            } else {
  364. +                multiline = expr.elements.length > 1;
  365. +                result = ['[', multiline ? newline : ''];
  366. +                withIndent(function (indent) {
  367. +                    for (i = 0, len = expr.elements.length; i < len; i += 1) {
  368. +                        if (!expr.elements[i]) {
  369. +                            if (multiline) {
  370. +                                result.push(indent);
  371. +                            }
  372. +                            if (i + 1 === len) {
  373. +                                result.push(',');
  374. +                            }
  375. +                        } else {
  376. +                            result.push(multiline ? indent : '', generateExpression(expr.elements[i], {
  377. +                                precedence: Precedence.Assignment,
  378. +                                allowIn: true,
  379. +                                allowCall: true
  380. +                            }));
  381. +                        }
  382. +                        if (i + 1 < len) {
  383. +                            result.push(',' + (multiline ? newline : space));
  384. +                        }
  385. +                    }
  386. +                });
  387. +                if (multiline && !endsWithLineTerminator(toSourceNode(result).toString())) {
  388. +                    result.push(newline);
  389. +                }
  390. +                result.push(multiline ? base : '', ']');
  391.              }
  392. -            result.push(multiline ? base : '', ']');
  393.              break;
  394.  
  395.          case Syntax.Property:
  396.              if (expr.kind === 'get' || expr.kind === 'set') {
  397. -                result = [
  398. -                    expr.kind, noEmptySpace(),
  399. -                    generateExpression(expr.key, {
  400. +                result = [expr.kind];
  401. +                // leading-extras NOT already included in key?
  402. +                if (!(expr.key.extras && expr.key.extras.leading)) {
  403. +                    // make sure there's a necessary space there instead
  404. +                    result.push(noEmptySpace());
  405. +                }
  406. +                result.push(generateExpression(expr.key, {
  407.                          precedence: Precedence.Sequence,
  408.                          allowIn: true,
  409.                          allowCall: true
  410.                      }),
  411.                      generateFunctionBody(expr.value)
  412. -                ];
  413. +                );
  414.              } else {
  415.                  if (expr.shorthand) {
  416.                      result = generateExpression(expr.key, {
  417. @@ -1352,7 +1446,8 @@
  418.                              allowIn: true,
  419.                              allowCall: true
  420.                          }),
  421. -                        ':' + space,
  422. +                        ':',
  423. +                        spaceIfNoExtras(expr.value.extras && expr.value.extras.leading),
  424.                          generateExpression(expr.value, {
  425.                              precedence: Precedence.Assignment,
  426.                              allowIn: true,
  427. @@ -1364,101 +1459,149 @@
  428.              break;
  429.  
  430.          case Syntax.ObjectExpression:
  431. -            if (!expr.properties.length) {
  432. -                result = '{}';
  433. -                break;
  434. +            if (expr.extras) {
  435. +                result = [];
  436. +                result.push('{');
  437. +                result = addBetweenExtrasToNode(expr, result);
  438.              }
  439. -            multiline = expr.properties.length > 1;
  440. -
  441. -            withIndent(function () {
  442. -                fragment = generateExpression(expr.properties[0], {
  443. -                    precedence: Precedence.Sequence,
  444. -                    allowIn: true,
  445. -                    allowCall: true,
  446. -                    type: Syntax.Property
  447. -                });
  448. -            });
  449.  
  450. -            if (!multiline) {
  451. -                // issues 4
  452. -                // Do not transform from
  453. -                //   dejavu.Class.declare({
  454. -                //       method2: function () {}
  455. -                //   });
  456. -                // to
  457. -                //   dejavu.Class.declare({method2: function () {
  458. -                //       }});
  459. -                if (!hasLineTerminator(toSourceNode(fragment).toString())) {
  460. -                    result = [ '{', space, fragment, space, '}' ];
  461. -                    break;
  462. -                }
  463. +            if (!expr.properties.length) {
  464. +                result.push('}');
  465. +                break;
  466.              }
  467.  
  468. -            withIndent(function (indent) {
  469. -                result = [ '{', newline, indent, fragment ];
  470. -
  471. -                if (multiline) {
  472. -                    result.push(',' + newline);
  473. -                    for (i = 1, len = expr.properties.length; i < len; i += 1) {
  474. -                        result.push(indent, generateExpression(expr.properties[i], {
  475. +            if (expr.extras) {
  476. +                for (i = 0, len = expr.properties.length; i < len; i += 1) {
  477. +                    if (expr.properties[i]) {
  478. +                        result.push(generateExpression(expr.properties[i], {
  479.                              precedence: Precedence.Sequence,
  480.                              allowIn: true,
  481.                              allowCall: true,
  482.                              type: Syntax.Property
  483.                          }));
  484. -                        if (i + 1 < len) {
  485. -                            result.push(',' + newline);
  486. -                        }
  487. +                    }
  488. +
  489. +                    if (i + 1 < len) {
  490. +                        result.push(',', spaceIfNoExtras(expr.properties[i + 1].extras && expr.properties[i + 1].extras.leading));
  491.                      }
  492.                  }
  493. -            });
  494. +                result.push('}');
  495. +            } else {
  496. +                multiline = expr.properties.length > 1;
  497.  
  498. -            if (!endsWithLineTerminator(toSourceNode(result).toString())) {
  499. -                result.push(newline);
  500. +                withIndent(function () {
  501. +                    fragment = generateExpression(expr.properties[0], {
  502. +                        precedence: Precedence.Sequence,
  503. +                        allowIn: true,
  504. +                        allowCall: true,
  505. +                        type: Syntax.Property
  506. +                    });
  507. +                });
  508. +
  509. +                if (!multiline) {
  510. +                    // issues 4
  511. +                    // Do not transform from
  512. +                    //   dejavu.Class.declare({
  513. +                    //       method2: function () {}
  514. +                    //   });
  515. +                    // to
  516. +                    //   dejavu.Class.declare({method2: function () {
  517. +                    //       }});
  518. +                    if (!hasLineTerminator(toSourceNode(fragment).toString())) {
  519. +                        result = [ '{', space, fragment, space, '}' ];
  520. +                        break;
  521. +                    }
  522. +                }
  523. +
  524. +                withIndent(function (indent) {
  525. +                    result = [ '{', newline, indent, fragment ];
  526. +
  527. +                    if (multiline) {
  528. +                        result.push(',' + newline);
  529. +                        for (i = 1, len = expr.properties.length; i < len; i += 1) {
  530. +                            result.push(indent, generateExpression(expr.properties[i], {
  531. +                                precedence: Precedence.Sequence,
  532. +                                allowIn: true,
  533. +                                allowCall: true,
  534. +                                type: Syntax.Property
  535. +                            }));
  536. +                            if (i + 1 < len) {
  537. +                                result.push(',' + newline);
  538. +                            }
  539. +                        }
  540. +                    }
  541. +                });
  542. +
  543. +                if (!endsWithLineTerminator(toSourceNode(result).toString())) {
  544. +                    result.push(newline);
  545. +                }
  546. +                result.push(base, '}');
  547.              }
  548. -            result.push(base, '}');
  549.              break;
  550.  
  551.          case Syntax.ObjectPattern:
  552. +            if (expr.extras) {
  553. +                result = [];
  554. +                result.push('{');
  555. +                result = addBetweenExtrasToNode(expr, result);
  556. +            }
  557. +
  558.              if (!expr.properties.length) {
  559. -                result = '{}';
  560. +                result.push('}');
  561.                  break;
  562.              }
  563.  
  564. -            multiline = false;
  565. -            if (expr.properties.length === 1) {
  566. -                property = expr.properties[0];
  567. -                if (property.value.type !== Syntax.Identifier) {
  568. -                    multiline = true;
  569. +            if (expr.extras) {
  570. +                for (i = 0, len = expr.properties.length; i < len; i += 1) {
  571. +                    if (expr.properties[i]) {
  572. +                        result.push(generateExpression(expr.properties[i], {
  573. +                            precedence: Precedence.Sequence,
  574. +                            allowIn: true,
  575. +                            allowCall: true
  576. +                        }));
  577. +                    }
  578. +
  579. +                    if (i + 1 < len) {
  580. +                        result.push(',', spaceIfNoExtras(expr.properties[i + 1].extras && expr.properties[i + 1].extras.leading));
  581. +                    }
  582.                  }
  583. +                result.push('}');
  584.              } else {
  585. -                for (i = 0, len = expr.properties.length; i < len; i += 1) {
  586. -                    property = expr.properties[i];
  587. -                    if (!property.shorthand) {
  588. +                multiline = false;
  589. +                if (expr.properties.length === 1) {
  590. +                    property = expr.properties[0];
  591. +                    if (property.value.type !== Syntax.Identifier) {
  592.                          multiline = true;
  593. -                        break;
  594. +                    }
  595. +                } else {
  596. +                    for (i = 0, len = expr.properties.length; i < len; i += 1) {
  597. +                        property = expr.properties[i];
  598. +                        if (!property.shorthand) {
  599. +                            multiline = true;
  600. +                            break;
  601. +                        }
  602.                      }
  603.                  }
  604. -            }
  605. -            result = ['{', multiline ? newline : '' ];
  606. +                result = ['{', multiline ? newline : '' ];
  607.  
  608. -            withIndent(function (indent) {
  609. -                for (i = 0, len = expr.properties.length; i < len; i += 1) {
  610. -                    result.push(multiline ? indent : '', generateExpression(expr.properties[i], {
  611. -                        precedence: Precedence.Sequence,
  612. -                        allowIn: true,
  613. -                        allowCall: true
  614. -                    }));
  615. -                    if (i + 1 < len) {
  616. -                        result.push(',' + (multiline ? newline : space));
  617. +                withIndent(function (indent) {
  618. +                    for (i = 0, len = expr.properties.length; i < len; i += 1) {
  619. +                        result.push(multiline ? indent : '', generateExpression(expr.properties[i], {
  620. +                            precedence: Precedence.Sequence,
  621. +                            allowIn: true,
  622. +                            allowCall: true
  623. +                        }));
  624. +                        if (i + 1 < len) {
  625. +                            result.push(',' + (multiline ? newline : space));
  626. +                        }
  627.                      }
  628. -                }
  629. -            });
  630. +                });
  631.  
  632. -            if (multiline && !endsWithLineTerminator(toSourceNode(result).toString())) {
  633. -                result.push(newline);
  634. +                if (multiline && !endsWithLineTerminator(toSourceNode(result).toString())) {
  635. +                    result.push(newline);
  636. +                }
  637. +                result.push(multiline ? base : '', '}');
  638.              }
  639. -            result.push(multiline ? base : '', '}');
  640.              break;
  641.  
  642.          case Syntax.ThisExpression:
  643. @@ -1508,14 +1651,18 @@
  644.              break;
  645.  
  646.          case Syntax.ComprehensionExpression:
  647. -            result = [
  648. -                '[',
  649. +            result = [];
  650. +            result.push('[');
  651. +            if (expr.extras) {
  652. +                result = addBetweenExtrasToNode(expr, result);
  653. +            }
  654. +            result.push(
  655.                  generateExpression(expr.body, {
  656.                      precedence: Precedence.Assignment,
  657.                      allowIn: true,
  658.                      allowCall: true
  659.                  })
  660. -            ];
  661. +            );
  662.  
  663.              if (expr.blocks) {
  664.                  for (i = 0, len = expr.blocks.length; i < len; i += 1) {
  665. @@ -1579,7 +1726,7 @@
  666.          }
  667.  
  668.          if (expr.extras) {
  669. -            result = addExtrasToNode(expr, result);
  670. +            result = addOuterExtrasToNode(expr, result);
  671.          }
  672.  
  673.          return toSourceNode(result, expr);
  674. @@ -1663,7 +1810,7 @@
  675.          case Syntax.CatchClause:
  676.              withIndent(function () {
  677.                  result = [
  678. -                    'catch' + space + '(',
  679. +                    'catch', extrasOrSpace(stmt.extras && stmt.extras.between), '(',
  680.                      generateExpression(stmt.param, {
  681.                          precedence: Precedence.Sequence,
  682.                          allowIn: true,
  683. @@ -1707,9 +1854,9 @@
  684.                          allowIn: allowIn,
  685.                          allowCall: true
  686.                      }),
  687. -                    space,
  688. +                    spaceIfNoExtras(stmt.extras && stmt.extras.trailing),
  689.                      '=',
  690. -                    space,
  691. +                    spaceIfNoExtras(stmt.extras && stmt.extras.leading),
  692.                      generateExpression(stmt.init, {
  693.                          precedence: Precedence.Assignment,
  694.                          allowIn: allowIn,
  695. @@ -1754,7 +1901,7 @@
  696.                                  allowIn: allowIn
  697.                              })));
  698.                          } else {
  699. -                            result.push(',' + space, generateStatement(node, {
  700. +                            result.push(',' + spaceIfNoExtras(node.extras && node.extras.leading), generateStatement(node, {
  701.                                  allowIn: allowIn
  702.                              }));
  703.                          }
  704. @@ -1810,7 +1957,7 @@
  705.          case Syntax.SwitchStatement:
  706.              withIndent(function () {
  707.                  result = [
  708. -                    'switch' + space + '(',
  709. +                    'switch' + extrasOrSpace(stmt.extras && stmt.extras.between) + '(',
  710.                      generateExpression(stmt.discriminant, {
  711.                          precedence: Precedence.Sequence,
  712.                          allowIn: true,
  713. @@ -2052,7 +2199,7 @@
  714.          }
  715.  
  716.          if (stmt.extras) {
  717. -            result = addExtrasToNode(stmt, result);
  718. +            result = addOuterExtrasToNode(stmt, result);
  719.          }
  720.  
  721.          return toSourceNode(result, stmt);
  722. @@ -2150,7 +2297,6 @@
  723.          case Syntax.BinaryExpression:
  724.          case Syntax.CallExpression:
  725.          case Syntax.ConditionalExpression:
  726. -        case Syntax.EmptyExpression:
  727.          case Syntax.FunctionExpression:
  728.          case Syntax.Identifier:
  729.          case Syntax.Literal:
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!