Skip to content

[libSyntax] Make SyntaxFactory methods instance methods #36233

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Mar 4, 2021
Merged

[libSyntax] Make SyntaxFactory methods instance methods #36233

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 0 additions & 2 deletions include/swift/Syntax/Syntax.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -53,8 +53,6 @@ const auto NoParent = llvm::None;
/// Essentially, this is a wrapper around \c SyntaxData that provides
/// convenience methods based on the node's kind.
class Syntax {
friend struct SyntaxFactory;

protected:
SyntaxData Data;

Expand Down
1 change: 0 additions & 1 deletion include/swift/Syntax/SyntaxCollection.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -53,7 +53,6 @@ struct SyntaxCollectionIterator {
/// A generic unbounded collection of syntax nodes
template <SyntaxKind CollectionKind, typename Element>
class SyntaxCollection : public Syntax {
friend struct SyntaxFactory;
friend class Syntax;

private:
Expand Down
118 changes: 43 additions & 75 deletions include/swift/Syntax/SyntaxFactory.h.gyb
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,17 +16,6 @@
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file defines the SyntaxFactory, one of the most important client-facing
// types in lib/Syntax and likely to be very commonly used.
//
// Effectively a namespace, SyntaxFactory is never instantiated, but is *the*
// one-stop shop for making new Syntax nodes. Putting all of these into a
// collection of static methods provides a single point of API lookup for
// clients' convenience and also allows the library to hide all of the
// constructors for all Syntax nodes, as the SyntaxFactory is friend to all.
//
//===----------------------------------------------------------------------===//

#ifndef SWIFT_SYNTAX_FACTORY_H
#define SWIFT_SYNTAX_FACTORY_H
Expand All @@ -43,41 +32,39 @@ namespace syntax {
class SyntaxArena;

/// The Syntax factory - the one-stop shop for making new Syntax nodes.
struct SyntaxFactory {
class SyntaxFactory {
RC<SyntaxArena> Arena;

public:
explicit SyntaxFactory(const RC<SyntaxArena> &Arena) : Arena(Arena) {}

/// Make any kind of token.
static TokenSyntax makeToken(tok Kind,
TokenSyntax makeToken(tok Kind,
StringRef Text,
StringRef LeadingTrivia,
StringRef TrailingTrivia,
SourcePresence Presence,
const RC<SyntaxArena> &Arena
SourcePresence Presence
);

/// Collect a list of tokens into a piece of "unknown" syntax.
static UnknownSyntax makeUnknownSyntax(
llvm::ArrayRef<TokenSyntax> Tokens,
const RC<SyntaxArena> &Arena
);
UnknownSyntax makeUnknownSyntax(llvm::ArrayRef<TokenSyntax> Tokens);

static Optional<Syntax> createSyntax(
Optional<Syntax> createSyntax(
SyntaxKind Kind,
llvm::ArrayRef<Syntax> Elements,
const RC<SyntaxArena> &Arena
llvm::ArrayRef<Syntax> Elements
);

static const RawSyntax *createRaw(
const RawSyntax *createRaw(
SyntaxKind Kind,
llvm::ArrayRef<const RawSyntax *> Elements,
const RC<SyntaxArena> &Arena
llvm::ArrayRef<const RawSyntax *> Elements
);

/// Count the number of children for a given syntax node kind,
/// returning a pair of mininum and maximum count of children. The gap
/// between these two numbers is the number of optional children.
static std::pair<unsigned, unsigned> countChildren(SyntaxKind Kind);

static Syntax
makeBlankCollectionSyntax(SyntaxKind Kind, const RC<SyntaxArena> &Arena);
Syntax makeBlankCollectionSyntax(SyntaxKind Kind);

% for node in SYNTAX_NODES:
% if node.children:
Expand All @@ -90,117 +77,98 @@ struct SyntaxFactory {
% child_params.append("%s %s" % (param_type, child.name))
% end
% child_params = ', '.join(child_params)
static ${node.name} make${node.syntax_kind}(${child_params},
const RC<SyntaxArena> &Arena
);
${node.name} make${node.syntax_kind}(${child_params});
% elif node.is_syntax_collection():
static ${node.name} make${node.syntax_kind}(
const std::vector<${node.collection_element_type}> &elts,
const RC<SyntaxArena> &Arena
${node.name} make${node.syntax_kind}(
const std::vector<${node.collection_element_type}> &elts
);
% end

static ${node.name} makeBlank${node.syntax_kind}(
const RC<SyntaxArena> &Arena
);
${node.name} makeBlank${node.syntax_kind}();
% end

% for token in SYNTAX_TOKENS:
% if token.is_keyword:
static TokenSyntax make${token.name}Keyword(
TokenSyntax make${token.name}Keyword(
StringRef LeadingTrivia,
StringRef TrailingTrivia,
const RC<SyntaxArena> &Arena
StringRef TrailingTrivi
);
% elif token.text:
static TokenSyntax make${token.name}Token(
TokenSyntax make${token.name}Token(
StringRef LeadingTrivia,
StringRef TrailingTrivia,
const RC<SyntaxArena> &Arena
StringRef TrailingTrivia
);
% else:
static TokenSyntax make${token.name}(
TokenSyntax make${token.name}(
StringRef Text,
StringRef LeadingTrivia, StringRef TrailingTrivia,
const RC<SyntaxArena> &Arena
StringRef LeadingTrivia, StringRef TrailingTrivia
);
% end
% end

#pragma mark - Convenience APIs

static TupleTypeSyntax makeVoidTupleType(
const RC<SyntaxArena> &Arena
);
TupleTypeSyntax makeVoidTupleType();

/// Creates an labelled TupleTypeElementSyntax with the provided label,
/// colon, type and optional trailing comma.
static TupleTypeElementSyntax makeTupleTypeElement(
TupleTypeElementSyntax makeTupleTypeElement(
llvm::Optional<TokenSyntax> Label,
llvm::Optional<TokenSyntax> Colon, TypeSyntax Type,
llvm::Optional<TokenSyntax> TrailingComma,
const RC<SyntaxArena> &Arena
llvm::Optional<TokenSyntax> TrailingComma
);

/// Creates an unlabelled TupleTypeElementSyntax with the provided type and
/// optional trailing comma.
static TupleTypeElementSyntax
TupleTypeElementSyntax
makeTupleTypeElement(
TypeSyntax Type,
llvm::Optional<TokenSyntax> TrailingComma,
const RC<SyntaxArena> &Arena
llvm::Optional<TokenSyntax> TrailingComma
);

/// Creates a TypeIdentifierSyntax with the provided name and leading/trailing
/// trivia.
static TypeSyntax makeTypeIdentifier(
TypeSyntax makeTypeIdentifier(
StringRef TypeName,
StringRef LeadingTrivia, StringRef TrailingTrivia,
const RC<SyntaxArena> &Arena
StringRef LeadingTrivia, StringRef TrailingTrivia
);

/// Creates a GenericParameterSyntax with no inheritance clause and an
/// optional trailing comma.
static GenericParameterSyntax
GenericParameterSyntax
makeGenericParameter(
TokenSyntax Name,
llvm::Optional<TokenSyntax> TrailingComma,
const RC<SyntaxArena> &Arena
llvm::Optional<TokenSyntax> TrailingComma
);

/// Creates a TypeIdentifierSyntax for the `Any` type.
static TypeSyntax makeAnyTypeIdentifier(
TypeSyntax makeAnyTypeIdentifier(
StringRef LeadingTrivia,
StringRef TrailingTrivia,
const RC<SyntaxArena> &Arena
StringRef TrailingTrivia
);

/// Creates a TypeIdentifierSyntax for the `Self` type.
static TypeSyntax makeSelfTypeIdentifier(
TypeSyntax makeSelfTypeIdentifier(
StringRef LeadingTrivia,
StringRef TrailingTrivia,
const RC<SyntaxArena> &Arena
StringRef TrailingTrivia
);

/// Creates a TokenSyntax for the `Type` identifier.
static TokenSyntax makeTypeToken(
TokenSyntax makeTypeToken(
StringRef LeadingTrivia,
StringRef TrailingTrivia,
const RC<SyntaxArena> &Arena
StringRef TrailingTrivia
);

/// Creates a TokenSyntax for the `Protocol` identifier.
static TokenSyntax makeProtocolToken(
TokenSyntax makeProtocolToken(
StringRef LeadingTrivia,
StringRef TrailingTrivia,
const RC<SyntaxArena> &Arena
StringRef TrailingTrivia
);

/// Creates an `==` operator token.
static TokenSyntax makeEqualityOperator(
TokenSyntax makeEqualityOperator(
StringRef LeadingTrivia,
StringRef TrailingTrivia,
const RC<SyntaxArena> &Arena
StringRef TrailingTrivia
);

/// Whether a raw node kind `MemberKind` can serve as a member in a syntax
Expand Down
Loading