clang-format: [JS] Only special case top level object literal assignments as enums.

[mprobst]

Summary

Top level object literals are treated as enums, and their k/v pairs are put on separate lines:

X.Y = {
  A: 1,
  B: 2
};

However assignments within blocks should not be affected:

function x() {
  y = {a:1, b:2};
}

This change fixes the second case.

[mprobst]

This is somewhat in "I have no idea what I'm doing territory", but seems to do what I want and I have tests to prove it. Please advise :-)

[djasper]

Looks good. Submitted as r239462.

lib/Format/TokenAnnotator.cpp

if ((Style.Language == FormatStyle::LK_Java ||
     return true;
 
   if (Style.Language == FormatStyle::LK_JavaScript) {
     // FIXME: This might apply to other languages and token kinds.
     if (Right.is(tok::char_constant) && Left.is(tok::plus) && Left.Previous &&
         Left.Previous->is(tok::char_constant))
       return true;
     if (Left.is(TT_DictLiteral) && Left.is(tok::l_brace) &&
-        Left.NestingLevel == 0 && Left.Previous &&
+        Line.Level == 0 && Left.Previous &&
         Left.Previous->is(tok::equal) &&
         Line.First->isOneOf(tok::identifier, Keywords.kw_import,
-                            tok::kw_export) &&
+                            tok::kw_export, tok::kw_const) &&
         // kw_var is a pseudo-token that's a tok::identifier, so matches above.
         !Line.First->is(Keywords.kw_var))
-      // Enum style object literal.
+      // Object literals on the top level of a file are treated as "enum-style".
+      // Each key/value pair is put on a separate line, instead of bin-packing.
       return true;
   } else if (Style.Language == FormatStyle::LK_Java) {
     if (Right.is(tok::plus) && Left.is(tok::string_literal) && Right.Next &&
         Right.Next->is(tok::string_literal))
       return true;
   }
 
   return false;

unittests/Format/FormatTestJS.cpp

verifyFormat("var obj = {\n"
                "    return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
                "  }\n"
                "};");
   // Simple object literal, as opposed to enum style below.
   verifyFormat("var obj = {a: 123};");
   // Enum style top level assignment.
   verifyFormat("X = {\n  a: 123\n};");
   verifyFormat("X.Y = {\n  a: 123\n};");
+  // But only on the top level, otherwise its a plain object literal assignment.
+  verifyFormat("function x() {\n"
+               "  y = {z: 1};\n"
+               "}");
   verifyFormat("x = foo && {a: 123};");
 
   // Arrow functions in object literals.
   verifyFormat("var x = {y: (a) => { return a; }};");
   verifyFormat("var x = {y: (a) => a};");
 
   // Computed keys.
   verifyFormat("var x = {[a]: 1, b: 2, [c]: 3};");