SyntaxFactory.cpp.gyb

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

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

#include <vector>

using namespace swift;
using namespace swift::syntax;

TokenSyntax SyntaxFactory::makeToken(tok Kind, StringRef Text,
                                     StringRef LeadingTrivia,
                                     StringRef TrailingTrivia,
                                     SourcePresence Presence) {
  return makeRoot<TokenSyntax>(RawSyntax::makeAndCalcLength(Kind, Text, 
    LeadingTrivia, TrailingTrivia, Presence, Arena));
}

UnknownSyntax
SyntaxFactory::makeUnknownSyntax(llvm::ArrayRef<TokenSyntax> Tokens) {
  auto RawTokens = llvm::map_iterator(Tokens.begin(),
    [](const TokenSyntax &Token) -> const RawSyntax * {
      return Token.getRaw();
    });
  auto Raw = RawSyntax::make(SyntaxKind::Unknown, RawTokens, Tokens.size(),
                             SourcePresence::Present, Arena);
  return makeRoot<UnknownSyntax>(Raw);
}

Syntax SyntaxFactory::makeBlankCollectionSyntax(SyntaxKind Kind) {
  switch(Kind) {
% for node in SYNTAX_NODES:
%   if node.is_syntax_collection():
  case SyntaxKind::${node.syntax_kind}:
    return makeBlank${node.syntax_kind}();
%   end
% end
  default: break;
  }
  llvm_unreachable("not collection kind.");
}

std::pair<unsigned, unsigned>
SyntaxFactory::countChildren(SyntaxKind Kind){
  switch(Kind) {
% for node in SYNTAX_NODES:
%   if not node.is_syntax_collection():
  case SyntaxKind::${node.syntax_kind}:
%     child_count = len(node.children)
%     non_optional_child_count = sum(0 if child.is_optional else 1 for child in node.children)
    return {${non_optional_child_count}, ${child_count}};
%   end
% end
  default:
  llvm_unreachable("bad syntax kind.");
  }
}

bool SyntaxFactory::canServeAsCollectionMemberRaw(SyntaxKind CollectionKind,
                                                  SyntaxKind MemberKind) {
  switch (CollectionKind) {
% for node in SYNTAX_NODES:
%   if node.is_syntax_collection():
  case SyntaxKind::${node.syntax_kind}:
%     if node.collection_element_choices:
%       element_checks = []
%       for choice in node.collection_element_choices:
%         element_checks.append("" + choice + "Syntax::kindof(MemberKind)")
%       end
    return ${' || '.join(element_checks)};
%     else:
    return ${node.collection_element_type}::kindof(MemberKind);
%     end
%   end
% end
  default:
    llvm_unreachable("Not collection kind.");
  }
}

bool SyntaxFactory::canServeAsCollectionMemberRaw(SyntaxKind CollectionKind,
                                                  const RawSyntax *Member) {
  return canServeAsCollectionMemberRaw(CollectionKind, Member->getKind());
}

bool SyntaxFactory::
canServeAsCollectionMember(SyntaxKind CollectionKind, Syntax Member) {
  return canServeAsCollectionMemberRaw(CollectionKind, Member.getRaw());
}

const RawSyntax *SyntaxFactory::createRaw(
  SyntaxKind Kind,
  llvm::ArrayRef<const RawSyntax *> Elements
) {
  switch (Kind) {
% for node in SYNTAX_NODES:
  case SyntaxKind::${node.syntax_kind}: {
% if node.children:
%   child_count = len(node.children)
    const RawSyntax *Layout[${child_count}];
    unsigned I = 0;
%   for (child_idx, child) in enumerate(node.children):
    // child[${child_idx}] ${child.name}
    if (I == Elements.size() ||
        !${check_child_condition_raw(child)}(Elements[I])) {
%     if child.is_optional:
      Layout[${child_idx}] = nullptr;
%     else:
      return nullptr;
%     end
    } else {
      Layout[${child_idx}] = Elements[I];
      ++I;
    }
%   end
    if (I != Elements.size())
      return nullptr;
    return RawSyntax::make(Kind, Layout, SourcePresence::Present, Arena);
% elif node.is_syntax_collection():
    for (auto &E : Elements) {
      if (!canServeAsCollectionMemberRaw(SyntaxKind::${node.syntax_kind}, E))
        return nullptr;
    }
    return RawSyntax::make(Kind, Elements, SourcePresence::Present, Arena);
% else:
    return nullptr;
% end
  }
% end
  default:
    return nullptr;
  }
}

Optional<Syntax> SyntaxFactory::createSyntax(SyntaxKind Kind,
                                             llvm::ArrayRef<Syntax> Elements) {
  std::vector<const RawSyntax *> Layout;
  Layout.reserve(Elements.size());
  for (auto &E : Elements)
    Layout.emplace_back(E.getRaw());

  if (auto Raw = createRaw(Kind, Layout))
    return makeRoot<Syntax>(Raw);
  else
    return None;
}

