@1999:

Oh, nice catch. I've misunderstood LetStatement can be represented as the following form.
```js
let (i = 10) for (...) { }
```

So LetStatement's body is specialized for some kind of Statement, `BlockStatement` and `ForStatement`.
And I'm not sure why `ForInStatement` is not specialized.
I've found that `for (let i in []);` is parsed as,
```js
{
  "loc": {
    "start": {
      "line": 1,
      "column": 0
    },
    "end": {
      "line": 1,
      "column": 28
    },
    "source": null
  },
  "type": "Program",
  "body": [
    {
      "loc": {
        "start": {
          "line": 1,
          "column": 0
        },
        "end": {
          "line": 1,
          "column": 28
        },
        "source": null
      },
      "type": "LetStatement",
      "head": [
        {
          "loc": {
            "start": {
              "line": 1,
              "column": 9
            },
            "end": {
              "line": 1,
              "column": 14
            },
            "source": null
          },
          "type": "VariableDeclarator",
          "id": {
            "loc": {
              "start": {
                "line": 1,
                "column": 9
              },
              "end": {
                "line": 1,
                "column": 14
              },
              "source": null
            },
            "type": "Identifier",
            "name": "i"
          },
          "init": {
            "loc": {
              "start": {
                "line": 1,
                "column": 13
              },
              "end": {
                "line": 1,
                "column": 14
              },
              "source": null
            },
            "type": "Literal",
            "value": 0
          }
        }
      ],
      "body": {
        "loc": {
          "start": {
            "line": 1,
            "column": 0
          },
          "end": {
            "line": 1,
            "column": 28
          },
          "source": null
        },
        "type": "ForStatement",
        "init": null,
        "test": {
          "loc": {
            "start": {
              "line": 1,
              "column": 16
            },
            "end": {
              "line": 1,
              "column": 21
            },
            "source": null
          },
          "type": "BinaryExpression",
          "operator": "<",
          "left": {
            "loc": {
              "start": {
                "line": 1,
                "column": 16
              },
              "end": {
                "line": 1,
                "column": 17
              },
              "source": null
            },
            "type": "Identifier",
            "name": "i"
          },
          "right": {
            "loc": {
              "start": {
                "line": 1,
                "column": 20
              },
              "end": {
                "line": 1,
                "column": 21
              },
              "source": null
            },
            "type": "Literal",
            "value": 0
          }
        },
        "update": {
          "loc": {
            "start": {
              "line": 1,
              "column": 23
            },
            "end": {
              "line": 1,
              "column": 26
            },
            "source": null
          },
          "type": "UpdateExpression",
          "operator": "++",
          "argument": {
            "loc": {
              "start": {
                "line": 1,
                "column": 25
              },
              "end": {
                "line": 1,
                "column": 26
              },
              "source": null
            },
            "type": "Identifier",
            "name": "i"
          },
          "prefix": true
        },
        "body": {
          "loc": {
            "start": {
              "line": 1,
              "column": 27
            },
            "end": {
              "line": 1,
              "column": 28
            },
            "source": null
          },
          "type": "EmptyStatement"
        }
      }
    }
  ]
}
```
I think it lacks consistency.
So do you know which statement can be used for `body` of `LetStatement`? To implement `LetStatement`, we need to know all forms of `LetStatement`, but currently I don't know them.

I suggest splitting this patch to `LetExpression` and `LetStatement`. `LetExpression` part seems mature. It can be merged soon :)

@getify:
> I'm not sure why let in a for loop needs special structural parsing handling. There may not be clarity yet on what the parse tree should be, but I don't think it'll even remotely end up being like a structural transpilation as we explored.

> I imagine the parse tree will be just like a normal for loop, except:

Maybe, this is the implementation detail of SpiderMonkey. Is it correct? @DavidBruant
I agree with you, I also think current form is not suitable for AST.

In the meantime, we may support SpiderMonkey's `LetStatement` generation, but I think filing issue to SpiderMonkey and submitting patch to fix it at the same time is better.
After the change is landed to SpiderMonkey, we'll drop the support for old `LetStatement` form.