test/tall/variable/local.stmt

40 columns                              |
>>> Short initializer.
var   a   =   1  ;
<<<
var a = 1;
>>> Split initializer.
var variableName = veryLongInitializerName;
<<<
var variableName =
    veryLongInitializerName;
>>> Split overflowing initializer.
var variableName = thisIsReallyQuiteAVeryLongVariableName;
<<<
var variableName =
    thisIsReallyQuiteAVeryLongVariableName;
>>> No split after keyword.
var thisIsReallyQuiteAVeryLongVariableName;
<<<
var thisIsReallyQuiteAVeryLongVariableName;
>>> Multiple unsplit variables with no initializers.
var a , b , c , d;
<<<
var a, b, c, d;
>>> Multiple split variables with no initializers.
var variableA, variableB, variableC, variableD;
<<<
var variableA,
    variableB,
    variableC,
    variableD;
>>> Multiple unsplit variables with initializers.
var x = 3, y = 4;
<<<
var x = 3, y = 4;
>>>
var x = 2, y;
<<<
var x = 2, y;
>>> Multiple split variables with initializers.
var x = initializer, y = initializer, z = initializer;
<<<
var x = initializer,
    y = initializer,
    z = initializer;
>>> Indent initializers if there are multiple variables.
var veryLongVariable1 = longishInitializer,
    short = value,
    veryLongVariable2 = longishInitializer;
<<<
var veryLongVariable1 =
        longishInitializer,
    short = value,
    veryLongVariable2 =
        longishInitializer;
>>> Final variable.
final  x  =  1  ;
<<<
final x = 1;
>>> Typed variable.
int  x  =  1  ;
<<<
int x = 1;
>>> Typed final variable.
final  int  x  =  1;
<<<
final int x = 1;
>>> Late variables.
{
  late  var  i  ;
  late  final  int  i  ;
  late  int  i  ;
}
<<<
{
  late var i;
  late final int i;
  late int i;
}
>>> Split after type name.
SomeVeryLongTypeName someLongVariableName;
<<<
SomeVeryLongTypeName
someLongVariableName;
>>> Split after type name with multiple variables.
SomeVeryLongTypeName someLongVariableName, another, third;
<<<
SomeVeryLongTypeName
someLongVariableName,
another,
third;
>>> Split in initializer without splitting after type.
int someLongVariableName = veryLong + initializer;
<<<
int someLongVariableName =
    veryLong + initializer;
>>> Split in initializers without splitting after type.
int someLongVariableName = longInitializerValue,
another = short, thirdLongVariable = anotherLongInitializer;
<<<
int someLongVariableName =
        longInitializerValue,
    another = short,
    thirdLongVariable =
        anotherLongInitializer;
>>> Split after type name and in initializer.
SomeVeryLongTypeName someLongVariableName = longInitializerValue;
<<<
SomeVeryLongTypeName
someLongVariableName =
    longInitializerValue;
>>> Split after type name and in initializers.
SomeVeryLongTypeName someLongVariableName = longInitializerValue,
another = short, thirdLongVariable = anotherLongInitializer;
<<<
SomeVeryLongTypeName
someLongVariableName =
    longInitializerValue,
another = short,
thirdLongVariable =
    anotherLongInitializer;
>>> Split in type name does not split before variable.
Generic<LongTypeArgument, AnotherLongTypeName> variable;
<<<
Generic<
  LongTypeArgument,
  AnotherLongTypeName
>
variable;
>>> Prefer to split at "=" over infix operator.
int variableName = argument * argument + argument;
<<<
int variableName =
    argument * argument + argument;
>>> Prefer block-like splitting for lists.
var variableName = [element, element, element];
<<<
var variableName = [
  element,
  element,
  element,
];
>>> No block-like splitting for empty lists.
var variableNameWithExactLength____ = [];
<<<
var variableNameWithExactLength____ =
    [];
>>> Prefer block-like splitting for maps.
var variableName = {1: element, 2: element, 3: element};
<<<
var variableName = {
  1: element,
  2: element,
  3: element,
};
>>> No block-like splitting for empty maps.
var variableNameWithExactLength____ = {};
<<<
var variableNameWithExactLength____ =
    {};
>>> Prefer block-like splitting for function calls.
var variableName = function(argument, argument);
<<<
var variableName = function(
  argument,
  argument,
);
>>> No block-like splitting for empty argument lists.
var variableNameExactLength = function();
<<<
var variableNameExactLength =
    function();
>>> No block-like splitting if function name doesn't fit.
var longVariableName = veryLongFunctionName(argument);
<<<
var longVariableName =
    veryLongFunctionName(argument);
>>> Prefer block-like splitting for constructor calls.
var variableName = new Thing(argument, argument);
<<<
var variableName = new Thing(
  argument,
  argument,
);
>>> Prefer block-like splitting for const constructor calls.
var variableName = const Thing(argument, argument);
<<<
var variableName = const Thing(
  argument,
  argument,
);
>>> Indent block if function name doesn't fit and arguments split.
var longVariableName = veryLongFunctionName(argument, another);
<<<
var longVariableName =
    veryLongFunctionName(
      argument,
      another,
    );
>>> Use block-like splitting for switch expressions.
var variableName = switch (value) { 1 => 'one', 2 => 'two' };
<<<
var variableName = switch (value) {
  1 => 'one',
  2 => 'two',
};
>>> Use block-like splitting for switch expressions with split values.
var variableName = switch ([longElement, longElement, longElement])
{ 1 => 'one', 2 => 'two' };
<<<
var variableName = switch ([
  longElement,
  longElement,
  longElement,
]) {
  1 => 'one',
  2 => 'two',
};
>>> Use block-like splitting for block-bodied function expressions.
var variableName = (parameter, parameter, parameter) { body; };
<<<
var variableName = (
  parameter,
  parameter,
  parameter,
) {
  body;
};
>>> Don't use block-like splitting for expression-bodied function expressions.
var variableName = (parameter, parameter, parameter) => body;
<<<
var variableName =
    (parameter, parameter, parameter) =>
        body;
>>> Use block-like splitting for parenthesized expressions whose inner does.
var variableName = ([element, element, element]);
<<<
var variableName = ([
  element,
  element,
  element,
]);
>>>
var variableName = (notDelimited + expression);
<<<
var variableName =
    (notDelimited + expression);
>>> Split all variables if an initializer has a split internally.
var a = 1, b = [element, element, element, element];
<<<
var a = 1,
    b = [
      element,
      element,
      element,
      element,
    ];
>>> Late local variable.
{
  late var x = 1;
  late int y = 2;
}
<<<
{
  late var x = 1;
  late int y = 2;
}
>>> Constant.
const  uptyped  =  123  ;
<<<
const uptyped = 123;
>>>
const  String  typed  =  'string'  ;
<<<
const String typed = 'string';
>>> With multiple variables, indent initializer block body.
SomeType a = () {body;}, b;
<<<
SomeType a = () {
      body;
    },
    b;