clang-format: [js] Support ES6 module exports.

[mprobst]

Properly handle exports followed by declarations ((default)? const, class, function, var).

[djasper]

lib/Format/TokenAnnotator.cpp

1762–1763

Line.First->isOneOf(Keywords.kw_import, tok::kw_export)

lib/Format/UnwrappedLineParser.cpp

737

I'd add:

if (Style.Language == FormatStyle::LK_JavaScript) {
  parseJavaScriptEs6ImportExport();
  return;
}
break;

here and not fall through or change the block below.

744–746

Line.First->isOneOf(Keywords.kw_import, tok::kw_export)

1612

Maybe assert instead of the comment?

1623

I'd probably use if statements instead of the switch. Seems a bit bad to mix switch and if (which you can't avoid because of Keywords):

if (FormatTok->isOneOf(tok::kw_const, tok::kw_class,
                       Keywords.kw_function, Keywords.kw_var))
  return; // Fall through to parsing the corresponding structure.

if (FormatTok->is(tok::kw_default)) {
  nextToken();
  return;
}

if (FormatTok->is(tok::l_brace)) {
  FormatTok->BlockKind = BK_Block;
  parseBracedList();
}

[mprobst]

Addressed comments.

lib/Format/TokenAnnotator.cpp

1762–1763

That wouldn't work in Java without reified generics. Nice :-)

lib/Format/UnwrappedLineParser.cpp

737

Done.

744–746

No longer needed.

1612

Done.

1623

Yeah, that's better indeed.

[djasper]

Submitted as r229865.

lib/Format/TokenAnnotator.cpp

if (Right.is(tok::l_paren) &&
         Left.isOneOf(Keywords.kw_returns, Keywords.kw_option))
       return true;
   } else if (Style.Language == FormatStyle::LK_JavaScript) {
     if (Left.is(Keywords.kw_var))
       return true;
     if (Right.is(TT_JsTypeColon))
       return false;
     if ((Left.is(tok::l_brace) || Right.is(tok::r_brace)) &&
-        Line.First->is(Keywords.kw_import))
+        (Line.First->is(Keywords.kw_import) ||
+         Line.First->is(tok::kw_export)))
       return false;
   } else if (Style.Language == FormatStyle::LK_Java) {
     if (Left.is(tok::r_square) && Right.is(tok::l_brace))
       return true;
     if (Left.is(TT_LambdaArrow) || Right.is(TT_LambdaArrow))
       return true;
     if (Left.is(Keywords.kw_synchronized) && Right.is(tok::l_paren))
       return Style.SpaceBeforeParens != FormatStyle::SBPO_Never;

lib/Format/UnwrappedLineParser.h

private:
   void parseAccessSpecifier();
   void parseEnum();
   void parseJavaEnumBody();
   void parseRecord();
   void parseObjCProtocolList();
   void parseObjCUntilAtEnd();
   void parseObjCInterfaceOrImplementation();
   void parseObjCProtocol();
-  void parseJavaScriptEs6Import();
+  void parseJavaScriptEs6ImportExport();
   bool tryToParseLambda();
   bool tryToParseLambdaIntroducer();
   void tryToParseJSFunction();
   void addUnwrappedLine();
   bool eof() const;
   void nextToken();
   void readToken();
   void flushComments(bool NewlineBeforeNext);

lib/Format/UnwrappedLineParser.cpp

if (FormatTok->Tok.is(tok::string_literal)) {
       nextToken();
       if (FormatTok->Tok.is(tok::l_brace)) {
         parseBlock(/*MustBeDeclaration=*/true, /*AddLevel=*/false);
         addUnwrappedLine();
         return;
       }
     }
     break;
+  case tok::kw_export:
   case tok::identifier:
     if (FormatTok->IsForEachMacro) {
       parseForOrWhileLoop();
       return;
     }
     if (Style.Language == FormatStyle::LK_JavaScript &&
-        FormatTok->is(Keywords.kw_import)) {
-      parseJavaScriptEs6Import();
+        (FormatTok->is(Keywords.kw_import) ||
+         FormatTok->is(tok::kw_export))) {
+      parseJavaScriptEs6ImportExport();
       return;
     }
     // In all other cases, parse the declaration.
     break;
   default:
     break;
   }
   do {
if (FormatTok->Tok.is(tok::semi)) {
     nextToken();
     return addUnwrappedLine();
   }
 
   addUnwrappedLine();
   parseObjCUntilAtEnd();
 }
 
-void UnwrappedLineParser::parseJavaScriptEs6Import() {
-  assert(FormatTok->is(Keywords.kw_import));
+void UnwrappedLineParser::parseJavaScriptEs6ImportExport() {
+  assert(FormatTok->isOneOf(Keywords.kw_import, tok::kw_export));
   nextToken();
-  if (FormatTok->is(tok::l_brace)) {
+  switch (FormatTok->Tok.getKind()) {
+  case tok::l_brace:
     FormatTok->BlockKind = BK_Block;
     parseBracedList();
+    break;
+  case tok::kw_default: // export default ...
+    nextToken();
+    return;
+  case tok::kw_const: // export const ...
+  case tok::kw_class: // export class {...}
+    return;
+  default:
+    if (FormatTok->isOneOf(Keywords.kw_function, Keywords.kw_var))
+      return; // export function ...
+    break;
   }
   while (!eof() && FormatTok->isNot(tok::semi) &&
          FormatTok->isNot(tok::l_brace)) {
     nextToken();
   }
 }
 
 LLVM_ATTRIBUTE_UNUSED static void printDebugInfo(const UnwrappedLine &Line,

unittests/Format/FormatTestJS.cpp

TEST_F(FormatTestJS, Modules) {
   verifyFormat("import {\n"
                "  X,\n"
                "  Y,\n"
                "} from 'some/long/module.js';",
                getGoogleJSStyleWithColumns(20));
   verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';");
   verifyFormat("import * as lib from 'some/module.js';");
   verifyFormat("var x = {\n  import: 1\n};\nx.import = 2;");
-  verifyFormat("export function fn() {\n  return 'fn';\n}");
+
+  verifyFormat("export function fn() {\n"
+               "  return 'fn';\n"
+               "}");
   verifyFormat("export const x = 12;");
   verifyFormat("export default class X {}");
+  verifyFormat("export {X, Y} from 'some/module.js';");
+  verifyFormat("export {\n"
+               "  X,\n"
+               "  Y,\n"
+               "} from 'some/module.js';");
+  verifyFormat("export class C {\n"
+               "  x: number;\n"
+               "  y: string;\n"
+               "}");
+  verifyFormat("export class X { y: number; }");
+  verifyFormat("export default class X { y: number }");
+  verifyFormat("export default function() {\n  return 1;\n}");
+  verifyFormat("export var x = 12;");
+  verifyFormat("export var x: number = 12;");
+  verifyFormat("export const y = {\n"
+               "  a: 1,\n"
+               "  b: 2\n"
+               "};");
 }
 
 } // end namespace tooling
 } // end namespace clang