% 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
%         child_params.append("%s %s" % (param_type, child.name))
%     child_params = ', '.join(child_params)
${node.name}
SyntaxFactory::make${node.syntax_kind}(${child_params}) {
  auto Raw = RawSyntax::make(SyntaxKind::${node.syntax_kind}, {
%     for child in node.children:
%       if child.is_optional:
    ${child.name}.hasValue() ? ${child.name}->getRaw() : nullptr,
%       else:
    ${child.name}.getRaw(),
%       end
%     end
  }, SourcePresence::Present, Arena);
  return makeRoot<${node.name}>(Raw);
}
%   elif node.is_syntax_collection():
${node.name}
SyntaxFactory::make${node.syntax_kind}(
    const std::vector<${node.collection_element_type}> &elements) {
  std::vector<const RawSyntax *> layout;
  layout.reserve(elements.size());
  for (auto &element : elements) {
    layout.push_back(element.getRaw());
  }
  auto raw = RawSyntax::make(SyntaxKind::${node.syntax_kind}, layout,
    SourcePresence::Present, Arena);
  return makeRoot<${node.name}>(raw);
}
%   end

${node.name}
SyntaxFactory::makeBlank${node.syntax_kind}() {
  auto raw = RawSyntax::make(SyntaxKind::${node.syntax_kind}, {
%   for child in node.children:
%       if child.is_optional:
    nullptr,
%       else:
    ${make_missing_child(child)},
%       end
%   end
  }, SourcePresence::Present, Arena);
  return makeRoot<${node.name}>(raw);
}
% end

% for token in SYNTAX_TOKENS:
%   if token.is_keyword:
  TokenSyntax
  SyntaxFactory::make${token.name}Keyword(StringRef LeadingTrivia,
                                          StringRef TrailingTrivia) {
    return makeToken(tok::${token.kind}, "${token.text}", LeadingTrivia,
                     TrailingTrivia, SourcePresence::Present);
  }
%   elif token.text:
  TokenSyntax
  SyntaxFactory::make${token.name}Token(StringRef LeadingTrivia,
                                        StringRef TrailingTrivia) {
    return makeToken(tok::${token.kind}, "${token.text}", LeadingTrivia,
                     TrailingTrivia, SourcePresence::Present);
  }
%   else:
  TokenSyntax
  SyntaxFactory::make${token.name}(StringRef Text,
                                   StringRef LeadingTrivia,
                                   StringRef TrailingTrivia) {
    return makeToken(tok::${token.kind}, Text, LeadingTrivia, TrailingTrivia,
                     SourcePresence::Present);
  }
%   end
% end

TupleTypeSyntax SyntaxFactory::makeVoidTupleType() {
  return makeTupleType(makeLeftParenToken({}, {}),
                       makeBlankTupleTypeElementList(),
                       makeRightParenToken({}, {}));
}

TupleTypeElementSyntax
SyntaxFactory::makeTupleTypeElement(llvm::Optional<TokenSyntax> Label,
                                    llvm::Optional<TokenSyntax> Colon,
                                    TypeSyntax Type,
                                    llvm::Optional<TokenSyntax> TrailingComma) {
  return makeTupleTypeElement(None, Label, None, Colon, Type, None, None,
                              TrailingComma);
}

TupleTypeElementSyntax
SyntaxFactory::makeTupleTypeElement(TypeSyntax Type,
                                    llvm::Optional<TokenSyntax> TrailingComma) {
  return makeTupleTypeElement(None, None, None, None, Type, None, None,
                              TrailingComma);
}

GenericParameterSyntax
SyntaxFactory::makeGenericParameter(TokenSyntax Name,
                                    llvm::Optional<TokenSyntax> TrailingComma) {
  return makeGenericParameter(None, Name, None, None, TrailingComma);
}

TypeSyntax SyntaxFactory::makeTypeIdentifier(StringRef TypeName,
                                             StringRef LeadingTrivia,
                                             StringRef TrailingTrivia) {
  auto identifier =
      makeIdentifier(TypeName, LeadingTrivia, TrailingTrivia);
  return makeSimpleTypeIdentifier(identifier, None);
}

TypeSyntax SyntaxFactory::makeAnyTypeIdentifier(StringRef LeadingTrivia,
                                                StringRef TrailingTrivia) {
  return makeTypeIdentifier("Any", LeadingTrivia, TrailingTrivia);
}

TypeSyntax SyntaxFactory::makeSelfTypeIdentifier(StringRef LeadingTrivia,
                                                 StringRef TrailingTrivia) {
  return makeTypeIdentifier("Self", LeadingTrivia, TrailingTrivia);
}

TokenSyntax SyntaxFactory::makeTypeToken(StringRef LeadingTrivia,
                                         StringRef TrailingTrivia) {
  return makeIdentifier("Type", LeadingTrivia, TrailingTrivia);
}

TokenSyntax SyntaxFactory::makeProtocolToken(StringRef LeadingTrivia,
                                             StringRef TrailingTrivia) {
  return makeIdentifier("Protocol", LeadingTrivia, TrailingTrivia);
}

TokenSyntax SyntaxFactory::makeEqualityOperator(StringRef LeadingTrivia,
                                                StringRef TrailingTrivia) {
  return makeToken(tok::oper_binary_spaced, "==", LeadingTrivia, TrailingTrivia, 
                   SourcePresence::Present);
}