[Syntax] Allow UnknownSyntax to have children

include/swift/Syntax/DeclSyntax.h

@@ -25,6 +25,7 @@
 #include "swift/Syntax/SyntaxData.h"
 #include "swift/Syntax/TokenSyntax.h"
 #include "swift/Syntax/TypeSyntax.h"
+#include "swift/Syntax/UnknownSyntax.h"
 
 #include "llvm/ADT/BitVector.h"
 
@@ -56,7 +57,7 @@ class DeclSyntax : public Syntax {
 
 #pragma mark - unknown-declaration Data
 
-class UnknownDeclSyntaxData : public DeclSyntaxData {
+class UnknownDeclSyntaxData : public UnknownSyntaxData {
   UnknownDeclSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
                         CursorIndex IndexInParent = 0);
 public:
@@ -71,7 +72,7 @@ class UnknownDeclSyntaxData : public DeclSyntaxData {
 
 #pragma mark - unknown-declaration API
 
-class UnknownDeclSyntax : public DeclSyntax {
+class UnknownDeclSyntax : public UnknownSyntax {
   friend class SyntaxData;
   friend class UnknownStmtSyntaxData;
   friend class LegacyASTTransformer;

include/swift/Syntax/ExprSyntax.h

@@ -23,6 +23,7 @@
 #include "swift/Syntax/Syntax.h"
 #include "swift/Syntax/SyntaxData.h"
 #include "swift/Syntax/TokenSyntax.h"
+#include "swift/Syntax/UnknownSyntax.h"
 
 using llvm::Optional;
 
@@ -61,7 +62,7 @@ class ExprSyntax : public Syntax {
 
 #pragma mark - unknown-expression Data
 
-class UnknownExprSyntaxData : public ExprSyntaxData {
+class UnknownExprSyntaxData : public UnknownSyntaxData {
   UnknownExprSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
                         CursorIndex IndexInParent = 0);
 public:
@@ -76,17 +77,17 @@ class UnknownExprSyntaxData : public ExprSyntaxData {
 
 #pragma mark - unknown-expression API
 
-class UnknownExprSyntax : public ExprSyntax {
+class UnknownExprSyntax : public UnknownSyntax {
   friend class SyntaxData;
   friend class UnknownExprSyntaxData;
   friend class LegacyASTTransformer;
 
   using DataType = UnknownExprSyntaxData;
 
+public:
   UnknownExprSyntax(const RC<SyntaxData> Root,
                     const UnknownExprSyntaxData *Data);
 
-public:
   static bool classof(const Syntax *S) {
     return S->getKind() == SyntaxKind::UnknownExpr;
   }
@@ -333,13 +334,14 @@ class FunctionCallArgumentListSyntaxData : public SyntaxData {
 /// function-call-argument-list -> function-call-argument
 ///                                function-call-argument-list?
 class FunctionCallArgumentListSyntax : public Syntax {
-  using DataType = FunctionCallArgumentListSyntaxData;
   friend struct SyntaxFactory;
   friend class FunctionCallArgumentListSyntaxData;
   friend class FunctionCallExprSyntax;
   friend class Syntax;
   friend class SyntaxData;
 
+  using DataType = FunctionCallArgumentListSyntaxData;
+
   FunctionCallArgumentListSyntax(const RC<SyntaxData> Root,
                                  const DataType *Data);
 
@@ -356,7 +358,7 @@ class FunctionCallArgumentListSyntax : public Syntax {
   withAdditionalArgument(FunctionCallArgumentSyntax AdditionalArgument) const;
 
   static bool classof(const Syntax *S) {
-    return S->getKind() == SyntaxKind::FunctionCallExpr;
+    return S->getKind() == SyntaxKind::FunctionCallArgumentList;
   }
 };
 

include/swift/Syntax/GenericSyntax.h

@@ -435,6 +435,7 @@ class GenericArgumentClauseSyntax : public Syntax {
   friend class GenericArgumentClauseBuilder;
   friend class SymbolicReferenceExprSyntax;
   friend class SyntaxData;
+  friend class Syntax;
 
   using DataType = GenericArgumentClauseSyntaxData;
 

include/swift/Syntax/RawSyntax.h

@@ -235,6 +235,18 @@ struct RawSyntax : public llvm::ThreadSafeRefCountedBase<RawSyntax> {
     return Kind >= SyntaxKind::First_Expr && Kind <= SyntaxKind::Last_Expr;
   }
 
+  /// Return true if this raw syntax node is a token.
+  bool isToken() const {
+    return Kind == SyntaxKind::Token;
+  }
+
+  bool isUnknown() const {
+    return Kind == SyntaxKind::Unknown ||
+           Kind == SyntaxKind::UnknownDecl ||
+           Kind == SyntaxKind::UnknownExpr ||
+           Kind == SyntaxKind::UnknownStmt;
+  }
+
   /// Get the absolute position of this raw syntax: its offset, line,
   /// and column.
   AbsolutePosition getAbsolutePosition(RC<RawSyntax> Root) const;

include/swift/Syntax/Rewriter.h

@@ -27,6 +27,7 @@
 #include "swift/Syntax/ExprSyntax.h"
 #include "swift/Syntax/StmtSyntax.h"
 #include "swift/Syntax/Syntax.h"
+#include "swift/Syntax/UnknownSyntax.h"
 
 namespace swift {
 namespace syntax {

include/swift/Syntax/StmtSyntax.h

@@ -22,6 +22,7 @@
 #include "swift/Syntax/References.h"
 #include "swift/Syntax/Syntax.h"
 #include "swift/Syntax/SyntaxData.h"
+#include "swift/Syntax/UnknownSyntax.h"
 
 using llvm::Optional;
 
@@ -66,7 +67,7 @@ class StmtSyntax : public Syntax {
 
 #pragma mark - unknown-statement Data
 
-class UnknownStmtSyntaxData : public StmtSyntaxData {
+class UnknownStmtSyntaxData : public UnknownSyntaxData {
   UnknownStmtSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
                         CursorIndex IndexInParent = 0);
 public:
@@ -81,12 +82,12 @@ class UnknownStmtSyntaxData : public StmtSyntaxData {
 
 #pragma mark - unknown-statement API
 
-class UnknownStmtSyntax : public StmtSyntax {
+class UnknownStmtSyntax : public UnknownSyntax {
   friend class SyntaxData;
   friend class UnknownStmtSyntaxData;
   friend class LegacyASTTransformer;
 
-  using DataType = UnknownExprSyntaxData;
+  using DataType = UnknownStmtSyntaxData;
 
   UnknownStmtSyntax(const RC<SyntaxData> Root,
                     const UnknownStmtSyntaxData *Data);

include/swift/Syntax/Syntax.h

@@ -39,7 +39,6 @@ namespace syntax {
 const auto NoParent = llvm::None;
 
 class SyntaxData;
-class UnknownSyntaxData;
 
 /// The main handle for syntax nodes - subclasses contain all public
 /// structured editing APIs.
@@ -138,6 +137,9 @@ class Syntax {
   /// Returns true if this syntax node represents a type.
   bool isType() const;
 
+  /// Returns true if this syntax is of some "unknown" kind.
+  bool isUnknown() const;
+
   /// Print the syntax node with full fidelity to the given output stream.
   void print(llvm::raw_ostream &OS) const;
 
@@ -155,19 +157,6 @@ class Syntax {
   // TODO: hasSameStructureAs ?
 };
 
-/// A chunk of "unknown" syntax - effectively a sequence of tokens.
-class UnknownSyntax final : public Syntax {
-  friend struct SyntaxFactory;
-
-  UnknownSyntax(const RC<SyntaxData> Root, UnknownSyntaxData *Data);
-  static UnknownSyntax make(RC<RawSyntax> Raw);
-
-public:
-  static bool classof(const Syntax *S) {
-    return S->getKind() == SyntaxKind::Unknown;
-  }
-};
-
 } // end namespace syntax
 } // end namespace swift
 

include/swift/Syntax/SyntaxData.h

@@ -242,28 +242,14 @@ class SyntaxData : public llvm::ThreadSafeRefCountedBase<SyntaxData> {
   /// Returns true if the data node represents expression syntax.
   bool isExpr() const;
 
+  /// Returns true if this syntax is of some "unknown" kind.
+  bool isUnknown() const;
+
   /// Dump a debug description of the syntax data for debugging to
   /// standard error.
   void dump(llvm::raw_ostream &OS) const;
 };
 
-class UnknownSyntaxData final : public SyntaxData {
-  friend class SyntaxData;
-  friend class UnknownSyntax;
-  friend struct SyntaxFactory;
-  friend class LegacyASTTransformer;
-
-  UnknownSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
-                    CursorIndex IndexInParent = 0)
-    : SyntaxData(Raw, Parent, IndexInParent) {}
-
-  static RC<UnknownSyntaxData> make(RC<RawSyntax> Raw,
-                                    const SyntaxData *Parent = nullptr,
-                                    CursorIndex IndexInParent = 0);
-public:
-  static bool classof(const SyntaxData *SD);
-};
-
 } // end namespace syntax
 } // end namespace swift
 

include/swift/Syntax/SyntaxFactory.h

@@ -152,7 +152,7 @@ struct SyntaxFactory {
   /// Make a function call argument list with the given arguments.
   static FunctionCallArgumentListSyntax
   makeFunctionCallArgumentList(
-    std::vector<FunctionCallArgumentSyntax> &Arguments);
+    std::vector<FunctionCallArgumentSyntax> Arguments);
 
   /// Make a function call argument list with no arguments.
   static FunctionCallArgumentListSyntax makeBlankFunctionCallArgumentList();

include/swift/Syntax/SyntaxKinds.def

@@ -99,7 +99,6 @@ SYNTAX(FunctionTypeArgument, Syntax)
 SYNTAX(FunctionCallArgumentList, Syntax)
 SYNTAX(FunctionCallArgument, Syntax)
 
-
 #undef ABSTRACT_SYNTAX
 #undef DECL
 #undef STMT

include/swift/Syntax/UnknownSyntax.h

@@ -0,0 +1,89 @@
+//===--- UnknownSyntax.h - Swift Unknown Syntax Interface -----------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SYNTAX_UNKNOWNSYNTAX_H
+#define SWIFT_SYNTAX_UNKNOWNSYNTAX_H
+
+#include "swift/Syntax/SyntaxData.h"
+#include "swift/Syntax/Syntax.h"
+
+#include <vector>
+
+namespace swift {
+namespace syntax {
+
+#pragma mark unknown-syntax Data
+
+class UnknownSyntaxData : public SyntaxData {
+  friend class SyntaxData;
+  friend class UnknownSyntax;
+  friend struct SyntaxFactory;
+  friend class LegacyASTTransformer;
+
+protected:
+  std::vector<RC<SyntaxData>> CachedChildren;
+
+  UnknownSyntaxData(const RC<RawSyntax> Raw,
+                    const SyntaxData *Parent = nullptr,
+                    const CursorIndex IndexInParent = 0);
+public:
+
+  static RC<UnknownSyntaxData> make(RC<RawSyntax> Raw,
+                                    const SyntaxData *Parent = nullptr,
+                                    CursorIndex IndexInParent = 0);
+
+  size_t getNumChildren() const {
+    return CachedChildren.size();
+  }
+
+  /// Get the child at the given Index.
+  ///
+  /// Precondition: Index <= getNumChildren();
+  Syntax getChild(size_t Index) const;
+
+  static bool classof(const SyntaxData *SD) {
+    return SD->isUnknown();
+  }
+};
+
+#pragma mark unknown-syntax API
+
+/// A chunk of "unknown" syntax.
+///
+/// Effectively wraps a tree of RawSyntax.
+///
+/// This should not be vended by SyntaxFactory.
+class UnknownSyntax : public Syntax {
+  friend struct SyntaxFactory;
+  friend class Syntax;
+
+  using DataType = UnknownSyntaxData;
+
+public:
+  UnknownSyntax(const RC<SyntaxData> Root, const UnknownSyntaxData *Data);
+
+  /// Get the number of child nodes in this piece of syntax, not including
+  /// tokens.
+  size_t getNumChildren() const;
+
+  /// Get the Nth child of this piece of syntax.
+  Syntax getChild(const size_t N) const;
+
+  static bool classof(const Syntax *S) {
+    return S->isUnknown();
+  }
+};
+
+} // end namespace syntax
+} // end namespace swift
+
+#endif // SWIFT_SYNTAX_UNKNOWNSYNTAX_H

lib/Syntax/CMakeLists.txt

@@ -12,4 +12,5 @@ add_swift_library(swiftSyntax STATIC
   SyntaxFactory.cpp
   SyntaxData.cpp
   TypeSyntax.cpp
+  UnknownSyntax.cpp
 )

lib/Syntax/DeclSyntax.cpp

@@ -36,14 +36,16 @@ DeclSyntax::DeclSyntax(const RC<SyntaxData> Root, const DeclSyntaxData *Data)
 UnknownDeclSyntaxData::UnknownDeclSyntaxData(RC<RawSyntax> Raw,
                                              const SyntaxData *Parent,
                                              CursorIndex IndexInParent)
-  : DeclSyntaxData(Raw, Parent, IndexInParent) {
-  assert(Raw->Kind == SyntaxKind::UnknownStmt);
+  : UnknownSyntaxData(Raw, Parent, IndexInParent) {
+  assert(Raw->Kind == SyntaxKind::UnknownDecl);
 }
 
 RC<UnknownDeclSyntaxData>
 UnknownDeclSyntaxData::make(RC<RawSyntax> Raw,
                             const SyntaxData *Parent,
                             CursorIndex IndexInParent) {
+  auto UnknownRaw = RawSyntax::make(SyntaxKind::UnknownDecl, Raw->Layout,
+                                    Raw->Presence);
   return RC<UnknownDeclSyntaxData> {
     new UnknownDeclSyntaxData {
       Raw, Parent, IndexInParent
@@ -55,7 +57,7 @@ UnknownDeclSyntaxData::make(RC<RawSyntax> Raw,
 
 UnknownDeclSyntax::UnknownDeclSyntax(const RC<SyntaxData> Root,
                                      const UnknownDeclSyntaxData *Data)
-  : DeclSyntax(Root, Data) {}
+  : UnknownSyntax(Root, Data) {}
 
 #pragma mark - declaration-members Data
 

lib/Syntax/ExprSyntax.cpp

@@ -42,17 +42,19 @@ ExprSyntax::ExprSyntax(const RC<SyntaxData> Root, const ExprSyntaxData *Data)
 UnknownExprSyntaxData::UnknownExprSyntaxData(RC<RawSyntax> Raw,
                                              const SyntaxData *Parent,
                                              CursorIndex IndexInParent)
-  : ExprSyntaxData(Raw, Parent, IndexInParent) {
+  : UnknownSyntaxData(Raw, Parent, IndexInParent) {
   assert(Raw->Kind == SyntaxKind::UnknownExpr);
 }
 
 RC<UnknownExprSyntaxData>
 UnknownExprSyntaxData::make(RC<RawSyntax> Raw,
                             const SyntaxData *Parent,
                             CursorIndex IndexInParent) {
+  auto UnknownRaw = RawSyntax::make(SyntaxKind::UnknownExpr, Raw->Layout,
+                                    Raw->Presence);
   return RC<UnknownExprSyntaxData> {
     new UnknownExprSyntaxData {
-      Raw, Parent, IndexInParent
+      UnknownRaw, Parent, IndexInParent
     }
   };
 }
@@ -61,7 +63,7 @@ UnknownExprSyntaxData::make(RC<RawSyntax> Raw,
 
 UnknownExprSyntax::UnknownExprSyntax(const RC<SyntaxData> Root,
                                      const UnknownExprSyntaxData *Data)
-  : ExprSyntax(Root, Data) {}
+  : UnknownSyntax(Root, Data) {}
 
 #pragma mark - integer-literal-expression Data