function assertSameLine(token, nextToken) {
            errors.assert.sameLine({
                token: token,
                nextToken: nextToken,
                message: 'Newline before curly brace for block statement is disallowed'
            });
        }
Disallows newline before opening curly brace of all block statements.

Type: `Boolean` or `Array` or `Object`

Values:

- `true` always disallows newline before curly brace of block statements
- `Array` specifies block-type keywords after which newlines are disallowed before curly brace
    - Valid types include: `['if', 'else', 'try', 'catch', 'finally', 'do', 'while', 'for', 'function', 'class',
      'switch']`
- `Object`:
    - `value`: `true` or an Array
    - `allExcept`: Array of exceptions
       - `"multiLine"`: if the conditions span on multiple lines, require a new line before the curly brace

#### Example

```js
"disallowNewlineBeforeBlockStatements": true
```

##### Valid

```js
function good(){
    var obj = {
        val: true
    };

    return {
        data: obj
    };
}

if (cond){
    foo();
}

for (var e in elements){
    bar(e);
}

while (cond){
    foo();
}
```

##### Invalid

```js
function bad()
{
    var obj =
    {
        val: true
    };

    return {
        data: obj
    };
}

if (cond)
{
    foo();
}

for (var e in elements)
{
    bar(e);
}

while (cond)
{
    foo();
}
```

#### Example

```js
"disallowNewlineBeforeBlockStatements": ["if", "else", "for"]
```

##### Valid

```js
if (i > 0) {
    positive = true;
}

if (i < 0) {
    negative = true;
} else {
    negative = false;
}

for (var i = 0, len = myList.length; i < len; ++i) {
    newList.push(myList[i]);
}

// this is fine, since "function" wasn't configured
function myFunc(x)
{
    return x + 1;
}
```

##### Invalid

```js
if (i < 0)
{
    negative = true;
}

if (i < 0)
{
    negative = true;
}
else
{
    negative = false;
}

for (var i = 0, len = myList.length; i < len; ++i)
{
    newList.push(myList[i]);
}
```

#### Example

```js
"disallowNewlineBeforeBlockStatements": ["function", "while"]
```

##### Valid

```js
function myFunc(x) {
    return x + 1;
}

var z = function(x) {
    return x - 1;
}

// this is fine, since "for" wasn't configured
for (var i = 0, len = myList.length; i < len; ++i)
{
    newList.push(myList[i]);
}
```

##### Invalid

```js
function myFunc(x)
{
    return x + 1;
}

var z = function(x)
{
    return x - 1;
}
```

#### Example

```js
"disallowNewlineBeforeBlockStatements": {
    "value": true,
    "allExcept": ["multiLine"]
}
```

##### Valid

```js
function myFunc(x,
                y)
{
    return x + y;
}

function foo() {
    if (bar && baz &&
        bat)
    {
        return true;
    }
}
```

##### Invalid

```js
function myFunc(x,
                y) {
    return x + y;
}

function foo() {
    if (bar && baz &&
        bat) {
        return true;
    }
}
```