[Syntax] return-statement, integer-literal-expression, child caching

CODE_OWNERS.TXT

@@ -13,7 +13,7 @@ D: Swift standard library
 
 N: David Farler
 E: [email protected]
-D: Markup, Swift Linux port
+D: Markup, lib/Syntax, Swift Linux port
 
 N: Doug Gregor
 E: [email protected]

include/swift/AST/Expr.h

@@ -840,6 +840,14 @@ class NumberLiteralExpr : public LiteralExpr {
       return DigitsLoc;
   }
 
+  SourceLoc getMinusLoc() const {
+    return MinusLoc;
+  }
+
+  SourceLoc getDigitsLoc() const {
+    return DigitsLoc;
+  }
+
   static bool classof(const Expr *E) {
     return E->getKind() >= ExprKind::First_NumberLiteralExpr
       && E->getKind() <= ExprKind::Last_NumberLiteralExpr;

include/swift/Syntax/DeclSyntax.h

@@ -31,6 +31,8 @@
 namespace swift {
 namespace syntax {
 
+#pragma mark declaration Data
+
 class DeclSyntaxData : public SyntaxData {
 protected:
   DeclSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
@@ -40,6 +42,8 @@ class DeclSyntaxData : public SyntaxData {
   static bool classof(const SyntaxData *S) { return S->isDecl(); }
 };
 
+#pragma mark declaration API
+
 class DeclSyntax : public Syntax {
   friend class Syntax;
   using DataType = DeclSyntaxData;
@@ -50,6 +54,39 @@ class DeclSyntax : public Syntax {
   static bool classof(const SyntaxData *S) { return S->isDecl(); }
 };
 
+#pragma mark - unknown-declaration Data
+
+class UnknownDeclSyntaxData : public DeclSyntaxData {
+  UnknownDeclSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+                        CursorIndex IndexInParent = 0);
+public:
+  static RC<UnknownDeclSyntaxData> make(RC<RawSyntax> Raw,
+                                        const SyntaxData *Parent = nullptr,
+                                        CursorIndex IndexInParent = 0);
+
+  static bool classof(const SyntaxData *S) {
+    return S->getKind() == SyntaxKind::UnknownDecl;
+  }
+};
+
+#pragma mark - unknown-declaration API
+
+class UnknownDeclSyntax : public DeclSyntax {
+  friend class SyntaxData;
+  friend class UnknownStmtSyntaxData;
+  friend class LegacyASTTransformer;
+
+  using DataType = UnknownDeclSyntaxData;
+
+  UnknownDeclSyntax(const RC<SyntaxData> Root,
+                    const UnknownDeclSyntaxData *Data);
+
+public:
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::UnknownDecl;
+  }
+};
+
 #pragma mark declaration-members Data
 
 class DeclMembersSyntaxData final : public SyntaxData {
@@ -85,11 +122,7 @@ class DeclMembersSyntax final : public Syntax {
   DeclMembersSyntax(RC<SyntaxData> Root,
                     const DeclMembersSyntaxData *Data);
 public:
-  static DeclMembersSyntax make(const RC<SyntaxData> Root,
-                                const DeclMembersSyntaxData *Data);
-  static DeclMembersSyntax makeBlank();
-
-  static bool classof(const SyntaxData *S) {
+  static bool classof(const Syntax *S) {
     return S->getKind() == SyntaxKind::DeclMembers;
   }
 };
@@ -213,8 +246,8 @@ class StructDeclSyntax final : public DeclSyntax {
   /// Return a StructDeclSyntax with the given right brace '}' token.
   StructDeclSyntax withRightBrace(RC<TokenSyntax> NewRightBrace) const;
 
-  static bool classof(const SyntaxData *Data) {
-    return Data->getKind() == SyntaxKind::StructDecl;
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::StructDecl;
   }
 };
 

include/swift/Syntax/ExprSyntax.h

@@ -0,0 +1,150 @@
+//===--- ExprSyntax.h - Swift Expression Syntax Interface --------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the interface for expresion-specific syntax nodes,
+// such as 
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SYNTAX_EXPRSYNTAX_H
+#define SWIFT_SYNTAX_EXPRSYNTAX_H
+
+#include "swift/Syntax/RawSyntax.h"
+#include "swift/Syntax/References.h"
+#include "swift/Syntax/Syntax.h"
+#include "swift/Syntax/SyntaxData.h"
+#include "swift/Syntax/TokenSyntax.h"
+
+using llvm::Optional;
+
+namespace swift {
+namespace syntax {
+
+class ExprSyntaxData : public SyntaxData {
+protected:
+  ExprSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+                 CursorIndex IndexInParent = 0)
+    : SyntaxData(Raw, Parent, IndexInParent) {
+    assert(Raw->isExpr());
+  }
+public:
+  static RC<ExprSyntaxData> make(RC<RawSyntax> Raw,
+                                 const SyntaxData *Parent = nullptr,
+                                 CursorIndex IndexInParent = 0);
+  static RC<ExprSyntaxData> makeBlank();
+  static bool classof(const SyntaxData *S) {
+    return S->isExpr();
+  }
+};
+
+class ExprSyntax : public Syntax {
+public:
+  using DataType = ExprSyntaxData;
+
+  ExprSyntax(const RC<SyntaxData> Root, const ExprSyntaxData *Data);
+  static bool classof(const Syntax *S) {
+    return S->isExpr();
+  }
+};
+
+#pragma mark - unknown-expression Data
+
+class UnknownExprSyntaxData : public ExprSyntaxData {
+  UnknownExprSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr,
+                        CursorIndex IndexInParent = 0);
+public:
+  static RC<UnknownExprSyntaxData> make(RC<RawSyntax> Raw,
+                                 const SyntaxData *Parent = nullptr,
+                                 CursorIndex IndexInParent = 0);
+
+  static bool classof(const SyntaxData *S) {
+    return S->getKind() == SyntaxKind::UnknownExpr;
+  }
+};
+
+#pragma mark - unknown-expression API
+
+class UnknownExprSyntax : public ExprSyntax {
+  friend class SyntaxData;
+  friend class UnknownExprSyntaxData;
+  friend class LegacyASTTransformer;
+
+  using DataType = UnknownExprSyntaxData;
+
+  UnknownExprSyntax(const RC<SyntaxData> Root,
+                    const UnknownExprSyntaxData *Data);
+
+public:
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::UnknownExpr;
+  }
+};
+
+#pragma mark - integer-literal-expression Data
+
+class IntegerLiteralExprSyntaxData : public ExprSyntaxData {
+  friend struct SyntaxFactory;
+  friend class SyntaxData;
+
+  IntegerLiteralExprSyntaxData(RC<RawSyntax> Raw,
+                               const SyntaxData *Parent = nullptr,
+                               CursorIndex IndexInParent = 0);
+  static RC<IntegerLiteralExprSyntaxData> make(RC<RawSyntax> Raw,
+                                       const SyntaxData *Parent = nullptr,
+                                       CursorIndex IndexInParent = 0);
+  static RC<IntegerLiteralExprSyntaxData> makeBlank();
+public:
+  static bool classof(const SyntaxData *S) {
+    return S->getKind() == SyntaxKind::IntegerLiteralExpr;
+  }
+};
+
+#pragma mark - integer-literal-expression API
+
+class IntegerLiteralExprSyntax : public ExprSyntax {
+  using DataType = IntegerLiteralExprSyntaxData;
+  friend struct SyntaxFactory;
+  friend class SyntaxData;
+  friend class IntegerLiteralExprSyntaxData;
+
+  IntegerLiteralExprSyntax(const RC<SyntaxData> Root,
+                           const IntegerLiteralExprSyntaxData *Data);
+
+  enum class Cursor : CursorIndex {
+    Sign,
+    Digits
+  };
+
+public:
+
+  /// Get the '+' or '-' associated with this integer literal expression.
+  RC<TokenSyntax> getSign() const;
+
+  /// Return a new IntegerLiteralExprSyntax with the given '+' or '-' sign.
+  IntegerLiteralExprSyntax withSign(RC<TokenSyntax> NewSign) const;
+
+  /// Return the string of digits comprising the number part of the integer
+  /// literal expression.
+  RC<TokenSyntax> getDigits() const;
+
+  /// Return a new IntegerLiteralExprSyntax with the given string of digits.
+  IntegerLiteralExprSyntax withDigits(RC<TokenSyntax> NewDigits) const;
+
+  static bool classof(const Syntax *S) {
+    return S->getKind() == SyntaxKind::IntegerLiteralExpr;
+  }
+};
+
+} // end namespace syntax
+} // end namespace swift
+
+#endif // SWIFT_SYNTAX_EXPRSYNTAX_H