Merge pull request #7582 from bitjammer/sr-3989-syntax-fallthrough-stmt

[Syntax] Implement fallthrough-statement

Author: bitjammer

include/swift/Syntax/StmtSyntax.h

@@ -48,7 +48,7 @@ class StmtSyntaxData : public SyntaxData {
 ///            | compiler-control-statement ';'?
 class StmtSyntax : public Syntax {
 protected:
-  StmtSyntax(RC<SyntaxData> Root, StmtSyntaxData *Data);
+  StmtSyntax(const RC<SyntaxData> Root, const StmtSyntaxData *Data);
 public:
   static bool classof(const Syntax *S) {
     return S->isStmt();
@@ -189,7 +189,7 @@ class FallthroughStmtSyntaxData final : public StmtSyntaxData {
 
 public:
   static bool classof(const SyntaxData *SD) {
-    return SD->getKind() == SyntaxKind::StmtList;
+    return SD->getKind() == SyntaxKind::FallthroughStmt;
   }
 };
 
@@ -198,20 +198,34 @@ class FallthroughStmtSyntaxData final : public StmtSyntaxData {
 
 class FallthroughStmtSyntax : public StmtSyntax {
   friend struct SyntaxFactory;
+  friend class SyntaxData;
+  friend class FallthroughStmtSyntaxData;
+
+  using DataType = FallthroughStmtSyntaxData;
 
   enum class Cursor : CursorIndex {
     FallthroughKeyword,
   };
 
   FallthroughStmtSyntax(const RC<SyntaxData> Root,
-                        FallthroughStmtSyntaxData *Data);
+                        const FallthroughStmtSyntaxData *Data);
 
   static FallthroughStmtSyntax make(RC<RawSyntax> Raw,
                                     const SyntaxData *Parent = nullptr,
                                     CursorIndex IndexInParent = 0);
   static FallthroughStmtSyntax makeBlank();
 
 public:
+
+  /// Get the 'fallthrough' keyword associated comprising this
+  /// fallthrough statement.
+  RC<TokenSyntax> getFallthroughKeyword() const;
+
+  /// Return a new FallthroughtStmtSyntax with the given fallthrough
+  /// keyword.
+  FallthroughStmtSyntax
+  withFallthroughKeyword(RC<TokenSyntax> NewFallthroughKeyword) const;
+
   static bool classof(const Syntax *S) {
     return S->getKind() == SyntaxKind::FallthroughStmt;
   }

include/swift/Syntax/SyntaxFactory.h

@@ -108,6 +108,11 @@ struct SyntaxFactory {
 
 #pragma mark - Tokens
 
+  /// Make a 'fallthrough' keyword with the specified leading and
+  /// trailing trivia.
+  static RC<TokenSyntax> makeFallthroughKeyword(const Trivia &LeadingTrivia,
+                                                const Trivia &TrailingTrivia);
+
   /// Make an at-sign '@' token with the specified leading and
   /// trailing trivia.
   static RC<TokenSyntax> makeAtSignToken(const Trivia &LeadingTrivia,

lib/Syntax/StmtSyntax.cpp

@@ -16,15 +16,21 @@
 using namespace swift;
 using namespace swift::syntax;
 
-StmtSyntax::StmtSyntax(RC<SyntaxData> Root, StmtSyntaxData *Data)
+StmtSyntax::StmtSyntax(const RC<SyntaxData> Root, const StmtSyntaxData *Data)
   : Syntax(Root, Data) {}
 
 #pragma mark fallthrough-statement Data
 
 FallthroughStmtSyntaxData::FallthroughStmtSyntaxData(RC<RawSyntax> Raw,
                                                      const SyntaxData *Parent,
                                                      CursorIndex IndexInParent)
- : StmtSyntaxData(Raw, Parent, IndexInParent) {}
+ : StmtSyntaxData(Raw, Parent, IndexInParent) {
+   assert(Raw->Kind == SyntaxKind::FallthroughStmt);
+   assert(Raw->Layout.size() == 1);
+   syntax_assert_child_token_text(Raw,
+      FallthroughStmtSyntax::Cursor::FallthroughKeyword,
+      tok::kw_fallthrough, "fallthrough");
+}
 
 RC<FallthroughStmtSyntaxData>
 FallthroughStmtSyntaxData::make(RC<RawSyntax> Raw,
@@ -45,8 +51,9 @@ RC<FallthroughStmtSyntaxData> FallthroughStmtSyntaxData::makeBlank() {
 
 #pragma mark fallthrough-statement API
 
-FallthroughStmtSyntax::FallthroughStmtSyntax(const RC<SyntaxData> Root,
-                                             FallthroughStmtSyntaxData *Data)
+FallthroughStmtSyntax::
+FallthroughStmtSyntax(const RC<SyntaxData> Root,
+                      const FallthroughStmtSyntaxData *Data)
     : StmtSyntax(Root, Data) {}
 
 FallthroughStmtSyntax
@@ -62,6 +69,19 @@ FallthroughStmtSyntax::make(RC<RawSyntax> Raw, const SyntaxData *Parent,
   };
 }
 
+RC<TokenSyntax> FallthroughStmtSyntax::getFallthroughKeyword() const {
+  return cast<TokenSyntax>(getRaw()->getChild(Cursor::FallthroughKeyword));
+}
+
+FallthroughStmtSyntax FallthroughStmtSyntax::
+withFallthroughKeyword(RC<TokenSyntax> NewFallthroughKeyword) const {
+  syntax_assert_token_is(NewFallthroughKeyword, tok::kw_fallthrough,
+                         "fallthrough");
+  return Data->replaceChild<FallthroughStmtSyntax>(NewFallthroughKeyword,
+                                                   Cursor::FallthroughKeyword);
+}
+
+
 CodeBlockStmtSyntaxData::CodeBlockStmtSyntaxData(RC<RawSyntax> Raw)
   : StmtSyntaxData(Raw) {
     assert(Raw->Kind == SyntaxKind::CodeBlockStmt);

lib/Syntax/SyntaxFactory.cpp

@@ -250,8 +250,16 @@ FallthroughStmtSyntax SyntaxFactory::makeBlankFallthroughStmt() {
 #pragma mark - Tokens
 
 RC<TokenSyntax>
-SyntaxFactory::makeAtSignToken(const swift::syntax::Trivia &LeadingTrivia,
-                               const swift::syntax::Trivia &TrailingTrivia) {
+SyntaxFactory::makeFallthroughKeyword(const Trivia &LeadingTrivia,
+                                      const Trivia &TrailingTrivia) {
+  return TokenSyntax::make(tok::kw_fallthrough, "fallthrough",
+                           SourcePresence::Present,
+                           LeadingTrivia, TrailingTrivia);
+}
+
+RC<TokenSyntax>
+SyntaxFactory::makeAtSignToken(const Trivia &LeadingTrivia,
+                               const Trivia &TrailingTrivia) {
   return TokenSyntax::make(tok::at_sign, "@", SourcePresence::Present,
                            LeadingTrivia, TrailingTrivia);
 }

unittests/Syntax/StmtSyntaxTests.cpp

@@ -0,0 +1,75 @@
+#include "swift/Syntax/SyntaxFactory.h"
+#include "swift/Syntax/StmtSyntax.h"
+#include "llvm/ADT/SmallString.h"
+#include "gtest/gtest.h"
+
+using namespace swift;
+using namespace swift::syntax;
+
+#pragma mark - fallthrough-statement
+
+TEST(StmtSyntaxTests, FallthroughStmtGetAPIs) {
+  llvm::SmallString<48> Scratch;
+  llvm::raw_svector_ostream OS(Scratch);
+
+  auto FallthroughKW = SyntaxFactory::makeFallthroughKeyword({}, {});
+
+  auto Fallthrough = SyntaxFactory::makeBlankFallthroughStmt()
+    .withFallthroughKeyword(FallthroughKW);
+
+  /// This should be directly shared through reference-counting.
+  ASSERT_EQ(FallthroughKW, Fallthrough.getFallthroughKeyword());
+}
+
+TEST(StmtSyntaxTests, FallthroughStmtWithAPIs) {
+  llvm::SmallString<48> Scratch;
+  llvm::raw_svector_ostream OS(Scratch);
+
+  auto FallthroughKW = SyntaxFactory::makeFallthroughKeyword({}, {});
+
+  SyntaxFactory::makeBlankFallthroughStmt()
+    .withFallthroughKeyword(FallthroughKW)
+    .print(OS);
+
+  ASSERT_EQ(OS.str().str(), "fallthrough");
+}
+
+TEST(StmtSyntaxTests, FallthroughStmtMakeAPIs) {
+  auto FallthroughKW = SyntaxFactory::makeFallthroughKeyword({}, {});
+
+  {
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+
+    SyntaxFactory::makeFallthroughStmt(FallthroughKW).print(OS);
+    ASSERT_EQ(OS.str().str(), "fallthrough");
+  }
+
+  {
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+
+    FallthroughKW = FallthroughKW->withLeadingTrivia(Trivia::spaces(2));
+
+    SyntaxFactory::makeFallthroughStmt(FallthroughKW).print(OS);
+    ASSERT_EQ(OS.str().str(), "  fallthrough");
+  }
+
+  {
+    llvm::SmallString<48> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+
+    FallthroughKW = FallthroughKW->withTrailingTrivia(Trivia::spaces(2));
+
+    SyntaxFactory::makeFallthroughStmt(FallthroughKW).print(OS);
+    ASSERT_EQ(OS.str().str(), "  fallthrough  ");
+  }
+
+  {
+    llvm::SmallString<1> Scratch;
+    llvm::raw_svector_ostream OS(Scratch);
+
+    SyntaxFactory::makeBlankFallthroughStmt().print(OS);
+    ASSERT_EQ(OS.str().str(), "");
+  }
+}