mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
43b9d13a2e
So far single payload enums were implemented in terms of runtime functions which internally emitted several calls to value witnesses. This commit adds value witnesses to get and store the enum tag side stepping the need for witness calls as this information is statically available in many cases /// int (*getEnumTagSinglePayload)(const T* enum, UINT_TYPE emptyCases) /// Given an instance of valid single payload enum with a payload of this /// witness table's type (e.g Optional<ThisType>) , get the tag of the enum. /// void (*storeEnumTagSinglePayload)(T* enum, INT_TYPE whichCase, /// UINT_TYPE emptyCases) /// Given uninitialized memory for an instance of a single payload enum with a /// payload of this witness table's type (e.g Optional<ThisType>), store the /// tag. A simple 'for element in array' loop in generic code operating on a ContigousArray of Int is ~25% faster on arm64. rdar://31408033
1919 lines
62 KiB
C++
1919 lines
62 KiB
C++
//===--- NodePrinter.cpp - Swift Demangling Node Printer ------------------===//
|
|
//
|
|
// 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 implements the node printer for demangle node trees.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "swift/Demangling/Demangle.h"
|
|
#include "swift/Strings.h"
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
|
|
using namespace swift;
|
|
using namespace Demangle;
|
|
using llvm::StringRef;
|
|
|
|
[[noreturn]]
|
|
static void printer_unreachable(const char *Message) {
|
|
fprintf(stderr, "fatal error: %s\n", Message);
|
|
std::abort();
|
|
}
|
|
|
|
DemanglerPrinter &DemanglerPrinter::operator<<(unsigned long long n) & {
|
|
char buffer[32];
|
|
snprintf(buffer, sizeof(buffer), "%llu", n);
|
|
Stream.append(buffer);
|
|
return *this;
|
|
}
|
|
DemanglerPrinter &DemanglerPrinter::operator<<(long long n) & {
|
|
char buffer[32];
|
|
snprintf(buffer, sizeof(buffer), "%lld",n);
|
|
Stream.append(buffer);
|
|
return *this;
|
|
}
|
|
|
|
std::string Demangle::archetypeName(Node::IndexType index,
|
|
Node::IndexType depth) {
|
|
DemanglerPrinter name;
|
|
do {
|
|
name << (char)('A' + (index % 26));
|
|
index /= 26;
|
|
} while (index);
|
|
if (depth != 0)
|
|
name << depth;
|
|
return std::move(name).str();
|
|
}
|
|
|
|
namespace {
|
|
|
|
struct QuotedString {
|
|
std::string Value;
|
|
|
|
explicit QuotedString(std::string Value) : Value(Value) {}
|
|
};
|
|
|
|
static DemanglerPrinter &operator<<(DemanglerPrinter &printer,
|
|
const QuotedString &QS) {
|
|
printer << '"';
|
|
for (auto C : QS.Value) {
|
|
switch (C) {
|
|
case '\\': printer << "\\\\"; break;
|
|
case '\t': printer << "\\t"; break;
|
|
case '\n': printer << "\\n"; break;
|
|
case '\r': printer << "\\r"; break;
|
|
case '"': printer << "\\\""; break;
|
|
case '\'': printer << '\''; break; // no need to escape these
|
|
case '\0': printer << "\\0"; break;
|
|
default:
|
|
auto c = static_cast<char>(C);
|
|
// Other ASCII control characters should get escaped.
|
|
if (c < 0x20 || c == 0x7F) {
|
|
static const char Hexdigit[] = {
|
|
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
|
|
'A', 'B', 'C', 'D', 'E', 'F'
|
|
};
|
|
printer << "\\x" << Hexdigit[c >> 4] << Hexdigit[c & 0xF];
|
|
} else {
|
|
printer << c;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
printer << '"';
|
|
return printer;
|
|
}
|
|
|
|
static StringRef toString(Directness d) {
|
|
switch (d) {
|
|
case Directness::Direct:
|
|
return "direct";
|
|
case Directness::Indirect:
|
|
return "indirect";
|
|
}
|
|
printer_unreachable("bad directness");
|
|
}
|
|
|
|
static StringRef toString(ValueWitnessKind k) {
|
|
switch (k) {
|
|
case ValueWitnessKind::AllocateBuffer:
|
|
return "allocateBuffer";
|
|
case ValueWitnessKind::AssignWithCopy:
|
|
return "assignWithCopy";
|
|
case ValueWitnessKind::AssignWithTake:
|
|
return "assignWithTake";
|
|
case ValueWitnessKind::DeallocateBuffer:
|
|
return "deallocateBuffer";
|
|
case ValueWitnessKind::Destroy:
|
|
return "destroy";
|
|
case ValueWitnessKind::DestroyBuffer:
|
|
return "destroyBuffer";
|
|
case ValueWitnessKind::InitializeBufferWithCopyOfBuffer:
|
|
return "initializeBufferWithCopyOfBuffer";
|
|
case ValueWitnessKind::InitializeBufferWithCopy:
|
|
return "initializeBufferWithCopy";
|
|
case ValueWitnessKind::InitializeWithCopy:
|
|
return "initializeWithCopy";
|
|
case ValueWitnessKind::InitializeBufferWithTake:
|
|
return "initializeBufferWithTake";
|
|
case ValueWitnessKind::InitializeWithTake:
|
|
return "initializeWithTake";
|
|
case ValueWitnessKind::ProjectBuffer:
|
|
return "projectBuffer";
|
|
case ValueWitnessKind::InitializeBufferWithTakeOfBuffer:
|
|
return "initializeBufferWithTakeOfBuffer";
|
|
case ValueWitnessKind::DestroyArray:
|
|
return "destroyArray";
|
|
case ValueWitnessKind::InitializeArrayWithCopy:
|
|
return "initializeArrayWithCopy";
|
|
case ValueWitnessKind::InitializeArrayWithTakeFrontToBack:
|
|
return "initializeArrayWithTakeFrontToBack";
|
|
case ValueWitnessKind::InitializeArrayWithTakeBackToFront:
|
|
return "initializeArrayWithTakeBackToFront";
|
|
case ValueWitnessKind::StoreExtraInhabitant:
|
|
return "storeExtraInhabitant";
|
|
case ValueWitnessKind::GetExtraInhabitantIndex:
|
|
return "getExtraInhabitantIndex";
|
|
case ValueWitnessKind::GetEnumTag:
|
|
return "getEnumTag";
|
|
case ValueWitnessKind::DestructiveProjectEnumData:
|
|
return "destructiveProjectEnumData";
|
|
case ValueWitnessKind::DestructiveInjectEnumTag:
|
|
return "destructiveInjectEnumTag";
|
|
case ValueWitnessKind::GetEnumTagSinglePayload:
|
|
return "getEnumTagSinglePayload";
|
|
case ValueWitnessKind::StoreEnumTagSinglePayload:
|
|
return "storeEnumTagSinglePayload";
|
|
}
|
|
printer_unreachable("bad value witness kind");
|
|
}
|
|
|
|
class NodePrinter {
|
|
private:
|
|
DemanglerPrinter Printer;
|
|
DemangleOptions Options;
|
|
bool SpecializationPrefixPrinted = false;
|
|
|
|
public:
|
|
NodePrinter(DemangleOptions options) : Options(options) {}
|
|
|
|
std::string printRoot(NodePointer root) {
|
|
print(root);
|
|
return std::move(Printer).str();
|
|
}
|
|
|
|
private:
|
|
void printChildren(Node::iterator begin,
|
|
Node::iterator end,
|
|
const char *sep = nullptr) {
|
|
for (; begin != end;) {
|
|
print(*begin);
|
|
++begin;
|
|
if (sep && begin != end)
|
|
Printer << sep;
|
|
}
|
|
}
|
|
|
|
void printChildren(NodePointer Node, const char *sep = nullptr) {
|
|
if (!Node)
|
|
return;
|
|
Node::iterator begin = Node->begin(), end = Node->end();
|
|
printChildren(begin, end, sep);
|
|
}
|
|
|
|
NodePointer getFirstChildOfKind(NodePointer Node, Node::Kind kind) {
|
|
if (!Node)
|
|
return nullptr;
|
|
for (NodePointer &child : *Node) {
|
|
if (child && child->getKind() == kind)
|
|
return child;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void printBoundGenericNoSugar(NodePointer Node) {
|
|
if (Node->getNumChildren() < 2)
|
|
return;
|
|
NodePointer typelist = Node->getChild(1);
|
|
print(Node->getChild(0));
|
|
Printer << "<";
|
|
printChildren(typelist, ", ");
|
|
Printer << ">";
|
|
}
|
|
|
|
static bool isSwiftModule(NodePointer node) {
|
|
return (node->getKind() == Node::Kind::Module &&
|
|
node->getText() == STDLIB_NAME);
|
|
}
|
|
|
|
bool printContext(NodePointer Context) {
|
|
if (!Options.QualifyEntities)
|
|
return false;
|
|
|
|
if (Context->getKind() == Node::Kind::Module &&
|
|
Context->getText().startswith(LLDB_EXPRESSIONS_MODULE_NAME_PREFIX)) {
|
|
return Options.DisplayDebuggerGeneratedModule;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool isIdentifier(NodePointer node, StringRef desired) {
|
|
return (node->getKind() == Node::Kind::Identifier &&
|
|
node->getText() == desired);
|
|
}
|
|
|
|
enum class SugarType {
|
|
None,
|
|
Optional,
|
|
ImplicitlyUnwrappedOptional,
|
|
Array,
|
|
Dictionary
|
|
};
|
|
|
|
enum class TypePrinting {
|
|
NoType,
|
|
WithColon,
|
|
FunctionStyle
|
|
};
|
|
|
|
/// Determine whether this is a "simple" type, from the type-simple
|
|
/// production.
|
|
bool isSimpleType(NodePointer Node) {
|
|
switch (Node->getKind()) {
|
|
case Node::Kind::AssociatedType:
|
|
case Node::Kind::AssociatedTypeRef:
|
|
case Node::Kind::BoundGenericClass:
|
|
case Node::Kind::BoundGenericEnum:
|
|
case Node::Kind::BoundGenericStructure:
|
|
case Node::Kind::BuiltinTypeName:
|
|
case Node::Kind::Class:
|
|
case Node::Kind::DependentGenericType:
|
|
case Node::Kind::DependentMemberType:
|
|
case Node::Kind::DependentGenericParamType:
|
|
case Node::Kind::DynamicSelf:
|
|
case Node::Kind::Enum:
|
|
case Node::Kind::ErrorType:
|
|
case Node::Kind::ExistentialMetatype:
|
|
case Node::Kind::Metatype:
|
|
case Node::Kind::MetatypeRepresentation:
|
|
case Node::Kind::Module:
|
|
case Node::Kind::Tuple:
|
|
case Node::Kind::Protocol:
|
|
case Node::Kind::QualifiedArchetype:
|
|
case Node::Kind::ReturnType:
|
|
case Node::Kind::SILBoxType:
|
|
case Node::Kind::SILBoxTypeWithLayout:
|
|
case Node::Kind::Structure:
|
|
case Node::Kind::TupleElementName:
|
|
case Node::Kind::Type:
|
|
case Node::Kind::TypeAlias:
|
|
case Node::Kind::TypeList:
|
|
return true;
|
|
|
|
case Node::Kind::ProtocolList:
|
|
return Node->getChild(0)->getNumChildren() <= 1;
|
|
|
|
case Node::Kind::ProtocolListWithAnyObject:
|
|
return Node->getChild(0)->getChild(0)->getNumChildren() == 0;
|
|
|
|
case Node::Kind::ProtocolListWithClass:
|
|
case Node::Kind::Allocator:
|
|
case Node::Kind::ArgumentTuple:
|
|
case Node::Kind::AssociatedTypeMetadataAccessor:
|
|
case Node::Kind::AssociatedTypeWitnessTableAccessor:
|
|
case Node::Kind::AutoClosureType:
|
|
case Node::Kind::CFunctionPointer:
|
|
case Node::Kind::Constructor:
|
|
case Node::Kind::CurryThunk:
|
|
case Node::Kind::Deallocator:
|
|
case Node::Kind::DeclContext:
|
|
case Node::Kind::DefaultArgumentInitializer:
|
|
case Node::Kind::DependentAssociatedTypeRef:
|
|
case Node::Kind::DependentGenericSignature:
|
|
case Node::Kind::DependentGenericParamCount:
|
|
case Node::Kind::DependentGenericConformanceRequirement:
|
|
case Node::Kind::DependentGenericLayoutRequirement:
|
|
case Node::Kind::DependentGenericSameTypeRequirement:
|
|
case Node::Kind::DependentPseudogenericSignature:
|
|
case Node::Kind::Destructor:
|
|
case Node::Kind::DidSet:
|
|
case Node::Kind::DirectMethodReferenceAttribute:
|
|
case Node::Kind::Directness:
|
|
case Node::Kind::DynamicAttribute:
|
|
case Node::Kind::ExplicitClosure:
|
|
case Node::Kind::Extension:
|
|
case Node::Kind::FieldOffset:
|
|
case Node::Kind::FullTypeMetadata:
|
|
case Node::Kind::Function:
|
|
case Node::Kind::FunctionSignatureSpecialization:
|
|
case Node::Kind::FunctionSignatureSpecializationParam:
|
|
case Node::Kind::FunctionSignatureSpecializationParamKind:
|
|
case Node::Kind::FunctionSignatureSpecializationParamPayload:
|
|
case Node::Kind::FunctionType:
|
|
case Node::Kind::GenericProtocolWitnessTable:
|
|
case Node::Kind::GenericProtocolWitnessTableInstantiationFunction:
|
|
case Node::Kind::GenericPartialSpecialization:
|
|
case Node::Kind::GenericPartialSpecializationNotReAbstracted:
|
|
case Node::Kind::GenericSpecialization:
|
|
case Node::Kind::GenericSpecializationNotReAbstracted:
|
|
case Node::Kind::GenericSpecializationParam:
|
|
case Node::Kind::GenericTypeMetadataPattern:
|
|
case Node::Kind::Getter:
|
|
case Node::Kind::Global:
|
|
case Node::Kind::GlobalGetter:
|
|
case Node::Kind::Identifier:
|
|
case Node::Kind::Index:
|
|
case Node::Kind::IVarInitializer:
|
|
case Node::Kind::IVarDestroyer:
|
|
case Node::Kind::ImplEscaping:
|
|
case Node::Kind::ImplConvention:
|
|
case Node::Kind::ImplFunctionAttribute:
|
|
case Node::Kind::ImplFunctionType:
|
|
case Node::Kind::ImplicitClosure:
|
|
case Node::Kind::ImplParameter:
|
|
case Node::Kind::ImplResult:
|
|
case Node::Kind::ImplErrorResult:
|
|
case Node::Kind::InOut:
|
|
case Node::Kind::InfixOperator:
|
|
case Node::Kind::Initializer:
|
|
case Node::Kind::KeyPathGetterThunkHelper:
|
|
case Node::Kind::KeyPathSetterThunkHelper:
|
|
case Node::Kind::KeyPathEqualsThunkHelper:
|
|
case Node::Kind::KeyPathHashThunkHelper:
|
|
case Node::Kind::LazyProtocolWitnessTableAccessor:
|
|
case Node::Kind::LazyProtocolWitnessTableCacheVariable:
|
|
case Node::Kind::LocalDeclName:
|
|
case Node::Kind::PrivateDeclName:
|
|
case Node::Kind::MaterializeForSet:
|
|
case Node::Kind::MergedFunction:
|
|
case Node::Kind::Metaclass:
|
|
case Node::Kind::NativeOwningAddressor:
|
|
case Node::Kind::NativeOwningMutableAddressor:
|
|
case Node::Kind::NativePinningAddressor:
|
|
case Node::Kind::NativePinningMutableAddressor:
|
|
case Node::Kind::NominalTypeDescriptor:
|
|
case Node::Kind::NonObjCAttribute:
|
|
case Node::Kind::Number:
|
|
case Node::Kind::ObjCAttribute:
|
|
case Node::Kind::ObjCBlock:
|
|
case Node::Kind::OwningAddressor:
|
|
case Node::Kind::OwningMutableAddressor:
|
|
case Node::Kind::PartialApplyForwarder:
|
|
case Node::Kind::PartialApplyObjCForwarder:
|
|
case Node::Kind::PostfixOperator:
|
|
case Node::Kind::PrefixOperator:
|
|
case Node::Kind::ProtocolConformance:
|
|
case Node::Kind::ProtocolDescriptor:
|
|
case Node::Kind::ProtocolWitness:
|
|
case Node::Kind::ProtocolWitnessTable:
|
|
case Node::Kind::ProtocolWitnessTableAccessor:
|
|
case Node::Kind::ReabstractionThunk:
|
|
case Node::Kind::ReabstractionThunkHelper:
|
|
case Node::Kind::Setter:
|
|
case Node::Kind::Shared:
|
|
case Node::Kind::SILBoxLayout:
|
|
case Node::Kind::SILBoxMutableField:
|
|
case Node::Kind::SILBoxImmutableField:
|
|
case Node::Kind::SpecializationIsFragile:
|
|
case Node::Kind::SpecializationPassID:
|
|
case Node::Kind::Static:
|
|
case Node::Kind::Subscript:
|
|
case Node::Kind::Suffix:
|
|
case Node::Kind::ThinFunctionType:
|
|
case Node::Kind::TupleElement:
|
|
case Node::Kind::TypeMangling:
|
|
case Node::Kind::TypeMetadata:
|
|
case Node::Kind::TypeMetadataAccessFunction:
|
|
case Node::Kind::TypeMetadataLazyCache:
|
|
case Node::Kind::UncurriedFunctionType:
|
|
case Node::Kind::Unmanaged:
|
|
case Node::Kind::Unowned:
|
|
case Node::Kind::UnsafeAddressor:
|
|
case Node::Kind::UnsafeMutableAddressor:
|
|
case Node::Kind::ValueWitness:
|
|
case Node::Kind::ValueWitnessTable:
|
|
case Node::Kind::Variable:
|
|
case Node::Kind::VTableAttribute:
|
|
case Node::Kind::VTableThunk:
|
|
case Node::Kind::Weak:
|
|
case Node::Kind::WillSet:
|
|
case Node::Kind::ReflectionMetadataBuiltinDescriptor:
|
|
case Node::Kind::ReflectionMetadataFieldDescriptor:
|
|
case Node::Kind::ReflectionMetadataAssocTypeDescriptor:
|
|
case Node::Kind::ReflectionMetadataSuperclassDescriptor:
|
|
case Node::Kind::GenericTypeParamDecl:
|
|
case Node::Kind::ThrowsAnnotation:
|
|
case Node::Kind::EmptyList:
|
|
case Node::Kind::FirstElementMarker:
|
|
case Node::Kind::VariadicMarker:
|
|
case Node::Kind::OutlinedBridgedMethod:
|
|
case Node::Kind::OutlinedCopy:
|
|
case Node::Kind::OutlinedConsume:
|
|
case Node::Kind::OutlinedRetain:
|
|
case Node::Kind::OutlinedRelease:
|
|
case Node::Kind::OutlinedVariable:
|
|
case Node::Kind::AssocTypePath:
|
|
return false;
|
|
}
|
|
printer_unreachable("bad node kind");
|
|
}
|
|
|
|
SugarType findSugar(NodePointer Node) {
|
|
if (Node->getNumChildren() == 1 &&
|
|
Node->getKind() == Node::Kind::Type)
|
|
return findSugar(Node->getChild(0));
|
|
|
|
if (Node->getNumChildren() != 2)
|
|
return SugarType::None;
|
|
|
|
if (Node->getKind() != Node::Kind::BoundGenericEnum &&
|
|
Node->getKind() != Node::Kind::BoundGenericStructure)
|
|
return SugarType::None;
|
|
|
|
auto unboundType = Node->getChild(0)->getChild(0); // drill through Type
|
|
auto typeArgs = Node->getChild(1);
|
|
|
|
if (Node->getKind() == Node::Kind::BoundGenericEnum) {
|
|
// Swift.Optional
|
|
if (isIdentifier(unboundType->getChild(1), "Optional") &&
|
|
typeArgs->getNumChildren() == 1 &&
|
|
isSwiftModule(unboundType->getChild(0))) {
|
|
return SugarType::Optional;
|
|
}
|
|
|
|
// Swift.ImplicitlyUnwrappedOptional
|
|
if (isIdentifier(unboundType->getChild(1),
|
|
"ImplicitlyUnwrappedOptional") &&
|
|
typeArgs->getNumChildren() == 1 &&
|
|
isSwiftModule(unboundType->getChild(0))) {
|
|
return SugarType::ImplicitlyUnwrappedOptional;
|
|
}
|
|
|
|
return SugarType::None;
|
|
}
|
|
|
|
assert(Node->getKind() == Node::Kind::BoundGenericStructure);
|
|
|
|
// Array
|
|
if (isIdentifier(unboundType->getChild(1), "Array") &&
|
|
typeArgs->getNumChildren() == 1 &&
|
|
isSwiftModule(unboundType->getChild(0))) {
|
|
return SugarType::Array;
|
|
}
|
|
|
|
// Dictionary
|
|
if (isIdentifier(unboundType->getChild(1), "Dictionary") &&
|
|
typeArgs->getNumChildren() == 2 &&
|
|
isSwiftModule(unboundType->getChild(0))) {
|
|
return SugarType::Dictionary;
|
|
}
|
|
|
|
return SugarType::None;
|
|
}
|
|
|
|
void printBoundGeneric(NodePointer Node) {
|
|
if (Node->getNumChildren() < 2)
|
|
return;
|
|
if (Node->getNumChildren() != 2) {
|
|
printBoundGenericNoSugar(Node);
|
|
return;
|
|
}
|
|
|
|
if (!Options.SynthesizeSugarOnTypes ||
|
|
Node->getKind() == Node::Kind::BoundGenericClass)
|
|
{
|
|
// no sugar here
|
|
printBoundGenericNoSugar(Node);
|
|
return;
|
|
}
|
|
|
|
SugarType sugarType = findSugar(Node);
|
|
|
|
switch (sugarType) {
|
|
case SugarType::None:
|
|
printBoundGenericNoSugar(Node);
|
|
break;
|
|
case SugarType::Optional:
|
|
case SugarType::ImplicitlyUnwrappedOptional: {
|
|
NodePointer type = Node->getChild(1)->getChild(0);
|
|
bool needs_parens = !isSimpleType(type);
|
|
if (needs_parens)
|
|
Printer << "(";
|
|
print(type);
|
|
if (needs_parens)
|
|
Printer << ")";
|
|
Printer << (sugarType == SugarType::Optional ? "?" : "!");
|
|
break;
|
|
}
|
|
case SugarType::Array: {
|
|
NodePointer type = Node->getChild(1)->getChild(0);
|
|
Printer << "[";
|
|
print(type);
|
|
Printer << "]";
|
|
break;
|
|
}
|
|
case SugarType::Dictionary: {
|
|
NodePointer keyType = Node->getChild(1)->getChild(0);
|
|
NodePointer valueType = Node->getChild(1)->getChild(1);
|
|
Printer << "[";
|
|
print(keyType);
|
|
Printer << " : ";
|
|
print(valueType);
|
|
Printer << "]";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void printFunctionType(NodePointer node) {
|
|
assert(node->getNumChildren() == 2 || node->getNumChildren() == 3);
|
|
unsigned startIndex = 0;
|
|
bool throws = false;
|
|
if (node->getNumChildren() == 3) {
|
|
assert(node->getChild(0)->getKind() == Node::Kind::ThrowsAnnotation);
|
|
startIndex++;
|
|
throws = true;
|
|
}
|
|
if (Options.ShowFunctionArgumentTypes) {
|
|
print(node->getChild(startIndex));
|
|
if (throws) Printer << " throws";
|
|
print(node->getChild(startIndex+1));
|
|
return;
|
|
}
|
|
// Print simplified arguments
|
|
NodePointer Args = node->getChild(startIndex);
|
|
assert(Args->getKind() == Node::Kind::ArgumentTuple);
|
|
Args = Args->getFirstChild();
|
|
assert(Args->getKind() == Node::Kind::Type);
|
|
Args = Args->getFirstChild();
|
|
if (Args->getKind() != Node::Kind::Tuple) {
|
|
// only a single not-named argument
|
|
Printer << "(_:)";
|
|
return;
|
|
}
|
|
Printer << '(';
|
|
for (NodePointer Arg : *Args) {
|
|
assert(Arg->getKind() == Node::Kind::TupleElement);
|
|
unsigned NameIdx = 0;
|
|
if (Arg->getFirstChild()->getKind() == Node::Kind::VariadicMarker)
|
|
NameIdx = 1;
|
|
if (Arg->getChild(NameIdx)->getKind() == Node::Kind::TupleElementName) {
|
|
Printer << Arg->getChild(NameIdx)->getText();
|
|
} else {
|
|
Printer << '_';
|
|
}
|
|
Printer << ':';
|
|
}
|
|
Printer << ')';
|
|
}
|
|
|
|
void printImplFunctionType(NodePointer fn) {
|
|
enum State { Attrs, Inputs, Results } curState = Attrs;
|
|
auto transitionTo = [&](State newState) {
|
|
assert(newState >= curState);
|
|
for (; curState != newState; curState = State(curState + 1)) {
|
|
switch (curState) {
|
|
case Attrs: Printer << '('; continue;
|
|
case Inputs: Printer << ") -> ("; continue;
|
|
case Results: printer_unreachable("no state after Results");
|
|
}
|
|
printer_unreachable("bad state");
|
|
}
|
|
};
|
|
|
|
for (auto &child : *fn) {
|
|
if (child->getKind() == Node::Kind::ImplParameter) {
|
|
if (curState == Inputs) Printer << ", ";
|
|
transitionTo(Inputs);
|
|
print(child);
|
|
} else if (child->getKind() == Node::Kind::ImplResult
|
|
|| child->getKind() == Node::Kind::ImplErrorResult) {
|
|
if (curState == Results) Printer << ", ";
|
|
transitionTo(Results);
|
|
print(child);
|
|
} else {
|
|
assert(curState == Attrs);
|
|
print(child);
|
|
Printer << ' ';
|
|
}
|
|
}
|
|
transitionTo(Results);
|
|
Printer << ')';
|
|
}
|
|
|
|
unsigned printFunctionSigSpecializationParam(NodePointer Node,
|
|
unsigned Idx);
|
|
|
|
void printSpecializationPrefix(NodePointer node, StringRef Description,
|
|
StringRef ParamPrefix = StringRef());
|
|
|
|
/// The main big print function.
|
|
NodePointer print(NodePointer Node, bool asPrefixContext = false);
|
|
|
|
NodePointer printAbstractStorage(NodePointer Node, bool asPrefixContent,
|
|
StringRef ExtraName);
|
|
|
|
/// Utility function to print entities.
|
|
///
|
|
/// \param Entity The entity node to print
|
|
/// \param asPrefixContext Should the entity printed as a context which as a
|
|
/// prefix to another entity, e.g. the Abc in Abc.def()
|
|
/// \param TypePr How should the type of the entity be printed, if at all.
|
|
/// E.g. with a colon for properties or as a function type.
|
|
/// \param hasName Does the entity has a name, e.g. a function in contrast to
|
|
/// an initializer.
|
|
/// \param ExtraName An extra name added to the entity name (if any).
|
|
/// \param ExtraIndex An extra index added to the entity name (if any),
|
|
/// e.g. closure #1
|
|
/// \param OverwriteName If non-empty, print this name instead of the one
|
|
/// provided by the node. Gets printed even if hasName is false.
|
|
/// \return If a non-null node is returned it's a context which must be
|
|
/// printed in postfix-form after the entity: "<entity> in <context>".
|
|
NodePointer printEntity(NodePointer Entity, bool asPrefixContext,
|
|
TypePrinting TypePr, bool hasName,
|
|
StringRef ExtraName = "", int ExtraIndex = -1,
|
|
StringRef OverwriteName = "");
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
static bool isExistentialType(NodePointer node) {
|
|
return (node->getKind() == Node::Kind::ExistentialMetatype ||
|
|
node->getKind() == Node::Kind::ProtocolList ||
|
|
node->getKind() == Node::Kind::ProtocolListWithClass ||
|
|
node->getKind() == Node::Kind::ProtocolListWithAnyObject);
|
|
}
|
|
|
|
/// Print the relevant parameters and return the new index.
|
|
unsigned NodePrinter::printFunctionSigSpecializationParam(NodePointer Node,
|
|
unsigned Idx) {
|
|
NodePointer firstChild = Node->getChild(Idx);
|
|
unsigned V = firstChild->getIndex();
|
|
auto K = FunctionSigSpecializationParamKind(V);
|
|
switch (K) {
|
|
case FunctionSigSpecializationParamKind::BoxToValue:
|
|
case FunctionSigSpecializationParamKind::BoxToStack:
|
|
print(Node->getChild(Idx++));
|
|
return Idx;
|
|
case FunctionSigSpecializationParamKind::ConstantPropFunction:
|
|
case FunctionSigSpecializationParamKind::ConstantPropGlobal: {
|
|
Printer << "[";
|
|
print(Node->getChild(Idx++));
|
|
Printer << " : ";
|
|
const auto &text = Node->getChild(Idx++)->getText();
|
|
std::string demangledName = demangleSymbolAsString(text);
|
|
if (demangledName.empty()) {
|
|
Printer << text;
|
|
} else {
|
|
Printer << demangledName;
|
|
}
|
|
Printer << "]";
|
|
return Idx;
|
|
}
|
|
case FunctionSigSpecializationParamKind::ConstantPropInteger:
|
|
case FunctionSigSpecializationParamKind::ConstantPropFloat:
|
|
Printer << "[";
|
|
print(Node->getChild(Idx++));
|
|
Printer << " : ";
|
|
print(Node->getChild(Idx++));
|
|
Printer << "]";
|
|
return Idx;
|
|
case FunctionSigSpecializationParamKind::ConstantPropString:
|
|
Printer << "[";
|
|
print(Node->getChild(Idx++));
|
|
Printer << " : ";
|
|
print(Node->getChild(Idx++));
|
|
Printer << "'";
|
|
print(Node->getChild(Idx++));
|
|
Printer << "'";
|
|
Printer << "]";
|
|
return Idx;
|
|
case FunctionSigSpecializationParamKind::ClosureProp:
|
|
Printer << "[";
|
|
print(Node->getChild(Idx++));
|
|
Printer << " : ";
|
|
print(Node->getChild(Idx++));
|
|
Printer << ", Argument Types : [";
|
|
for (unsigned e = Node->getNumChildren(); Idx < e;) {
|
|
NodePointer child = Node->getChild(Idx);
|
|
// Until we no longer have a type node, keep demangling.
|
|
if (child->getKind() != Node::Kind::Type)
|
|
break;
|
|
print(child);
|
|
++Idx;
|
|
|
|
// If we are not done, print the ", ".
|
|
if (Idx < e && Node->getChild(Idx)->hasText())
|
|
Printer << ", ";
|
|
}
|
|
Printer << "]";
|
|
return Idx;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
assert(
|
|
((V & unsigned(FunctionSigSpecializationParamKind::OwnedToGuaranteed)) ||
|
|
(V & unsigned(FunctionSigSpecializationParamKind::SROA)) ||
|
|
(V & unsigned(FunctionSigSpecializationParamKind::Dead))) &&
|
|
"Invalid OptionSet");
|
|
print(Node->getChild(Idx++));
|
|
return Idx;
|
|
}
|
|
|
|
void NodePrinter::printSpecializationPrefix(NodePointer node,
|
|
StringRef Description,
|
|
StringRef ParamPrefix) {
|
|
if (!Options.DisplayGenericSpecializations) {
|
|
if (!SpecializationPrefixPrinted) {
|
|
Printer << "specialized ";
|
|
SpecializationPrefixPrinted = true;
|
|
}
|
|
return;
|
|
}
|
|
Printer << Description << " <";
|
|
const char *Separator = "";
|
|
for (unsigned i = 0, e = node->getNumChildren(); i < e; ++i) {
|
|
switch (node->getChild(i)->getKind()) {
|
|
case Node::Kind::SpecializationPassID:
|
|
// We skip the SpecializationPassID since it does not contain any
|
|
// information that is useful to our users.
|
|
break;
|
|
|
|
case Node::Kind::SpecializationIsFragile:
|
|
Printer << Separator;
|
|
Separator = ", ";
|
|
print(node->getChild(i));
|
|
break;
|
|
|
|
default:
|
|
// Ignore empty specializations.
|
|
if (node->getChild(i)->hasChildren()) {
|
|
Printer << Separator << ParamPrefix;
|
|
Separator = ", ";
|
|
print(node->getChild(i));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
Printer << "> of ";
|
|
}
|
|
|
|
static bool isClassType(NodePointer Node) {
|
|
return Node->getKind() == Node::Kind::Class;
|
|
}
|
|
|
|
static bool needSpaceBeforeType(NodePointer Type) {
|
|
switch (Type->getKind()) {
|
|
case Node::Kind::Type:
|
|
return needSpaceBeforeType(Type->getFirstChild());
|
|
case Node::Kind::FunctionType:
|
|
case Node::Kind::UncurriedFunctionType:
|
|
case Node::Kind::DependentGenericType:
|
|
return false;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
|
|
switch (Node->getKind()) {
|
|
case Node::Kind::Static:
|
|
Printer << "static ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::CurryThunk:
|
|
Printer << "curry thunk of ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::OutlinedBridgedMethod:
|
|
Printer << "outlined bridged method (" << Node->getText() << ") of ";
|
|
return nullptr;
|
|
case Node::Kind::OutlinedCopy:
|
|
Printer << "outlined copy of ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::OutlinedConsume:
|
|
Printer << "outlined consume of ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::OutlinedRetain:
|
|
Printer << "outlined retain of ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::OutlinedRelease:
|
|
Printer << "outlined release of ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::OutlinedVariable:
|
|
Printer << "outlined variable #" << Node->getIndex() << " of ";
|
|
return nullptr;
|
|
case Node::Kind::Directness:
|
|
Printer << toString(Directness(Node->getIndex())) << " ";
|
|
return nullptr;
|
|
case Node::Kind::Extension:
|
|
assert((Node->getNumChildren() == 2 || Node->getNumChildren() == 3)
|
|
&& "Extension expects 2 or 3 children.");
|
|
if (Options.QualifyEntities && Options.DisplayExtensionContexts) {
|
|
Printer << "(extension in ";
|
|
// Print the module where extension is defined.
|
|
print(Node->getChild(0), true);
|
|
Printer << "):";
|
|
}
|
|
print(Node->getChild(1));
|
|
if (Node->getNumChildren() == 3)
|
|
print(Node->getChild(2));
|
|
return nullptr;
|
|
case Node::Kind::Variable:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::WithColon,
|
|
/*hasName*/true);
|
|
case Node::Kind::Function:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::FunctionStyle,
|
|
/*hasName*/true);
|
|
case Node::Kind::Subscript:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::FunctionStyle,
|
|
/*hasName*/false, /*ExtraName*/"", /*ExtraIndex*/-1,
|
|
"subscript");
|
|
case Node::Kind::GenericTypeParamDecl:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::NoType,
|
|
/*hasName*/true);
|
|
case Node::Kind::ExplicitClosure:
|
|
return printEntity(Node, asPrefixContext,
|
|
Options.ShowFunctionArgumentTypes ?
|
|
TypePrinting::FunctionStyle : TypePrinting::NoType,
|
|
/*hasName*/false, "closure #",
|
|
(int)Node->getChild(1)->getIndex() + 1);
|
|
case Node::Kind::ImplicitClosure:
|
|
return printEntity(Node, asPrefixContext,
|
|
Options.ShowFunctionArgumentTypes ?
|
|
TypePrinting::FunctionStyle : TypePrinting::NoType,
|
|
/*hasName*/false, "implicit closure #",
|
|
(int)Node->getChild(1)->getIndex() + 1);
|
|
case Node::Kind::Global:
|
|
printChildren(Node);
|
|
return nullptr;
|
|
case Node::Kind::Suffix:
|
|
if (Options.DisplayUnmangledSuffix) {
|
|
Printer << " with unmangled suffix " << QuotedString(Node->getText());
|
|
}
|
|
return nullptr;
|
|
case Node::Kind::Initializer:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::NoType,
|
|
/*hasName*/false, "variable initialization expression");
|
|
case Node::Kind::DefaultArgumentInitializer:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::NoType,
|
|
/*hasName*/false, "default argument ",
|
|
(int)Node->getChild(1)->getIndex());
|
|
case Node::Kind::DeclContext:
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::Type:
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::TypeMangling:
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::Class:
|
|
case Node::Kind::Structure:
|
|
case Node::Kind::Enum:
|
|
case Node::Kind::Protocol:
|
|
case Node::Kind::TypeAlias:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::NoType,
|
|
/*hasName*/true);
|
|
case Node::Kind::LocalDeclName:
|
|
print(Node->getChild(1));
|
|
Printer << " #" << (Node->getChild(0)->getIndex() + 1);
|
|
return nullptr;
|
|
case Node::Kind::PrivateDeclName:
|
|
if (Node->getNumChildren() > 1) {
|
|
if (Options.ShowPrivateDiscriminators)
|
|
Printer << '(';
|
|
|
|
print(Node->getChild(1));
|
|
|
|
if (Options.ShowPrivateDiscriminators)
|
|
Printer << " in " << Node->getChild(0)->getText() << ')';
|
|
} else {
|
|
if (Options.ShowPrivateDiscriminators) {
|
|
Printer << "(in " << Node->getChild(0)->getText() << ')';
|
|
}
|
|
}
|
|
return nullptr;
|
|
case Node::Kind::Module:
|
|
if (Options.DisplayModuleNames)
|
|
Printer << Node->getText();
|
|
return nullptr;
|
|
case Node::Kind::Identifier:
|
|
Printer << Node->getText();
|
|
return nullptr;
|
|
case Node::Kind::Index:
|
|
Printer << Node->getIndex();
|
|
return nullptr;
|
|
case Node::Kind::AutoClosureType:
|
|
Printer << "@autoclosure ";
|
|
printFunctionType(Node);
|
|
return nullptr;
|
|
case Node::Kind::ThinFunctionType:
|
|
Printer << "@convention(thin) ";
|
|
printFunctionType(Node);
|
|
return nullptr;
|
|
case Node::Kind::FunctionType:
|
|
case Node::Kind::UncurriedFunctionType:
|
|
printFunctionType(Node);
|
|
return nullptr;
|
|
case Node::Kind::ArgumentTuple: {
|
|
bool need_parens = false;
|
|
if (Node->getNumChildren() > 1)
|
|
need_parens = true;
|
|
else {
|
|
if (!Node->hasChildren())
|
|
need_parens = true;
|
|
else {
|
|
Node::Kind child0_kind = Node->getChild(0)->getKind();
|
|
if (child0_kind == Node::Kind::Type)
|
|
child0_kind = Node->getChild(0)->getChild(0)->getKind();
|
|
|
|
if (child0_kind != Node::Kind::Tuple)
|
|
need_parens = true;
|
|
}
|
|
}
|
|
if (need_parens)
|
|
Printer << "(";
|
|
printChildren(Node);
|
|
if (need_parens)
|
|
Printer << ")";
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::Tuple: {
|
|
Printer << "(";
|
|
printChildren(Node, ", ");
|
|
Printer << ")";
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::TupleElement: {
|
|
unsigned Idx = 0;
|
|
bool isVariadic = false;
|
|
if (Node->getNumChildren() >= 1 &&
|
|
Node->getFirstChild()->getKind() == Node::Kind::VariadicMarker) {
|
|
isVariadic = true;
|
|
Idx++;
|
|
}
|
|
NodePointer type = nullptr;
|
|
if (Node->getNumChildren() == Idx + 1) {
|
|
type = Node->getChild(Idx);
|
|
} else if (Node->getNumChildren() == Idx + 2) {
|
|
NodePointer id = Node->getChild(Idx);
|
|
type = Node->getChild(Idx + 1);
|
|
print(id);
|
|
}
|
|
if (isVariadic) {
|
|
print(type);
|
|
Printer << "...";
|
|
} else {
|
|
print(type);
|
|
}
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::TupleElementName:
|
|
Printer << Node->getText() << ": ";
|
|
return nullptr;
|
|
case Node::Kind::ReturnType:
|
|
if (Node->getNumChildren() == 0)
|
|
Printer << " -> " << Node->getText();
|
|
else {
|
|
Printer << " -> ";
|
|
printChildren(Node);
|
|
}
|
|
return nullptr;
|
|
case Node::Kind::Weak:
|
|
Printer << "weak ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::Unowned:
|
|
Printer << "unowned ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::Unmanaged:
|
|
Printer << "unowned(unsafe) ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::InOut:
|
|
Printer << "inout ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::Shared:
|
|
Printer << "__shared ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::NonObjCAttribute:
|
|
Printer << "@nonobjc ";
|
|
return nullptr;
|
|
case Node::Kind::ObjCAttribute:
|
|
Printer << "@objc ";
|
|
return nullptr;
|
|
case Node::Kind::DirectMethodReferenceAttribute:
|
|
Printer << "super ";
|
|
return nullptr;
|
|
case Node::Kind::DynamicAttribute:
|
|
Printer << "dynamic ";
|
|
return nullptr;
|
|
case Node::Kind::VTableAttribute:
|
|
Printer << "override ";
|
|
return nullptr;
|
|
case Node::Kind::FunctionSignatureSpecialization:
|
|
printSpecializationPrefix(Node, "function signature specialization");
|
|
return nullptr;
|
|
case Node::Kind::GenericPartialSpecialization:
|
|
printSpecializationPrefix(Node, "generic partial specialization",
|
|
"Signature = ");
|
|
return nullptr;
|
|
case Node::Kind::GenericPartialSpecializationNotReAbstracted:
|
|
printSpecializationPrefix(Node,
|
|
"generic not-reabstracted partial specialization", "Signature = ");
|
|
return nullptr;
|
|
case Node::Kind::GenericSpecialization:
|
|
printSpecializationPrefix(Node, "generic specialization");
|
|
return nullptr;
|
|
case Node::Kind::GenericSpecializationNotReAbstracted:
|
|
printSpecializationPrefix(Node, "generic not re-abstracted specialization");
|
|
return nullptr;
|
|
case Node::Kind::SpecializationIsFragile:
|
|
Printer << "preserving fragile attribute";
|
|
return nullptr;
|
|
case Node::Kind::GenericSpecializationParam:
|
|
print(Node->getChild(0));
|
|
for (unsigned i = 1, e = Node->getNumChildren(); i < e; ++i) {
|
|
if (i == 1)
|
|
Printer << " with ";
|
|
else
|
|
Printer << " and ";
|
|
print(Node->getChild(i));
|
|
}
|
|
return nullptr;
|
|
case Node::Kind::FunctionSignatureSpecializationParam: {
|
|
uint64_t argNum = Node->getIndex();
|
|
|
|
Printer << "Arg[" << argNum << "] = ";
|
|
|
|
unsigned Idx = printFunctionSigSpecializationParam(Node, 0);
|
|
|
|
for (unsigned e = Node->getNumChildren(); Idx < e;) {
|
|
Printer << " and ";
|
|
Idx = printFunctionSigSpecializationParam(Node, Idx);
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::FunctionSignatureSpecializationParamPayload: {
|
|
std::string demangledName = demangleSymbolAsString(Node->getText());
|
|
if (demangledName.empty()) {
|
|
Printer << Node->getText();
|
|
} else {
|
|
Printer << demangledName;
|
|
}
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::FunctionSignatureSpecializationParamKind: {
|
|
uint64_t raw = Node->getIndex();
|
|
|
|
bool printedOptionSet = false;
|
|
if (raw & uint64_t(FunctionSigSpecializationParamKind::Dead)) {
|
|
printedOptionSet = true;
|
|
Printer << "Dead";
|
|
}
|
|
|
|
if (raw & uint64_t(FunctionSigSpecializationParamKind::OwnedToGuaranteed)) {
|
|
if (printedOptionSet)
|
|
Printer << " and ";
|
|
printedOptionSet = true;
|
|
Printer << "Owned To Guaranteed";
|
|
}
|
|
|
|
if (raw & uint64_t(FunctionSigSpecializationParamKind::SROA)) {
|
|
if (printedOptionSet)
|
|
Printer << " and ";
|
|
Printer << "Exploded";
|
|
return nullptr;
|
|
}
|
|
|
|
if (printedOptionSet)
|
|
return nullptr;
|
|
|
|
switch (FunctionSigSpecializationParamKind(raw)) {
|
|
case FunctionSigSpecializationParamKind::BoxToValue:
|
|
Printer << "Value Promoted from Box";
|
|
return nullptr;
|
|
case FunctionSigSpecializationParamKind::BoxToStack:
|
|
Printer << "Stack Promoted from Box";
|
|
return nullptr;
|
|
case FunctionSigSpecializationParamKind::ConstantPropFunction:
|
|
Printer << "Constant Propagated Function";
|
|
return nullptr;
|
|
case FunctionSigSpecializationParamKind::ConstantPropGlobal:
|
|
Printer << "Constant Propagated Global";
|
|
return nullptr;
|
|
case FunctionSigSpecializationParamKind::ConstantPropInteger:
|
|
Printer << "Constant Propagated Integer";
|
|
return nullptr;
|
|
case FunctionSigSpecializationParamKind::ConstantPropFloat:
|
|
Printer << "Constant Propagated Float";
|
|
return nullptr;
|
|
case FunctionSigSpecializationParamKind::ConstantPropString:
|
|
Printer << "Constant Propagated String";
|
|
return nullptr;
|
|
case FunctionSigSpecializationParamKind::ClosureProp:
|
|
Printer << "Closure Propagated";
|
|
return nullptr;
|
|
case FunctionSigSpecializationParamKind::Dead:
|
|
case FunctionSigSpecializationParamKind::OwnedToGuaranteed:
|
|
case FunctionSigSpecializationParamKind::SROA:
|
|
printer_unreachable("option sets should have been handled earlier");
|
|
}
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::SpecializationPassID:
|
|
Printer << Node->getIndex();
|
|
return nullptr;
|
|
case Node::Kind::BuiltinTypeName:
|
|
Printer << Node->getText();
|
|
return nullptr;
|
|
case Node::Kind::Number:
|
|
Printer << Node->getIndex();
|
|
return nullptr;
|
|
case Node::Kind::InfixOperator:
|
|
Printer << Node->getText() << " infix";
|
|
return nullptr;
|
|
case Node::Kind::PrefixOperator:
|
|
Printer << Node->getText() << " prefix";
|
|
return nullptr;
|
|
case Node::Kind::PostfixOperator:
|
|
Printer << Node->getText() << " postfix";
|
|
return nullptr;
|
|
case Node::Kind::LazyProtocolWitnessTableAccessor:
|
|
Printer << "lazy protocol witness table accessor for type ";
|
|
print(Node->getChild(0));
|
|
Printer << " and conformance ";
|
|
print(Node->getChild(1));
|
|
return nullptr;
|
|
case Node::Kind::LazyProtocolWitnessTableCacheVariable:
|
|
Printer << "lazy protocol witness table cache variable for type ";
|
|
print(Node->getChild(0));
|
|
Printer << " and conformance ";
|
|
print(Node->getChild(1));
|
|
return nullptr;
|
|
case Node::Kind::ProtocolWitnessTableAccessor:
|
|
Printer << "protocol witness table accessor for ";
|
|
print(Node->getFirstChild());
|
|
return nullptr;
|
|
case Node::Kind::ProtocolWitnessTable:
|
|
Printer << "protocol witness table for ";
|
|
print(Node->getFirstChild());
|
|
return nullptr;
|
|
case Node::Kind::GenericProtocolWitnessTable:
|
|
Printer << "generic protocol witness table for ";
|
|
print(Node->getFirstChild());
|
|
return nullptr;
|
|
case Node::Kind::GenericProtocolWitnessTableInstantiationFunction:
|
|
Printer << "instantiation function for generic protocol witness table for ";
|
|
print(Node->getFirstChild());
|
|
return nullptr;
|
|
case Node::Kind::VTableThunk: {
|
|
Printer << "vtable thunk for ";
|
|
print(Node->getChild(1));
|
|
Printer << " dispatching to ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::ProtocolWitness: {
|
|
Printer << "protocol witness for ";
|
|
print(Node->getChild(1));
|
|
Printer << " in conformance ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::PartialApplyForwarder:
|
|
if (Options.ShortenPartialApply)
|
|
Printer << "partial apply";
|
|
else
|
|
Printer << "partial apply forwarder";
|
|
|
|
if (Node->hasChildren()) {
|
|
Printer << " for ";
|
|
print(Node->getFirstChild());
|
|
}
|
|
return nullptr;
|
|
case Node::Kind::PartialApplyObjCForwarder:
|
|
if (Options.ShortenPartialApply)
|
|
Printer << "partial apply";
|
|
else
|
|
Printer << "partial apply ObjC forwarder";
|
|
|
|
if (Node->hasChildren()) {
|
|
Printer << " for ";
|
|
print(Node->getFirstChild());
|
|
}
|
|
return nullptr;
|
|
case Node::Kind::KeyPathGetterThunkHelper:
|
|
Printer << "key path getter for ";
|
|
print(Node->getChild(0));
|
|
Printer << " : ";
|
|
if (Node->getNumChildren() == 2) {
|
|
print(Node->getChild(1));
|
|
} else {
|
|
print(Node->getChild(1));
|
|
print(Node->getChild(2));
|
|
}
|
|
return nullptr;
|
|
case Node::Kind::KeyPathSetterThunkHelper:
|
|
Printer << "key path setter for ";
|
|
print(Node->getChild(0));
|
|
Printer << " : ";
|
|
if (Node->getNumChildren() == 2) {
|
|
print(Node->getChild(1));
|
|
} else {
|
|
print(Node->getChild(1));
|
|
print(Node->getChild(2));
|
|
}
|
|
return nullptr;
|
|
case Node::Kind::KeyPathEqualsThunkHelper:
|
|
case Node::Kind::KeyPathHashThunkHelper: {
|
|
Printer << "key path index "
|
|
<< (Node->getKind() == Node::Kind::KeyPathEqualsThunkHelper
|
|
? "equality" : "hash")
|
|
<< " operator for ";
|
|
|
|
auto lastChild = Node->getChild(Node->getNumChildren() - 1);
|
|
auto lastType = Node->getNumChildren();
|
|
if (lastChild->getKind() == Node::Kind::DependentGenericSignature) {
|
|
print(lastChild);
|
|
lastType--;
|
|
}
|
|
|
|
Printer << "(";
|
|
for (unsigned i = 0; i < lastType; ++i) {
|
|
if (i != 0)
|
|
Printer << ", ";
|
|
print(Node->getChild(i));
|
|
}
|
|
Printer << ")";
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::FieldOffset: {
|
|
print(Node->getChild(0)); // directness
|
|
Printer << "field offset for ";
|
|
auto entity = Node->getChild(1);
|
|
print(entity, /*asContext*/ false);
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::ReabstractionThunk:
|
|
case Node::Kind::ReabstractionThunkHelper: {
|
|
if (Options.ShortenThunk) {
|
|
Printer << "thunk for ";
|
|
print(Node->getChild(Node->getNumChildren() - 2));
|
|
return nullptr;
|
|
}
|
|
Printer << "reabstraction thunk ";
|
|
if (Node->getKind() == Node::Kind::ReabstractionThunkHelper)
|
|
Printer << "helper ";
|
|
auto generics = getFirstChildOfKind(Node, Node::Kind::DependentGenericSignature);
|
|
assert(Node->getNumChildren() == 2 + unsigned(generics != nullptr));
|
|
if (generics) {
|
|
print(generics);
|
|
Printer << " ";
|
|
}
|
|
Printer << "from ";
|
|
print(Node->getChild(Node->getNumChildren() - 2));
|
|
Printer << " to ";
|
|
print(Node->getChild(Node->getNumChildren() - 1));
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::MergedFunction:
|
|
if (!Options.ShortenThunk) {
|
|
Printer << "merged ";
|
|
}
|
|
return nullptr;
|
|
case Node::Kind::GenericTypeMetadataPattern:
|
|
Printer << "generic type metadata pattern for ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::Metaclass:
|
|
Printer << "metaclass for ";
|
|
print(Node->getFirstChild());
|
|
return nullptr;
|
|
case Node::Kind::ProtocolDescriptor:
|
|
Printer << "protocol descriptor for ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::FullTypeMetadata:
|
|
Printer << "full type metadata for ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::TypeMetadata:
|
|
Printer << "type metadata for ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::TypeMetadataAccessFunction:
|
|
Printer << "type metadata accessor for ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::TypeMetadataLazyCache:
|
|
Printer << "lazy cache variable for type metadata for ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::AssociatedTypeMetadataAccessor:
|
|
Printer << "associated type metadata accessor for ";
|
|
print(Node->getChild(1));
|
|
Printer << " in ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::AssociatedTypeWitnessTableAccessor:
|
|
Printer << "associated type witness table accessor for ";
|
|
print(Node->getChild(1));
|
|
Printer << " : ";
|
|
print(Node->getChild(2));
|
|
Printer << " in ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::NominalTypeDescriptor:
|
|
Printer << "nominal type descriptor for ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::ValueWitness:
|
|
Printer << toString(ValueWitnessKind(Node->getIndex()));
|
|
if (Options.ShortenValueWitness) Printer << " for ";
|
|
else Printer << " value witness for ";
|
|
print(Node->getFirstChild());
|
|
return nullptr;
|
|
case Node::Kind::ValueWitnessTable:
|
|
Printer << "value witness table for ";
|
|
print(Node->getFirstChild());
|
|
return nullptr;
|
|
case Node::Kind::BoundGenericClass:
|
|
case Node::Kind::BoundGenericStructure:
|
|
case Node::Kind::BoundGenericEnum:
|
|
printBoundGeneric(Node);
|
|
return nullptr;
|
|
case Node::Kind::DynamicSelf:
|
|
Printer << "Self";
|
|
return nullptr;
|
|
case Node::Kind::CFunctionPointer: {
|
|
Printer << "@convention(c) ";
|
|
printFunctionType(Node);
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::ObjCBlock: {
|
|
Printer << "@convention(block) ";
|
|
printFunctionType(Node);
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::SILBoxType: {
|
|
Printer << "@box ";
|
|
NodePointer type = Node->getChild(0);
|
|
print(type);
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::Metatype: {
|
|
unsigned Idx = 0;
|
|
if (Node->getNumChildren() == 2) {
|
|
NodePointer repr = Node->getChild(Idx);
|
|
print(repr);
|
|
Printer << " ";
|
|
Idx++;
|
|
}
|
|
NodePointer type = Node->getChild(Idx)->getChild(0);
|
|
bool needs_parens = !isSimpleType(type);
|
|
if (needs_parens)
|
|
Printer << "(";
|
|
print(type);
|
|
if (needs_parens)
|
|
Printer << ")";
|
|
if (isExistentialType(type)) {
|
|
Printer << ".Protocol";
|
|
} else {
|
|
Printer << ".Type";
|
|
}
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::ExistentialMetatype: {
|
|
unsigned Idx = 0;
|
|
if (Node->getNumChildren() == 2) {
|
|
NodePointer repr = Node->getChild(Idx);
|
|
print(repr);
|
|
Printer << " ";
|
|
Idx++;
|
|
}
|
|
|
|
NodePointer type = Node->getChild(Idx);
|
|
print(type);
|
|
Printer << ".Type";
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::MetatypeRepresentation: {
|
|
Printer << Node->getText();
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::AssociatedTypeRef:
|
|
print(Node->getChild(0));
|
|
Printer << '.' << Node->getChild(1)->getText();
|
|
return nullptr;
|
|
case Node::Kind::ProtocolList: {
|
|
NodePointer type_list = Node->getChild(0);
|
|
if (!type_list)
|
|
return nullptr;
|
|
if (type_list->getNumChildren() == 0)
|
|
Printer << "Any";
|
|
else
|
|
printChildren(type_list, " & ");
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::ProtocolListWithClass: {
|
|
if (Node->getNumChildren() < 2)
|
|
return nullptr;
|
|
NodePointer protocols = Node->getChild(0);
|
|
NodePointer superclass = Node->getChild(1);
|
|
print(superclass);
|
|
Printer << " & ";
|
|
if (protocols->getNumChildren() < 1)
|
|
return nullptr;
|
|
NodePointer type_list = protocols->getChild(0);
|
|
printChildren(type_list, " & ");
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::ProtocolListWithAnyObject: {
|
|
if (Node->getNumChildren() < 1)
|
|
return nullptr;
|
|
NodePointer protocols = Node->getChild(0);
|
|
if (protocols->getNumChildren() < 1)
|
|
return nullptr;
|
|
NodePointer type_list = protocols->getChild(0);
|
|
if (type_list->getNumChildren() > 0) {
|
|
printChildren(type_list, " & ");
|
|
Printer << " & ";
|
|
}
|
|
if (Options.QualifyEntities)
|
|
Printer << "Swift.";
|
|
Printer << "AnyObject";
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::AssociatedType:
|
|
// Don't print for now.
|
|
return nullptr;
|
|
case Node::Kind::QualifiedArchetype: {
|
|
if (Options.ShortenArchetype) {
|
|
Printer << "(archetype)";
|
|
return nullptr;
|
|
}
|
|
if (Node->getNumChildren() < 2)
|
|
return nullptr;
|
|
NodePointer number = Node->getChild(0);
|
|
NodePointer decl_ctx = Node->getChild(1);
|
|
Printer << "(archetype " << number->getIndex() << " of ";
|
|
print(decl_ctx);
|
|
Printer << ")";
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::OwningAddressor:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"owningAddressor");
|
|
case Node::Kind::OwningMutableAddressor:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"owningMutableAddressor");
|
|
case Node::Kind::NativeOwningAddressor:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"nativeOwningAddressor");
|
|
case Node::Kind::NativeOwningMutableAddressor:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"nativeOwningMutableAddressor");
|
|
case Node::Kind::NativePinningAddressor:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"nativePinningAddressor");
|
|
case Node::Kind::NativePinningMutableAddressor:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"nativePinningMutableAddressor");
|
|
case Node::Kind::UnsafeAddressor:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"unsafeAddressor");
|
|
case Node::Kind::UnsafeMutableAddressor:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"unsafeMutableAddressor");
|
|
case Node::Kind::GlobalGetter:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"getter");
|
|
case Node::Kind::Getter:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"getter");
|
|
case Node::Kind::Setter:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"setter");
|
|
case Node::Kind::MaterializeForSet:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"materializeForSet");
|
|
case Node::Kind::WillSet:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"willset");
|
|
case Node::Kind::DidSet:
|
|
return printAbstractStorage(Node->getFirstChild(), asPrefixContext,
|
|
"didset");
|
|
case Node::Kind::Allocator:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::FunctionStyle,
|
|
/*hasName*/false, isClassType(Node->getChild(0)) ?
|
|
"__allocating_init" : "init");
|
|
case Node::Kind::Constructor:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::FunctionStyle,
|
|
/*hasName*/Node->getNumChildren() > 2, "init");
|
|
case Node::Kind::Destructor:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::NoType,
|
|
/*hasName*/false, "deinit");
|
|
case Node::Kind::Deallocator:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::NoType,
|
|
/*hasName*/false, isClassType(Node->getChild(0)) ?
|
|
"__deallocating_deinit" : "deinit");
|
|
case Node::Kind::IVarInitializer:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::NoType,
|
|
/*hasName*/false, "__ivar_initializer");
|
|
case Node::Kind::IVarDestroyer:
|
|
return printEntity(Node, asPrefixContext, TypePrinting::NoType,
|
|
/*hasName*/false, "__ivar_destroyer");
|
|
case Node::Kind::ProtocolConformance: {
|
|
NodePointer child0 = Node->getChild(0);
|
|
NodePointer child1 = Node->getChild(1);
|
|
NodePointer child2 = Node->getChild(2);
|
|
if (Node->getNumChildren() == 4) {
|
|
// TODO: check if this is correct
|
|
Printer << "property behavior storage of ";
|
|
print(child2);
|
|
Printer << " in ";
|
|
print(child0);
|
|
Printer << " : ";
|
|
print(child1);
|
|
} else {
|
|
print(child0);
|
|
if (Options.DisplayProtocolConformances) {
|
|
Printer << " : ";
|
|
print(child1);
|
|
Printer << " in ";
|
|
print(child2);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::TypeList:
|
|
printChildren(Node);
|
|
return nullptr;
|
|
case Node::Kind::ImplEscaping:
|
|
Printer << "@escaping";
|
|
return nullptr;
|
|
case Node::Kind::ImplConvention:
|
|
Printer << Node->getText();
|
|
return nullptr;
|
|
case Node::Kind::ImplFunctionAttribute:
|
|
Printer << Node->getText();
|
|
return nullptr;
|
|
case Node::Kind::ImplErrorResult:
|
|
Printer << "@error ";
|
|
LLVM_FALLTHROUGH;
|
|
case Node::Kind::ImplParameter:
|
|
case Node::Kind::ImplResult:
|
|
printChildren(Node, " ");
|
|
return nullptr;
|
|
case Node::Kind::ImplFunctionType:
|
|
printImplFunctionType(Node);
|
|
return nullptr;
|
|
case Node::Kind::ErrorType:
|
|
Printer << "<ERROR TYPE>";
|
|
return nullptr;
|
|
|
|
case Node::Kind::DependentPseudogenericSignature:
|
|
case Node::Kind::DependentGenericSignature: {
|
|
Printer << '<';
|
|
|
|
unsigned depth = 0;
|
|
unsigned numChildren = Node->getNumChildren();
|
|
for (;
|
|
depth < numChildren
|
|
&& Node->getChild(depth)->getKind()
|
|
== Node::Kind::DependentGenericParamCount;
|
|
++depth) {
|
|
if (depth != 0)
|
|
Printer << "><";
|
|
|
|
unsigned count = Node->getChild(depth)->getIndex();
|
|
for (unsigned index = 0; index < count; ++index) {
|
|
if (index != 0)
|
|
Printer << ", ";
|
|
// FIXME: Depth won't match when a generic signature applies to a
|
|
// method in generic type context.
|
|
Printer << archetypeName(index, depth);
|
|
}
|
|
}
|
|
|
|
if (depth != numChildren) {
|
|
if (Options.DisplayWhereClauses) {
|
|
Printer << " where ";
|
|
for (unsigned i = depth; i < numChildren; ++i) {
|
|
if (i > depth)
|
|
Printer << ", ";
|
|
print(Node->getChild(i));
|
|
}
|
|
}
|
|
}
|
|
Printer << '>';
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::DependentGenericParamCount:
|
|
printer_unreachable("should be printed as a child of a "
|
|
"DependentGenericSignature");
|
|
case Node::Kind::DependentGenericConformanceRequirement: {
|
|
NodePointer type = Node->getChild(0);
|
|
NodePointer reqt = Node->getChild(1);
|
|
print(type);
|
|
Printer << ": ";
|
|
print(reqt);
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::DependentGenericLayoutRequirement: {
|
|
NodePointer type = Node->getChild(0);
|
|
NodePointer layout = Node->getChild(1);
|
|
print(type);
|
|
Printer << ": ";
|
|
assert(layout->getKind() == Node::Kind::Identifier);
|
|
assert(layout->getText().size() == 1);
|
|
char c = layout->getText()[0];
|
|
StringRef name;
|
|
if (c == 'U') {
|
|
name = "_UnknownLayout";
|
|
} else if (c == 'R') {
|
|
name = "_RefCountedObject";
|
|
} else if (c == 'N') {
|
|
name = "_NativeRefCountedObject";
|
|
} else if (c == 'C') {
|
|
name = "AnyObject";
|
|
} else if (c == 'D') {
|
|
name = "_NativeClass";
|
|
} else if (c == 'T') {
|
|
name = "_Trivial";
|
|
} else if (c == 'E' || c == 'e') {
|
|
name = "_Trivial";
|
|
} else if (c == 'M' || c == 'm') {
|
|
name = "_TrivialAtMost";
|
|
}
|
|
Printer << name;
|
|
if (Node->getNumChildren() > 2) {
|
|
Printer << "(";
|
|
print(Node->getChild(2));
|
|
if (Node->getNumChildren() > 3) {
|
|
Printer << ", ";
|
|
print(Node->getChild(3));
|
|
}
|
|
Printer << ")";
|
|
}
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::DependentGenericSameTypeRequirement: {
|
|
NodePointer fst = Node->getChild(0);
|
|
NodePointer snd = Node->getChild(1);
|
|
|
|
print(fst);
|
|
Printer << " == ";
|
|
print(snd);
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::DependentGenericParamType: {
|
|
Printer << Node->getText();
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::DependentGenericType: {
|
|
NodePointer sig = Node->getChild(0);
|
|
NodePointer depTy = Node->getChild(1);
|
|
print(sig);
|
|
if (needSpaceBeforeType(depTy))
|
|
Printer << ' ';
|
|
print(depTy);
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::DependentMemberType: {
|
|
NodePointer base = Node->getChild(0);
|
|
print(base);
|
|
Printer << '.';
|
|
NodePointer assocTy = Node->getChild(1);
|
|
print(assocTy);
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::DependentAssociatedTypeRef: {
|
|
Printer << Node->getText();
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::ReflectionMetadataBuiltinDescriptor:
|
|
Printer << "reflection metadata builtin descriptor ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::ReflectionMetadataFieldDescriptor:
|
|
Printer << "reflection metadata field descriptor ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::ReflectionMetadataAssocTypeDescriptor:
|
|
Printer << "reflection metadata associated type descriptor ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::ReflectionMetadataSuperclassDescriptor:
|
|
Printer << "reflection metadata superclass descriptor ";
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
|
|
case Node::Kind::ThrowsAnnotation:
|
|
Printer<< " throws ";
|
|
return nullptr;
|
|
case Node::Kind::EmptyList:
|
|
Printer << " empty-list ";
|
|
return nullptr;
|
|
case Node::Kind::FirstElementMarker:
|
|
Printer << " first-element-marker ";
|
|
return nullptr;
|
|
case Node::Kind::VariadicMarker:
|
|
Printer << " variadic-marker ";
|
|
return nullptr;
|
|
case Node::Kind::SILBoxTypeWithLayout: {
|
|
assert(Node->getNumChildren() == 1 || Node->getNumChildren() == 3);
|
|
NodePointer layout = Node->getChild(0);
|
|
assert(layout->getKind() == Node::Kind::SILBoxLayout);
|
|
NodePointer signature, genericArgs = nullptr;
|
|
if (Node->getNumChildren() == 3) {
|
|
signature = Node->getChild(1);
|
|
assert(signature->getKind() == Node::Kind::DependentGenericSignature);
|
|
genericArgs = Node->getChild(2);
|
|
assert(genericArgs->getKind() == Node::Kind::TypeList);
|
|
|
|
print(signature);
|
|
Printer << ' ';
|
|
}
|
|
print(layout);
|
|
if (genericArgs) {
|
|
Printer << " <";
|
|
for (unsigned i = 0, e = genericArgs->getNumChildren(); i < e; ++i) {
|
|
if (i > 0)
|
|
Printer << ", ";
|
|
print(genericArgs->getChild(i));
|
|
}
|
|
Printer << '>';
|
|
}
|
|
return nullptr;
|
|
}
|
|
case Node::Kind::SILBoxLayout:
|
|
Printer << '{';
|
|
for (unsigned i = 0; i < Node->getNumChildren(); ++i) {
|
|
if (i > 0)
|
|
Printer << ',';
|
|
Printer << ' ';
|
|
print(Node->getChild(i));
|
|
}
|
|
Printer << " }";
|
|
return nullptr;
|
|
case Node::Kind::SILBoxImmutableField:
|
|
case Node::Kind::SILBoxMutableField:
|
|
Printer << (Node->getKind() == Node::Kind::SILBoxImmutableField
|
|
? "let "
|
|
: "var ");
|
|
assert(Node->getNumChildren() == 1
|
|
&& Node->getChild(0)->getKind() == Node::Kind::Type);
|
|
print(Node->getChild(0));
|
|
return nullptr;
|
|
case Node::Kind::AssocTypePath:
|
|
printChildren(Node->begin(), Node->end(), ".");
|
|
return nullptr;
|
|
}
|
|
printer_unreachable("bad node kind!");
|
|
}
|
|
|
|
NodePointer NodePrinter::printAbstractStorage(NodePointer Node,
|
|
bool asPrefixContent,
|
|
StringRef ExtraName) {
|
|
switch (Node->getKind()) {
|
|
case Node::Kind::Variable:
|
|
return printEntity(Node, asPrefixContent, TypePrinting::WithColon,
|
|
/*hasName*/true, ExtraName);
|
|
case Node::Kind::Subscript:
|
|
return printEntity(Node, asPrefixContent, TypePrinting::WithColon,
|
|
/*hasName*/false, ExtraName, /*ExtraIndex*/-1,
|
|
"subscript");
|
|
default:
|
|
printer_unreachable("Not an abstract storage node");
|
|
}
|
|
}
|
|
|
|
NodePointer NodePrinter::
|
|
printEntity(NodePointer Entity, bool asPrefixContext, TypePrinting TypePr,
|
|
bool hasName, StringRef ExtraName, int ExtraIndex,
|
|
StringRef OverwriteName) {
|
|
// Either we print the context in prefix form "<context>.<name>" or in
|
|
// suffix form "<name> in <context>".
|
|
bool MultiWordName = ExtraName.contains(' ');
|
|
// Also a local name (e.g. Mystruct #1) does not look good if its context is
|
|
// printed in prefix form.
|
|
if (hasName &&
|
|
Entity->getChild(1)->getKind() == Node::Kind::LocalDeclName)
|
|
MultiWordName = true;
|
|
|
|
if (asPrefixContext && (TypePr != TypePrinting::NoType || MultiWordName)) {
|
|
// If the context has a type to be printed, we can't use the prefix form.
|
|
return Entity;
|
|
}
|
|
|
|
NodePointer PostfixContext = nullptr;
|
|
NodePointer Context = Entity->getChild(0);
|
|
if (printContext(Context)) {
|
|
if (MultiWordName) {
|
|
// If the name contains some spaces we don't print the context now but
|
|
// later in suffix form.
|
|
PostfixContext = Context;
|
|
} else {
|
|
size_t CurrentPos = Printer.getStringRef().size();
|
|
PostfixContext = print(Context, /*asPrefixContext*/true);
|
|
|
|
// Was the context printed as prefix?
|
|
if (Printer.getStringRef().size() != CurrentPos)
|
|
Printer << '.';
|
|
}
|
|
}
|
|
|
|
if (hasName || !OverwriteName.empty()) {
|
|
assert(ExtraIndex < 0 && "Can't have a name and extra index");
|
|
if (!ExtraName.empty() && MultiWordName) {
|
|
Printer << ExtraName;
|
|
Printer << " of ";
|
|
ExtraName = "";
|
|
}
|
|
size_t CurrentPos = Printer.getStringRef().size();
|
|
if (!OverwriteName.empty()) {
|
|
Printer << OverwriteName;
|
|
} else {
|
|
print(Entity->getChild(1));
|
|
}
|
|
if (Printer.getStringRef().size() != CurrentPos && !ExtraName.empty())
|
|
Printer << '.';
|
|
}
|
|
if (!ExtraName.empty()) {
|
|
Printer << ExtraName;
|
|
if (ExtraIndex >= 0)
|
|
Printer << ExtraIndex;
|
|
}
|
|
if (TypePr != TypePrinting::NoType) {
|
|
NodePointer type = Entity->getChild(1);
|
|
if (type->getKind() != Node::Kind::Type)
|
|
type = Entity->getChild(2);
|
|
assert(type->getKind() == Node::Kind::Type);
|
|
type = type->getChild(0);
|
|
if (TypePr == TypePrinting::FunctionStyle) {
|
|
// We expect to see a function type here, but if we don't, use the colon.
|
|
NodePointer t = type;
|
|
while (t->getKind() == Node::Kind::DependentGenericType)
|
|
t = t->getChild(1)->getChild(0);
|
|
if (t->getKind() != Node::Kind::FunctionType &&
|
|
t->getKind() != Node::Kind::UncurriedFunctionType &&
|
|
t->getKind() != Node::Kind::CFunctionPointer &&
|
|
t->getKind() != Node::Kind::ThinFunctionType) {
|
|
TypePr = TypePrinting::WithColon;
|
|
}
|
|
}
|
|
if (TypePr == TypePrinting::WithColon) {
|
|
if (Options.DisplayEntityTypes) {
|
|
Printer << " : ";
|
|
print(type);
|
|
}
|
|
} else {
|
|
assert(TypePr == TypePrinting::FunctionStyle);
|
|
if (MultiWordName || needSpaceBeforeType(type))
|
|
Printer << ' ';
|
|
|
|
print(type);
|
|
}
|
|
}
|
|
if (!asPrefixContext && PostfixContext) {
|
|
// Print any left over context which couldn't be printed in prefix form.
|
|
if (Entity->getKind() == Node::Kind::DefaultArgumentInitializer ||
|
|
Entity->getKind() == Node::Kind::Initializer) {
|
|
Printer << " of ";
|
|
} else {
|
|
Printer << " in ";
|
|
}
|
|
print(PostfixContext);
|
|
PostfixContext = nullptr;
|
|
}
|
|
return PostfixContext;
|
|
};
|
|
|
|
std::string Demangle::nodeToString(NodePointer root,
|
|
const DemangleOptions &options) {
|
|
if (!root)
|
|
return "";
|
|
|
|
return NodePrinter(options).printRoot(root);
|
|
}
|