While AST (#5161)

* updated grammar

* tests

* add tests

Author: helixbass

lib/coffeescript/grammar.js

@@ -679,14 +679,14 @@ grammar =
   While: [
     o 'WhileSource Block',                      -> $1.addBody $2
     o 'WhileLineSource Block',                  -> $1.addBody $2
-    o 'Statement  WhileSource',                 -> $2.addBody LOC(1) Block.wrap([$1])
-    o 'Expression WhileSource',                 -> $2.addBody LOC(1) Block.wrap([$1])
+    o 'Statement  WhileSource',                 -> (Object.assign $2, postfix: yes).addBody LOC(1) Block.wrap([$1])
+    o 'Expression WhileSource',                 -> (Object.assign $2, postfix: yes).addBody LOC(1) Block.wrap([$1])
     o 'Loop',                                   -> $1
   ]
 
   Loop: [
-    o 'LOOP Block',                             -> new While(LOC(1) new BooleanLiteral 'true').addBody $2
-    o 'LOOP Expression',                        -> new While(LOC(1) new BooleanLiteral 'true').addBody LOC(2) Block.wrap [$2]
+    o 'LOOP Block',                             -> new While(LOC(1)(new BooleanLiteral 'true'), isLoop: yes).addBody $2
+    o 'LOOP Expression',                        -> new While(LOC(1)(new BooleanLiteral 'true'), isLoop: yes).addBody LOC(2) Block.wrap [$2]
   ]
 
   # Array, object, and range comprehensions, at the most generic level.

lib/coffeescript/nodes.js

@@ -3832,12 +3832,9 @@ exports.Elision = class Elision extends Base
 # it, all other loops can be manufactured. Useful in cases where you need more
 # flexibility or more speed than a comprehension can provide.
 exports.While = class While extends Base
-  constructor: (condition, options) ->
+  constructor: (@condition, {@invert, @guard, @isLoop} = {}) ->
     super()
 
-    @condition = if options?.invert then condition.invert() else condition
-    @guard     = options?.guard
-
   children: ['condition', 'guard', 'body']
 
   isStatement: YES
@@ -3878,12 +3875,26 @@ exports.While = class While extends Base
         else
           body = Block.wrap [new If @guard, body] if @guard
       body = [].concat @makeCode("\n"), (body.compileToFragments o, LEVEL_TOP), @makeCode("\n#{@tab}")
-    answer = [].concat @makeCode(set + @tab + "while ("), @condition.compileToFragments(o, LEVEL_PAREN),
+    answer = [].concat @makeCode(set + @tab + "while ("), @processedCondition().compileToFragments(o, LEVEL_PAREN),
       @makeCode(") {"), body, @makeCode("}")
     if @returns
       answer.push @makeCode "\n#{@tab}return #{rvar};"
     answer
 
+  processedCondition: ->
+    @processedConditionCache ?= if @invert then @condition.invert() else @condition
+
+  astType: -> 'WhileStatement'
+
+  astProperties: (o) ->
+    return
+      test: @condition.ast o, LEVEL_PAREN
+      body: @body.ast o, LEVEL_TOP
+      guard: @guard?.ast(o) ? null
+      inverted: !!@invert
+      postfix: !!@postfix
+      loop: !!@isLoop
+
 #### Op
 
 # Simple Arithmetic and logical operations. Performs some conversion from

lib/coffeescript/parser.js

@@ -511,6 +511,9 @@ exports.Rewriter = class Rewriter
     @scanTokens (token, i, tokens) ->
       return 1 if     token[2]
       return 1 unless token.generated or token.explicit
+      if token.fromThen and token[0] is 'INDENT'
+        token[2] = token.origin[2]
+        return 1
       if token[0] is '{' and nextLocation=tokens[i + 1]?[2]
         {first_line: line, first_column: column, range: [rangeIndex]} = nextLocation
       else if prevLocation = tokens[i - 1]?[2]

lib/coffeescript/rewriter.js

@@ -1775,22 +1775,125 @@ test "AST as expected for Elision node", ->
       type: 'StringLiteral'
       value: 'asdfqwer'
 
-# test "AST as expected for While node", ->
-#   testExpression 'loop 1',
-#     type: 'While'
-#     condition:
-#       type: 'BooleanLiteral'
-#       value: 'true'
-#       originalValue: 'true'   # TODO: This should probably be changed for Prettier.
-#     body:
-#       type: 'Value'
+test "AST as expected for While node", ->
+  testStatement 'loop 1',
+    type: 'WhileStatement'
+    test:
+      type: 'BooleanLiteral'
+      value: true
+    body:
+      type: 'BlockStatement'
+      body: [
+        type: 'ExpressionStatement'
+        expression: NUMBER 1
+      ]
+    guard: null
+    inverted: no
+    postfix: no
+    loop: yes
 
-#   testExpression 'while 1 < 2 then',
-#     type: 'While'
-#     condition:
-#       type: 'Op'
-#     body:
-#       type: 'Block'
+  testStatement 'while 1 < 2 then',
+    type: 'WhileStatement'
+    test:
+      type: 'BinaryExpression'
+    body:
+      type: 'BlockStatement'
+      body: []
+    guard: null
+    inverted: no
+    postfix: no
+    loop: no
+
+  testStatement 'while 1 < 2 then fn()',
+    type: 'WhileStatement'
+    test:
+      type: 'BinaryExpression'
+    body:
+      type: 'BlockStatement'
+      body: [
+        type: 'ExpressionStatement'
+        expression:
+          type: 'CallExpression'
+      ]
+    guard: null
+    inverted: no
+    postfix: no
+    loop: no
+
+  testStatement '''
+    x() until y
+  ''',
+    type: 'WhileStatement'
+    test: ID 'y'
+    body:
+      type: 'BlockStatement'
+      body: [
+        type: 'ExpressionStatement'
+        expression:
+          type: 'CallExpression'
+      ]
+    guard: null
+    inverted: yes
+    postfix: yes
+    loop: no
+
+  testStatement '''
+    until x when y
+      z++
+  ''',
+    type: 'WhileStatement'
+    test: ID 'x'
+    body:
+      type: 'BlockStatement'
+      body: [
+        type: 'ExpressionStatement'
+        expression:
+          type: 'UpdateExpression'
+      ]
+    guard: ID 'y'
+    inverted: yes
+    postfix: no
+    loop: no
+
+  testStatement '''
+    x while y when z
+  ''',
+    type: 'WhileStatement'
+    test: ID 'y'
+    body:
+      type: 'BlockStatement'
+      body: [
+        type: 'ExpressionStatement'
+        expression: ID 'x'
+      ]
+    guard: ID 'z'
+    inverted: no
+    postfix: yes
+    loop: no
+
+  testStatement '''
+    loop
+      a()
+      b++
+  ''',
+    type: 'WhileStatement'
+    test:
+      type: 'BooleanLiteral'
+    body:
+      type: 'BlockStatement'
+      body: [
+        type: 'ExpressionStatement'
+        expression:
+          type: 'CallExpression'
+      ,
+        type: 'ExpressionStatement'
+        expression:
+          type: 'UpdateExpression'
+      ]
+    guard: null
+    inverted: no
+    postfix: no
+    loop: yes
 
 test "AST as expected for Op node", ->
   testExpression 'a <= 2',