| //===--- DeclSyntax.h - Declaration 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 declaration-specific syntax nodes, |
| // such as for structures, enumerations, type aliases, and constants. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef SWIFT_SYNTAX_DECLSYNTAX_H |
| #define SWIFT_SYNTAX_DECLSYNTAX_H |
| |
| #include "swift/Syntax/References.h" |
| #include "swift/Syntax/RawSyntax.h" |
| #include "swift/Syntax/Syntax.h" |
| #include "swift/Syntax/SyntaxCollection.h" |
| #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" |
| |
| namespace swift { |
| namespace syntax { |
| |
| class ExprSyntax; |
| class ExprSyntaxData; |
| class CodeBlockStmtSyntax; |
| class CodeBlockStmtSyntaxData; |
| class TypeAttributesSyntax; |
| class TypeAttributesSyntaxData; |
| class DeclModifierListSyntax; |
| class GenericWhereClauseSyntax; |
| class GenericWhereClauseSyntaxData; |
| class GenericParameterListSyntax; |
| class GenericParameterListSyntaxData; |
| |
| #pragma mark declaration-modifier Data |
| |
| class DeclModifierSyntaxData final : public SyntaxData { |
| friend struct SyntaxFactory; |
| friend class SyntaxData; |
| friend class Syntax; |
| friend class DeclModifierSyntax; |
| |
| DeclModifierSyntaxData(const RC<RawSyntax> Raw, |
| const SyntaxData *Parent = nullptr, |
| const CursorIndex IndexInParent = 0); |
| |
| static RC<DeclModifierSyntaxData> make(const RC<RawSyntax> Raw, |
| const SyntaxData *Parent = nullptr, |
| const CursorIndex IndexInParent = 0); |
| |
| static RC<DeclModifierSyntaxData> makeBlank(); |
| |
| public: |
| static bool classof(const SyntaxData *SD) { |
| return SD->getKind() == SyntaxKind::DeclModifier; |
| } |
| }; |
| |
| #pragma mark declaration-modifier API |
| |
| /// declaration-modifier -> access-level-modifier |
| /// | mutation-modifier |
| /// | 'class' |
| /// | 'convenience' |
| /// | 'dynamic' |
| /// | 'final' |
| /// | 'infix' |
| /// | 'lazy' |
| /// | 'optional' |
| /// | 'override' |
| /// | 'postfix' |
| /// | 'prefix' |
| /// | 'required' |
| /// | 'static' |
| /// | 'unowned' |
| /// | 'unowned(safe)' |
| /// | 'unowned(unsafe)' |
| /// | 'weak' |
| /// access-level-modifier -> 'private' | 'private' '(' 'set' ')' |
| /// | 'fileprivate' | 'fileprivate' '(' 'set' ')' |
| /// | 'internal' | 'internal' '(' 'set' ')' |
| /// | 'public' | 'public' '(' 'set' ')' |
| /// | 'open' | 'open' '(' 'set' ')' |
| /// mutation-modifier -> 'mutating' | 'nonmutating' |
| class DeclModifierSyntax final : public Syntax { |
| friend struct SyntaxFactory; |
| friend class Syntax; |
| friend class SyntaxData; |
| friend class DeclModifierSyntaxData; |
| |
| enum class Cursor : CursorIndex { |
| Name, |
| LeftParen, |
| Argument, |
| RightParen |
| }; |
| |
| DeclModifierSyntax(const RC<SyntaxData> Root, const DataType *Data) |
| : Syntax(Root, Data) {} |
| |
| public: |
| using DataType = DeclModifierSyntaxData; |
| |
| /// Return the name of the modifier. |
| RC<TokenSyntax> getName() const; |
| |
| /// Return a DeclModifierSyntax with the given name. |
| DeclModifierSyntax withName(RC<TokenSyntax> NewName) const; |
| |
| /// Return the left parenthesis '(' token as a part of the argument clause, |
| /// if there is one. |
| RC<TokenSyntax> getLeftParenToken() const; |
| |
| /// Return a DeclModifierSyntax with the given left parenthesis '(' token. |
| DeclModifierSyntax withLeftParenToken(RC<TokenSyntax> NewLeftParen) const; |
| |
| /// Get the argument to the declaration modifier. |
| /// |
| /// This is either: |
| /// - 'set' for the access modifiers such as 'private' or 'public', or |
| /// - 'safe' / 'unsafe' for the 'unowned' modifier. |
| RC<TokenSyntax> getArgument() const; |
| |
| /// Return a DeclModifierSyntax with the given argument. |
| DeclModifierSyntax withArgument(RC<TokenSyntax> NewArgument) const; |
| |
| /// Return the right parenthesis ')' token as a part of the argument clause, |
| /// if there is one. |
| RC<TokenSyntax> getRightParenToken() const; |
| |
| /// Return a DeclModifierSyntax with the given right parenthesis ')' token. |
| DeclModifierSyntax withRightParenToken(RC<TokenSyntax> NewRightParen) const; |
| |
| static bool classof(const Syntax *S) { |
| return S->getKind() == SyntaxKind::DeclModifier; |
| } |
| }; |
| |
| #pragma mark declaration-modifiers Data |
| |
| using DeclModifierListSyntaxData = |
| SyntaxCollectionData<SyntaxKind::DeclModifierList, DeclModifierSyntax>; |
| |
| #pragma mark declaration-modifiers API |
| |
| class DeclModifierListSyntax final : |
| public SyntaxCollection<SyntaxKind::DeclModifierList, DeclModifierSyntax> { |
| |
| friend struct SyntaxFactory; |
| friend class Syntax; |
| friend class SyntaxData; |
| friend class FunctionDeclSyntax; |
| |
| using DataType = DeclModifierListSyntaxData; |
| |
| DeclModifierListSyntax(const RC<SyntaxData> Root, const DataType *Data) |
| : SyntaxCollection(Root, Data) {} |
| |
| public: |
| static bool classof(const Syntax *S) { |
| return S->getKind() == SyntaxKind::DeclModifierList; |
| } |
| }; |
| |
| #pragma mark declaration Data |
| |
| class DeclSyntaxData : public SyntaxData { |
| protected: |
| DeclSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr, |
| CursorIndex IndexInParent = 0); |
| |
| public: |
| static bool classof(const SyntaxData *S) { return S->isDecl(); } |
| }; |
| |
| #pragma mark declaration API |
| |
| class DeclSyntax : public Syntax { |
| friend class Syntax; |
| using DataType = DeclSyntaxData; |
| protected: |
| DeclSyntax(const RC<SyntaxData> Root, const DeclSyntaxData *Data); |
| |
| public: |
| static bool classof(const SyntaxData *S) { return S->isDecl(); } |
| }; |
| |
| #pragma mark - unknown-declaration Data |
| |
| class UnknownDeclSyntaxData : public UnknownSyntaxData { |
| 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 UnknownSyntax { |
| 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 { |
| friend class SyntaxData; |
| friend class DeclMembersSyntaxBuilder; |
| friend struct SyntaxFactory; |
| |
| DeclMembersSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr, |
| CursorIndex IndexInParent = 0); |
| |
| public: |
| static RC<DeclMembersSyntaxData> make(RC<RawSyntax> Raw, |
| const SyntaxData *Parent = nullptr, |
| CursorIndex IndexInParent = 0); |
| static RC<DeclMembersSyntaxData> makeBlank(); |
| |
| static bool classof(const SyntaxData *S) { |
| return S->getKind() == SyntaxKind::DeclMembers; |
| } |
| }; |
| |
| #pragma mark - |
| #pragma mark declaration-members API |
| |
| class DeclMembersSyntax final : public Syntax { |
| using DataType = DeclMembersSyntaxData; |
| friend struct SyntaxFactory; |
| friend class SyntaxData; |
| friend class Syntax; |
| friend class DeclMembersSyntaxBuilder; |
| friend class StructDeclSyntax; |
| |
| DeclMembersSyntax(RC<SyntaxData> Root, |
| const DeclMembersSyntaxData *Data); |
| public: |
| static bool classof(const Syntax *S) { |
| return S->getKind() == SyntaxKind::DeclMembers; |
| } |
| }; |
| |
| #pragma mark - |
| #pragma mark declaration-members Builder (TODO) |
| |
| class DeclMembersSyntaxBuilder final { |
| RawSyntax::LayoutList MembersLayout; |
| public: |
| DeclMembersSyntaxBuilder &addMember(DeclSyntax Member); |
| DeclMembersSyntax build() const; |
| }; |
| |
| #pragma mark - |
| #pragma mark struct-declaration Data |
| |
| class StructDeclSyntaxData final : public DeclSyntaxData { |
| friend class SyntaxData; |
| friend class StructDeclSyntax; |
| friend class StructDeclSyntaxBuilder; |
| friend struct SyntaxFactory; |
| |
| RC<GenericWhereClauseSyntaxData> CachedWhereClause; |
| RC<GenericParameterClauseSyntaxData> CachedGenericParams; |
| RC<DeclMembersSyntaxData> CachedMembers; |
| |
| StructDeclSyntaxData(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr, |
| CursorIndex IndexInParent = 0); |
| |
| static RC<StructDeclSyntaxData> make(RC<RawSyntax> Raw, |
| const SyntaxData *Parent = nullptr, |
| CursorIndex IndexInParent = 0); |
| static RC<StructDeclSyntaxData> makeBlank(); |
| |
| public: |
| static bool classof(const SyntaxData *S) { |
| return S->getKind() == SyntaxKind::StructDecl; |
| } |
| }; |
| |
| #pragma mark - struct-declaration API |
| |
| /// struct-declaration -> attributes? access-level-modifier? |
| /// 'struct' struct-name |
| /// generic-parameter-clause? type-inheritance-clause? |
| /// generic-where-clause? |
| /// '{' struct-members '}' |
| /// struct-name -> identifier |
| /// struct-members -> struct-member struct-members? |
| /// struct-member -> declaration | compiler-control-statement |
| class StructDeclSyntax final : public DeclSyntax { |
| using DataType = StructDeclSyntaxData; |
| friend struct SyntaxFactory; |
| friend class Syntax; |
| friend class SyntaxData; |
| friend class StructDeclSyntaxData; |
| friend class StructDeclSyntaxBuilder; |
| |
| enum class Cursor : CursorIndex { |
| StructKeyword, |
| Identifier, |
| GenericParameterClause, |
| GenericWhereClause, |
| LeftBrace, |
| Members, |
| RightBrace, |
| First = StructKeyword, |
| Last = RightBrace, |
| }; |
| |
| StructDeclSyntax(const RC<SyntaxData> Root, const StructDeclSyntaxData *Data); |
| |
| const StructDeclSyntaxData *getData() const { |
| return cast<StructDeclSyntaxData>(Data); |
| } |
| |
| public: |
| /// Return the 'struct' keyword attached to the declaration. |
| RC<TokenSyntax> getStructKeyword() const; |
| |
| /// Return a StructDeclSyntax with the given 'struct' keyword. |
| StructDeclSyntax withStructKeyword(RC<TokenSyntax> NewStructKeyword) const; |
| |
| /// Return the identifier of the struct. |
| RC<TokenSyntax> getIdentifier() const; |
| |
| /// Return a StructDeclSyntax with the given identifier. |
| StructDeclSyntax withIdentifier(RC<TokenSyntax> NewIdentifier) const; |
| |
| /// Return the generic parameter clause of the struct declaration. |
| GenericParameterClauseSyntax getGenericParameterClause() const; |
| |
| /// Return a StructDeclSyntax with the given generic parameter clause. |
| StructDeclSyntax |
| withGenericParameterClause(GenericParameterClauseSyntax NewGenericParams) |
| const; |
| |
| /// Return the where clause of the struct declaration. |
| GenericWhereClauseSyntax getGenericWhereClause() const; |
| |
| /// Return a StructDeclSyntax with the given generic where clause. |
| StructDeclSyntax |
| withWhereClause(GenericWhereClauseSyntax NewWhereClause) const; |
| |
| /// Return the left brace '{' token of the struct declaration. |
| RC<TokenSyntax> getLeftBraceToken() const; |
| |
| /// Return a StructDeclSyntax with the given left brace '{' token. |
| StructDeclSyntax withLeftBrace(RC<TokenSyntax> NewLeftBrace) const; |
| |
| /// Return the members' syntax of the struct. |
| DeclMembersSyntax getMembers() const; |
| |
| /// Return a StructDeclSyntax with the given new members. |
| StructDeclSyntax withMembers(DeclMembersSyntax NewMembers) const; |
| |
| /// Return the right brace '}' token of the struct declaration. |
| RC<TokenSyntax> getRightBraceToken() const; |
| |
| /// Return a StructDeclSyntax with the given right brace '}' token. |
| StructDeclSyntax withRightBrace(RC<TokenSyntax> NewRightBrace) const; |
| |
| static bool classof(const Syntax *S) { |
| return S->getKind() == SyntaxKind::StructDecl; |
| } |
| }; |
| |
| #pragma mark - struct-declaration Builder |
| |
| class StructDeclSyntaxBuilder final { |
| RawSyntax::LayoutList StructLayout; |
| public: |
| StructDeclSyntaxBuilder(); |
| StructDeclSyntaxBuilder &useStructKeyword(RC<TokenSyntax> StructKeyword); |
| StructDeclSyntaxBuilder &useIdentifier(RC<TokenSyntax> Identifier); |
| StructDeclSyntaxBuilder &useLeftBrace(RC<TokenSyntax> LeftBrace); |
| |
| StructDeclSyntaxBuilder & |
| useGenericParameterClause(GenericParameterClauseSyntax GenericParams); |
| |
| StructDeclSyntaxBuilder & |
| useGenericWhereClause(GenericWhereClauseSyntax GenericWhereClause); |
| |
| StructDeclSyntaxBuilder &useMembers(DeclMembersSyntax Members); |
| StructDeclSyntaxBuilder &useRightBrace(RC<TokenSyntax> RightBrace); |
| StructDeclSyntax build() const; |
| }; |
| |
| #pragma mark - |
| #pragma mark - type-alias Data |
| |
| class TypeAliasDeclSyntaxData final : public DeclSyntaxData { |
| friend class SyntaxData; |
| friend struct SyntaxFactory; |
| friend class TypeAliasDeclSyntaxBuilder; |
| |
| TypeAliasDeclSyntaxData(RC<RawSyntax> Raw, |
| const SyntaxData *Parent = nullptr, |
| CursorIndex IndexInParent = 0); |
| static RC<TypeAliasDeclSyntaxData> make(RC<RawSyntax> Raw, |
| const SyntaxData *Parent = nullptr, |
| CursorIndex IndexInParent = 0); |
| static RC<TypeAliasDeclSyntaxData> makeBlank(); |
| |
| public: |
| static bool classof(const SyntaxData *S) { |
| return S->getKind() == SyntaxKind::TypeAliasDecl; |
| } |
| }; |
| |
| #pragma mark - |
| #pragma mark - type-alias API |
| |
| class TypeAliasDeclSyntax final : public DeclSyntax { |
| friend struct SyntaxFactory; |
| friend class SyntaxData; |
| friend class TypeAliasDeclSyntaxData; |
| friend class TypeAliasDeclSyntaxBuilder; |
| |
| using DataType = TypeAliasDeclSyntaxData; |
| |
| enum Cursor : CursorIndex { |
| TypeAliasKeyword, |
| Identifier, |
| GenericParameterClause, |
| EqualToken, |
| Type |
| }; |
| |
| TypeAliasDeclSyntax(RC<SyntaxData> Root, const TypeAliasDeclSyntaxData *Data); |
| |
| public: |
| /// Return the 'typealias' keyword for the declaration. |
| RC<TokenSyntax> getTypealiasKeyword() const { |
| return cast<TokenSyntax>(getRaw()->getChild(Cursor::TypeAliasKeyword)); |
| } |
| |
| /// Return a TypeAliasDeclSyntax with the given 'typealias' keyword. |
| TypeAliasDeclSyntax |
| withTypeAliasKeyword(RC<TokenSyntax> NewTypeAliasKeyword) const; |
| |
| /// Return the identifier for the declaration. |
| RC<TokenSyntax> getIdentifier() const; |
| |
| /// Return a TypeAliasDeclSyntax with the given identifier. |
| TypeAliasDeclSyntax withIdentifier(RC<TokenSyntax> NewIdentifier) const; |
| |
| /// Return the generic parameter clause of the declaration. |
| GenericParameterClauseSyntax getGenericParameterClause() const; |
| |
| /// Return a TypeAliasDeclSyntax with the given generic parameter clause. |
| TypeAliasDeclSyntax |
| withGenericParameterClause( GenericParameterClauseSyntax NewGenericParams) |
| const; |
| |
| /// Return the equal '=' token from the declaration. |
| RC<TokenSyntax> getEqualToken() const; |
| |
| /// Return a TypeAliasDeclSyntax with the given equal '=' token. |
| TypeAliasDeclSyntax |
| withEqualToken(RC<TokenSyntax> NewEqualToken) const; |
| |
| /// Return the type syntax to which the type alias is assigned. |
| TypeSyntax getTypeSyntax() const; |
| |
| /// Return a TypeAliasDeclSyntax with the given type assignment. |
| TypeAliasDeclSyntax withTypeSyntax(TypeSyntax NewType) const; |
| |
| static bool classof(const Syntax *S) { |
| return S->getKind() == SyntaxKind::TypeAliasDecl; |
| } |
| }; |
| |
| #pragma mark - type-alias Builder |
| |
| class TypeAliasDeclSyntaxBuilder final { |
| RawSyntax::LayoutList TypeAliasLayout; |
| public: |
| TypeAliasDeclSyntaxBuilder(); |
| |
| TypeAliasDeclSyntaxBuilder & |
| useTypeAliasKeyword(RC<TokenSyntax> TypeAliasKeyword); |
| |
| TypeAliasDeclSyntaxBuilder &useIdentifier(RC<TokenSyntax> Identifier); |
| |
| TypeAliasDeclSyntaxBuilder & |
| useGenericParameterClause(GenericParameterClauseSyntax GenericParams); |
| |
| TypeAliasDeclSyntaxBuilder &useEqualToken(RC<TokenSyntax> EqualToken); |
| |
| TypeAliasDeclSyntaxBuilder &useType(TypeSyntax ReferentType); |
| |
| TypeAliasDeclSyntax build() const; |
| }; |
| |
| #pragma mark - function-parameter Data |
| |
| class FunctionParameterSyntaxData final : public SyntaxData { |
| |
| friend struct SyntaxFactory; |
| friend class Syntax; |
| friend class SyntaxData; |
| friend class FunctionParameterSyntax; |
| |
| RC<TypeSyntaxData> CachedTypeSyntax; |
| RC<ExprSyntaxData> CachedDefaultValue; |
| |
| FunctionParameterSyntaxData(RC<RawSyntax> Raw, |
| const SyntaxData *Parent = nullptr, |
| CursorIndex IndexInParent = 0); |
| static RC<FunctionParameterSyntaxData> |
| make(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr, |
| CursorIndex IndexInParent = 0); |
| static RC<FunctionParameterSyntaxData> makeBlank(); |
| |
| public: |
| static bool classof(const SyntaxData *SD) { |
| return SD->getKind() == SyntaxKind::FunctionParameter; |
| } |
| }; |
| |
| #pragma mark - function-parameter API |
| |
| /// parameter -> |
| /// external-parameter-name? local-parameter-name ':' |
| /// type '...'? '='? expression? ','? |
| class FunctionParameterSyntax final : public Syntax { |
| friend struct SyntaxFactory; |
| friend class Syntax; |
| friend class SyntaxData; |
| friend class FunctionParameterSyntaxData; |
| |
| enum class Cursor : CursorIndex { |
| ExternalName, |
| LocalName, |
| Colon, |
| Type, |
| Ellipsis, |
| DefaultEqual, |
| DefaultExpression, |
| TrailingComma, |
| }; |
| |
| public: |
| using DataType = FunctionParameterSyntaxData; |
| |
| FunctionParameterSyntax(const RC<SyntaxData> Root, const DataType *Data) |
| : Syntax(Root, Data) {} |
| |
| /// Get the external name of the parameter, if there is one. |
| RC<TokenSyntax> getExternalName() const; |
| |
| /// Return a FunctionParameterSyntax with the given external name. |
| FunctionParameterSyntax |
| withExternalName(RC<TokenSyntax> NewExternalName) const; |
| |
| /// Return the local name of the parameter. |
| RC<TokenSyntax> getLocalName() const; |
| |
| /// Return a FunctionParameterSyntax with the given local name. |
| FunctionParameterSyntax |
| withLocalName(RC<TokenSyntax> NewLocalName) const; |
| |
| /// Return the colon ':' token between the local name and type of the |
| /// parameter. |
| RC<TokenSyntax> getColonToken() const; |
| |
| /// Return a FunctionParameterSyntax with the given colon token between |
| /// the local name and type. |
| FunctionParameterSyntax |
| withColonToken(RC<TokenSyntax> NewColonToken) const; |
| |
| /// Return the syntax for the type of this parameter. |
| llvm::Optional<TypeSyntax> getTypeSyntax() const; |
| |
| /// Return a FunctionParameterSyntax with the given parameter type syntax. |
| FunctionParameterSyntax |
| withTypeSyntax(llvm::Optional<TypeSyntax> NewType) const; |
| |
| /// Return the equal '=' token in between the parameter type and the default |
| /// value, if there is one. |
| RC<TokenSyntax> getEqualToken() const; |
| |
| /// Return a FunctionParameterSyntax with the given equal '=' token in |
| /// between the parameter type and the default value. |
| FunctionParameterSyntax withEqualToken(RC<TokenSyntax> NewEqualToken) const; |
| |
| /// Return the expresion for the default value of the parameter, if there |
| /// is one. |
| llvm::Optional<ExprSyntax> getDefaultValue() const; |
| |
| /// Return a FunctionParameterSyntax with the given default value. To remove |
| /// the default value, pass llvm::None. |
| FunctionParameterSyntax |
| withDefaultValue(llvm::Optional<ExprSyntax> NewDefaultValue) const; |
| |
| /// Return the trailing comma on the parameter, if there is one. |
| RC<TokenSyntax> getTrailingComma() const; |
| |
| /// Return a FunctionParameterSyntax with the given trailing comma. |
| FunctionParameterSyntax |
| withTrailingComma(RC<TokenSyntax> NewTrailingComma) const; |
| |
| static bool classof(const Syntax *S) { |
| return S->getKind() == SyntaxKind::FunctionParameter; |
| } |
| }; |
| |
| #pragma mark - function-parameter-list Data |
| |
| using FunctionParameterListSyntaxData = |
| SyntaxCollectionData<SyntaxKind::FunctionParameterList, |
| FunctionParameterSyntax>; |
| |
| #pragma mark - function-parameter-list API |
| |
| /// parameter-list -> parameteter | parameter ',' parameter-list |
| class FunctionParameterListSyntax final : public |
| SyntaxCollection<SyntaxKind::FunctionParameterList, FunctionParameterSyntax> { |
| friend struct SyntaxFactory; |
| friend class Syntax; |
| friend class SyntaxData; |
| friend class FunctionSignatureSyntax; |
| |
| using DataType = FunctionParameterListSyntaxData; |
| |
| FunctionParameterListSyntax(const RC<SyntaxData> Root, |
| const DataType *Data) |
| : SyntaxCollection(Root, Data) {} |
| |
| public: |
| static bool classof(const Syntax *S) { |
| return S->getKind() == SyntaxKind::FunctionParameterList; |
| } |
| }; |
| |
| #pragma mark - function-signature Data |
| |
| class FunctionSignatureSyntaxData final : public SyntaxData { |
| friend struct SyntaxFactory; |
| friend class SyntaxData; |
| friend class FunctionSignatureSyntax; |
| |
| RC<FunctionParameterListSyntaxData> CachedParameterList; |
| RC<TypeAttributesSyntaxData> CachedReturnTypeAttributes; |
| RC<TypeSyntaxData> CachedReturnTypeSyntax; |
| |
| FunctionSignatureSyntaxData(const RC<RawSyntax> Raw, |
| const SyntaxData *Parent = nullptr, |
| const CursorIndex IndexInParent = 0); |
| |
| static RC<FunctionSignatureSyntaxData> |
| make(RC<RawSyntax> Raw, const SyntaxData *Parent = nullptr, |
| CursorIndex IndexInParent = 0); |
| static RC<FunctionSignatureSyntaxData> makeBlank(); |
| |
| public: |
| static bool classof(const SyntaxData *SD) { |
| return SD->getKind() == SyntaxKind::FunctionSignature; |
| } |
| }; |
| |
| #pragma mark - function-signature API |
| |
| /// function-signature -> |
| /// '(' parameter-list? ')' (throws | rethrows)? '->' attributes? type |
| class FunctionSignatureSyntax final : public Syntax { |
| friend struct SyntaxBuilder; |
| friend class Syntax; |
| friend class SyntaxData; |
| friend class FunctionSignatureSyntaxData; |
| |
| enum class Cursor : CursorIndex { |
| LeftParen, |
| ParameterList, |
| RightParen, |
| ThrowsOrRethrows, |
| Arrow, |
| ReturnTypeAttributes, |
| ReturnType, |
| }; |
| |
| public: |
| using DataType = FunctionSignatureSyntaxData; |
| |
| FunctionSignatureSyntax(const RC<SyntaxData> Root, const DataType *Data) |
| : Syntax(Root, Data) {} |
| |
| /// Return the left parenthesis '(' token enclosing the parameter list. |
| RC<TokenSyntax> getLeftParenToken() const; |
| |
| /// Return a FunctionSignatureSyntax with the given left parentesis '(' token |
| /// enclosing the parameter list. |
| FunctionSignatureSyntax |
| withLeftParenToken(RC<TokenSyntax> NewLeftParen) const; |
| |
| /// Return the parameter list for this signature. |
| FunctionParameterListSyntax getParameterList() const; |
| |
| /// Return the parameter list for this signature. |
| FunctionSignatureSyntax |
| withParameterList(FunctionParameterListSyntax NewParameterList) const; |
| |
| /// Return the right parenthesis ')' token enclosing the parameter list. |
| RC<TokenSyntax> getRightParenToken() const; |
| |
| /// Return a FunctionSignatureSyntax with the given right parentesis ')' token |
| /// enclosing the parameter list. |
| FunctionSignatureSyntax |
| withRightParenToken(RC<TokenSyntax> NewRightParen) const; |
| |
| /// Return the 'throws' token in this signature if it exists. |
| RC<TokenSyntax> getThrowsToken() const; |
| |
| /// Return a FunctionSignatureSyntax with the given 'throws' token. |
| FunctionSignatureSyntax withThrowsToken(RC<TokenSyntax> NewThrowsToken) const; |
| |
| /// Return the 'rethrows' token in this signature if it exists; |
| RC<TokenSyntax> getRethrowsToken() const; |
| |
| /// Return a FunctionSignatureSyntax with the given 'rethrows' token. |
| FunctionSignatureSyntax |
| withRethrowsToken(RC<TokenSyntax> NewRethrowsToken) const; |
| |
| /// Return the arrow '->' token for the signature. |
| RC<TokenSyntax> getArrowToken() const; |
| |
| /// Return a FunctionSignatureSyntax with the given arrow token |
| FunctionSignatureSyntax withArrowToken(RC<TokenSyntax> NewArrowToken) const; |
| |
| /// Return the return type attributes for the signature. |
| TypeAttributesSyntax getReturnTypeAttributes() const; |
| |
| /// Return a FunctionSignatureSyntax with the given return type attributes. |
| FunctionSignatureSyntax |
| withReturnTypeAttributes(TypeAttributesSyntax NewReturnTypeAttributes) const; |
| |
| /// Return the syntax for the return type of the signature. |
| TypeSyntax getReturnTypeSyntax() const; |
| |
| /// Return a FunctionSignatureSyntax with the given return type. |
| FunctionSignatureSyntax withReturnTypeSyntax(TypeSyntax NewReturnType) const; |
| |
| static bool classof(const Syntax *S) { |
| return S->getKind() == SyntaxKind::FunctionSignature; |
| } |
| }; |
| |
| #pragma mark - function-declaration Data |
| |
| class FunctionDeclSyntaxData final : public SyntaxData { |
| friend struct SyntaxFactory; |
| friend class SyntaxData; |
| friend class FunctionDeclSyntax; |
| |
| RC<TypeAttributesSyntaxData> CachedAttributes; |
| RC<DeclModifierListSyntaxData> CachedModifiers; |
| RC<GenericParameterClauseSyntaxData> CachedGenericParams; |
| RC<FunctionSignatureSyntaxData> CachedSignature; |
| RC<GenericWhereClauseSyntaxData> CachedGenericWhereClause; |
| RC<CodeBlockStmtSyntaxData> CachedBody; |
| |
| FunctionDeclSyntaxData(const RC<RawSyntax> Raw, |
| const SyntaxData *Parent = nullptr, |
| const CursorIndex IndexInParent = 0); |
| |
| static RC<FunctionDeclSyntaxData> make(const RC<RawSyntax> Raw, |
| const SyntaxData *Parent = nullptr, |
| const CursorIndex IndexInParent = 0); |
| static RC<FunctionDeclSyntaxData> makeBlank(); |
| |
| public: |
| static bool classof(const SyntaxData *SD) { |
| return SD->getKind() == SyntaxKind::FunctionDecl; |
| } |
| }; |
| |
| #pragma mark - function-declaration API |
| |
| class FunctionDeclSyntax final : public Syntax { |
| friend struct SyntaxFactory; |
| friend class Syntax; |
| friend class SyntaxData; |
| friend class FunctionDeclSyntaxData; |
| |
| enum class Cursor : CursorIndex { |
| Attributes, |
| Modifiers, |
| FuncKeyword, |
| Identifier, |
| GenericParameterClause, |
| Signature, |
| GenericWhereClause, |
| Body |
| }; |
| |
| using DataType = FunctionDeclSyntaxData; |
| |
| FunctionDeclSyntax(const RC<SyntaxData> Root, const DataType *Data) |
| : Syntax(Root, Data) {} |
| |
| public: |
| /// Get the attributes of this function declaration. |
| TypeAttributesSyntax getAttributes() const; |
| |
| /// Return a FunctionDeclSyntax with the given attributes. |
| FunctionDeclSyntax withAttributes(TypeAttributesSyntax NewAttributes) const; |
| |
| /// Get the modifiers of this function declaration. |
| DeclModifierListSyntax getModifiers() const; |
| |
| /// Return a FunctionDeclSyntax with the given modifiers. |
| FunctionDeclSyntax withModifiers(DeclModifierListSyntax NewModifiers) const; |
| |
| /// Return the 'func' keyword of tis function declaration. |
| RC<TokenSyntax> getFuncKeyword() const; |
| |
| /// Return a FunctionDeclSyntax with the given 'func' keyword. |
| FunctionDeclSyntax withFuncKeyword(RC<TokenSyntax> NewFuncKeyword) const; |
| |
| /// Return the identifier of the function declaration. |
| RC<TokenSyntax> getIdentifier() const; |
| |
| /// Return a FunctionDeclSyntax with the given identifier. |
| FunctionDeclSyntax withIdentifier(RC<TokenSyntax> NewIdentifier) const; |
| |
| /// Return the generic parameter clause of the function declaration, if |
| /// there is one. Otherwise, return llvm::None. |
| llvm::Optional<GenericParameterClauseSyntax> |
| getGenericParameterClause() const; |
| |
| /// Return a FunctionDeclSyntax with the given generic parameter clause. |
| /// To remove the generic parameters, pass in llvm::None. |
| FunctionDeclSyntax withGenericParameterClause( |
| llvm::Optional<GenericParameterClauseSyntax> NewGenericParams) const; |
| |
| /// Return the signature of the function declaration. |
| FunctionSignatureSyntax getSignature() const; |
| |
| /// Return a FunctionDeclSyntax with the given function signature. |
| FunctionDeclSyntax withSignature(FunctionSignatureSyntax NewSignature) const; |
| |
| /// Return the body of the function declaration, if there is one. |
| /// |
| /// As an example, function declarations in protocols have no body. |
| llvm::Optional<CodeBlockStmtSyntax> getBody() const; |
| |
| /// Return a FunctionDeclSyntax with the given body. To remove the body, |
| /// pass in llvm::None. |
| FunctionDeclSyntax |
| withBody(llvm::Optional<CodeBlockStmtSyntax> NewBody) const; |
| |
| static bool classof(const Syntax *S) { |
| return S->getKind() == SyntaxKind::FunctionDecl; |
| } |
| }; |
| |
| } // end namespace syntax |
| } // end namespace swift |
| |
| #endif // SWIFT_SYNTAX_DECLSYNTAX_H |