mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
d0cb7ad624
Currently, when creating a `RawSyntax` layout node, the `RawSyntax` constructor needs to iterate over all child nodes to a) sum up their sub node count b) add their arena as a child arena of the new node's arena But we are already iterating over all child nodes in every place that calls these constructors. So instead of looping twice, we can perform the above operations in the loop that already exists and pass the parameters to the `RawSyntax` constructor, which spees up `RawSyntax` node creation. To ensure the integrity of the `RawSyntax` tree, the passed in values are still validated in release builds.
306 lines
10 KiB
C++
306 lines
10 KiB
C++
%{
|
|
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);
|
|
}
|