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

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.

750

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

1626

Maybe assert instead of the comment?

1636

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

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

lib/Format/UnwrappedLineParser.cpp

737

Done.

750

No longer needed.

1626

Done.

1636

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->isOneOf(Keywords.kw_import, 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

bool UnwrappedLineParser::parse() {
   } while (!PPLevelBranchIndex.empty());
 
   return StructuralError;
 }
 
 void UnwrappedLineParser::parseFile() {
   ScopedDeclarationState DeclarationState(
       *Line, DeclarationScopeStack,
-      /*MustBeDeclaration=*/ !Line->InPPDirective);
+      /*MustBeDeclaration=*/!Line->InPPDirective);
   parseLevel(/*HasOpeningBrace=*/false);
   // Make sure to format the remaining tokens.
   flushComments(true);
   addUnwrappedLine();
 }
 
 void UnwrappedLineParser::parseLevel(bool HasOpeningBrace) {
   bool SwitchLabelEncountered = false;
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:
+    if (Style.Language == FormatStyle::LK_JavaScript) {
+      parseJavaScriptEs6ImportExport();
+      return;
+    }
+    break;
   case tok::identifier:
     if (FormatTok->IsForEachMacro) {
       parseForOrWhileLoop();
       return;
     }
     if (Style.Language == FormatStyle::LK_JavaScript &&
         FormatTok->is(Keywords.kw_import)) {
-      parseJavaScriptEs6Import();
+      parseJavaScriptEs6ImportExport();
       return;
     }
     // In all other cases, parse the declaration.
     break;
   default:
     break;
   }
   do {
bool UnwrappedLineParser::tryToParseLambdaIntroducer() {
   return false;
 }
 
 void UnwrappedLineParser::tryToParseJSFunction() {
   nextToken();
 
   // Consume function name.
   if (FormatTok->is(tok::identifier))
-      nextToken();
 
   if (FormatTok->isNot(tok::l_paren))
     return;
   nextToken();
   while (FormatTok->isNot(tok::l_brace)) {
     // Err on the side of caution in order to avoid consuming the full file in
     // case of incomplete code.
     if (!FormatTok->isOneOf(tok::identifier, tok::comma, tok::r_paren,
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->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(); // export default ..., fall through after eating 'default'.
+    return;
+  }
+
   if (FormatTok->is(tok::l_brace)) {
     FormatTok->BlockKind = BK_Block;
     parseBracedList();
   }
+
   while (!eof() && FormatTok->isNot(tok::semi) &&
          FormatTok->isNot(tok::l_brace)) {
     nextToken();
   }
 }
 
 LLVM_ATTRIBUTE_UNUSED static void printDebugInfo(const UnwrappedLine &Line,
                                                  StringRef Prefix = "") {
   llvm::dbgs() << Prefix << "Line(" << Line.Level << ")"
                << (Line.InPPDirective ? " MACRO" : "") << ": ";
   for (std::list<UnwrappedLineNode>::const_iterator I = Line.Tokens.begin(),
                                                     E = Line.Tokens.end();
        I != E; ++I) {
     llvm::dbgs() << I->Tok->Tok.getName() << "[" << I->Tok->Type << "] ";
   }

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