clang-format: [JS] Introduce WrapJavaScriptImports option.

[mprobst]

Summary

When turned on, clang-format wraps JavaScript imports (and importing exports),
instead of forcing the entire import statement onto one line.

[djasper]

include/clang/Format/Format.h

631

Wondering whether we should call this JavaScriptWrapImports so that the JS-specific options stay together. What do you think?

[mprobst]

• rename to JavaScriptWrapImports
• re-alphabetize options list

[djasper]

lib/Format/TokenAnnotator.cpp

789

I think it is a bit dodgy to not mark the line as import statement based on this style option. Would it be a lot of work to pull the decision of whether or not to format this out a level higher?

[mprobst]

• classify as LT_ImportStatement, re-enable wrapping later
• no early exist in TokenAnnotator: while loop is required for consumeToken().

[djasper]

Looks good.

include/clang/Format/Format.h

enum JavaScriptQuoteStyle {
     JSQS_Single,
     /// Always use double quotes.
     JSQS_Double
   };
 
   /// \brief The JavaScriptQuoteStyle to use for JavaScript strings.
   JavaScriptQuoteStyle JavaScriptQuotes;
 
+  /// \brief Whether to wrap JavaScript import/export statements.
+  bool WrapJavaScriptImports;
+
   bool operator==(const FormatStyle &R) const {
     return AccessModifierOffset == R.AccessModifierOffset &&
            AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
            AlignConsecutiveAssignments == R.AlignConsecutiveAssignments &&
            AlignConsecutiveDeclarations == R.AlignConsecutiveDeclarations &&
            AlignEscapedNewlinesLeft == R.AlignEscapedNewlinesLeft &&
            AlignOperands == R.AlignOperands &&
            AlignTrailingComments == R.AlignTrailingComments &&

lib/Format/Format.cpp

static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("SpacesInCStyleCastParentheses",
                    Style.SpacesInCStyleCastParentheses);
     IO.mapOptional("SpacesInParentheses", Style.SpacesInParentheses);
     IO.mapOptional("SpacesInSquareBrackets", Style.SpacesInSquareBrackets);
     IO.mapOptional("Standard", Style.Standard);
     IO.mapOptional("TabWidth", Style.TabWidth);
     IO.mapOptional("UseTab", Style.UseTab);
     IO.mapOptional("JavaScriptQuotes", Style.JavaScriptQuotes);
+    IO.mapOptional("WrapJavaScriptImports", Style.WrapJavaScriptImports);
   }
 };
 
 template <> struct MappingTraits<FormatStyle::BraceWrappingFlags> {
   static void mapping(IO &IO, FormatStyle::BraceWrappingFlags &Wrapping) {
     IO.mapOptional("AfterClass", Wrapping.AfterClass);
     IO.mapOptional("AfterControlStatement", Wrapping.AfterControlStatement);
     IO.mapOptional("AfterEnum", Wrapping.AfterEnum);
if (Language == FormatStyle::LK_Java) {
     GoogleStyle.AlignOperands = false;
     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
     GoogleStyle.AlwaysBreakBeforeMultilineStrings = false;
     GoogleStyle.BreakBeforeTernaryOperators = false;
     GoogleStyle.CommentPragmas = "@(export|return|see|visibility) ";
     GoogleStyle.MaxEmptyLinesToKeep = 3;
     GoogleStyle.SpacesInContainerLiterals = false;
     GoogleStyle.JavaScriptQuotes = FormatStyle::JSQS_Single;
+    GoogleStyle.WrapJavaScriptImports = false;
   } else if (Language == FormatStyle::LK_Proto) {
     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
     GoogleStyle.SpacesInContainerLiterals = false;
   }
 
   return GoogleStyle;
 }
 

lib/Format/TokenAnnotator.cpp

if (Style.Language == FormatStyle::LK_Proto && Line.Level == 0 &&
         CurrentToken->is(Keywords.kw_option)) {
       next();
       if (CurrentToken && CurrentToken->is(tok::identifier))
         return LT_ImportStatement;
     }
 
     // import {...} from '...';
     if (Style.Language == FormatStyle::LK_JavaScript &&
-        CurrentToken->is(Keywords.kw_import))
+        CurrentToken->is(Keywords.kw_import) && !Style.WrapJavaScriptImports)
       return LT_ImportStatement;
 
     bool KeywordVirtualFound = false;
     bool ImportStatement = false;
     while (CurrentToken) {
       if (CurrentToken->is(tok::kw_virtual))
         KeywordVirtualFound = true;
       if (Style.Language == FormatStyle::LK_JavaScript) {
         // export {...} from '...';
         // An export followed by "from 'some string';" is a re-export from
         // another module identified by a URI and is treated as a
         // LT_ImportStatement (i.e. prevent wraps on it for long URIs).
         // Just "export {...};" or "export class ..." should not be treated as
         // an import in this sense.
         if (Line.First->is(tok::kw_export) &&
             CurrentToken->is(Keywords.kw_from) && CurrentToken->Next &&
             CurrentToken->Next->isStringLiteral())
-          ImportStatement = true;
+          ImportStatement = !Style.WrapJavaScriptImports;
         if (isClosureImportStatement(*CurrentToken))
           ImportStatement = true;
       }
       if (!consumeToken())
         return LT_Invalid;
     }
     if (KeywordVirtualFound)
       return LT_VirtualFunctionDecl;

unittests/Format/FormatTestJS.cpp

TEST_F(FormatTestJS, Modules) {
   verifyFormat("export default [];");
   verifyFormat("export default () => {};");
   verifyFormat("export interface Foo { foo: number; }\n"
                "export class Bar {\n"
                "  blah(): string { return this.blah; };\n"
                "}");
 }
 
+TEST_F(FormatTestJS, ImportWrapping) {
+  FormatStyle Style = getGoogleJSStyleWithColumns(80);
+  Style.WrapJavaScriptImports = true;
+  verifyFormat("import {\n"
+               "  VeryLongImportsAreAnnoying,\n"
+               "  VeryLongImportsAreAnnoying,\n"
+               "  VeryLongImportsAreAnnoying,\n"
+               "} from 'some/module.js';",
+               Style);
+  verifyFormat("import {\n"
+               "  A,\n"
+               "  A,\n"
+               "} from 'some/module.js';",
+               Style);
+  verifyFormat("export {\n"
+               "  A,\n"
+               "  A,\n"
+               "} from 'some/module.js';",
+               Style);
+}
+
 TEST_F(FormatTestJS, TemplateStrings) {
   // Keeps any whitespace/indentation within the template string.
   verifyFormat("var x = `hello\n"
             "     ${  name    }\n"
             "  !`;",
             "var x    =    `hello\n"
                    "     ${  name    }\n"
                    "  !`;");