%{
  from gyb_syntax_support import *
  # -*- mode: C++ -*-
  # Ignore the following admonition; it applies to the resulting .h file only
}%
//// Automatically Generated From SyntaxFactory.h.gyb.
//// Do Not Edit Directly!
//===------------- SyntaxFactory.h - Syntax Factory definition ------------===//
//
// 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_FACTORY_H
#define SWIFT_SYNTAX_FACTORY_H

#include "swift/Syntax/SyntaxNodes.h"
#include "swift/Syntax/Trivia.h"
#include "llvm/ADT/ArrayRef.h"

#include <vector>

namespace swift {
namespace syntax {

class SyntaxArena;

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

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

  /// Make any kind of token.
  TokenSyntax makeToken(tok Kind,
      StringRef Text,
      StringRef LeadingTrivia,
      StringRef TrailingTrivia,
      SourcePresence Presence
  );

  /// Collect a list of tokens into a piece of "unknown" syntax.
  UnknownSyntax makeUnknownSyntax(llvm::ArrayRef<TokenSyntax> Tokens);

  Optional<Syntax> createSyntax(
      SyntaxKind Kind,
      llvm::ArrayRef<Syntax> Elements
  );

  const RawSyntax *createRaw(
      SyntaxKind Kind,
      llvm::ArrayRef<const RawSyntax *> Elements
  );

  /// Count the number of children for a given syntax node kind,
  /// returning a pair of minimum 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);

  Syntax makeBlankCollectionSyntax(SyntaxKind Kind);

% for node in SYNTAX_NODES:
%   if node.children:
%     child_params = []
%     for child in node.children:
%         param_type = child.type_name
%         if child.is_optional:
%            param_type = "llvm::Optional<%s>" % param_type
%         end
%         child_params.append("%s %s" % (param_type, child.name))
%     end
%     child_params = ', '.join(child_params)
  ${node.name} make${node.syntax_kind}(${child_params});
%   elif node.is_syntax_collection():
  ${node.name} make${node.syntax_kind}(
      const std::vector<${node.collection_element_type}> &elts
  );
%   end

  ${node.name} makeBlank${node.syntax_kind}();
% end

% for token in SYNTAX_TOKENS:
%   if token.is_keyword:
  TokenSyntax make${token.name}Keyword(
      StringRef LeadingTrivia,
      StringRef TrailingTrivi
  );
%   elif token.text:
  TokenSyntax make${token.name}Token(
      StringRef LeadingTrivia,
      StringRef TrailingTrivia
  );
%   else:
  TokenSyntax make${token.name}(
      StringRef Text,
      StringRef LeadingTrivia, StringRef TrailingTrivia
  );
%   end
% end

#pragma mark - Convenience APIs

  TupleTypeSyntax makeVoidTupleType();

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

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

  /// Creates a TypeIdentifierSyntax with the provided name and leading/trailing
  /// trivia.
  TypeSyntax makeTypeIdentifier(
      StringRef TypeName,
      StringRef LeadingTrivia, StringRef TrailingTrivia
  );

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

  /// Creates a TypeIdentifierSyntax for the `Any` type.
  TypeSyntax makeAnyTypeIdentifier(
      StringRef LeadingTrivia,
      StringRef TrailingTrivia
  );

  /// Creates a TypeIdentifierSyntax for the `Self` type.
  TypeSyntax makeSelfTypeIdentifier(
      StringRef LeadingTrivia,
      StringRef TrailingTrivia
  );

  /// Creates a TokenSyntax for the `Type` identifier.
  TokenSyntax makeTypeToken(
      StringRef LeadingTrivia,
      StringRef TrailingTrivia
  );

  /// Creates a TokenSyntax for the `Protocol` identifier.
  TokenSyntax makeProtocolToken(
      StringRef LeadingTrivia,
      StringRef TrailingTrivia
  );

  /// Creates an `==` operator token.
  TokenSyntax makeEqualityOperator(
      StringRef LeadingTrivia,
      StringRef TrailingTrivia
  );

  /// Whether a raw node kind `MemberKind` can serve as a member in a syntax
  /// collection of the given syntax collection kind.
  static bool canServeAsCollectionMemberRaw(SyntaxKind CollectionKind,
                                            SyntaxKind MemberKind);

  /// Whether a raw node `Member` can serve as a member in a syntax collection
  /// of the given syntax collection kind.
  static bool canServeAsCollectionMemberRaw(SyntaxKind CollectionKind,
                                            const RawSyntax *Member);

  /// Whether a node `Member` can serve as a member in a syntax collection of
  /// the given syntax collection kind.
  static bool canServeAsCollectionMember(SyntaxKind CollectionKind, Syntax Member);
};
}
}

#endif // SWIFT_SYNTAX_FACTORY_H