include/swift/Syntax/DeclSyntax.h - third_party/swift - Git at Google

 //===--- 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/GenericSyntax.h"
 #include "swift/Syntax/References.h"
 #include "swift/Syntax/RawSyntax.h"
 #include "swift/Syntax/Syntax.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 {

 #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;
 };

 } // end namespace syntax
 } // end namespace swift

 #endif // SWIFT_SYNTAX_DECLSYNTAX_H
	//===--- 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/GenericSyntax.h"
	#include "swift/Syntax/References.h"
	#include "swift/Syntax/RawSyntax.h"
	#include "swift/Syntax/Syntax.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 {

	#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;
	};

	} // end namespace syntax
	} // end namespace swift

	#endif // SWIFT_SYNTAX_DECLSYNTAX_H