/* FUNCTIONS */
private void renderFunction(
@NotNull FunctionDescriptor function, @NotNull StringBuilder builder) {
if (!startFromName) {
renderAnnotations(function, builder);
renderVisibility(function.getVisibility(), builder);
renderModalityForCallable(function, builder);
renderOverride(function, builder);
renderMemberKind(function, builder);
builder.append(renderKeyword("fun")).append(" ");
renderTypeParameters(function.getTypeParameters(), builder, true);
ReceiverParameterDescriptor receiver = function.getReceiverParameter();
if (receiver != null) {
builder.append(escape(renderType(receiver.getType()))).append(".");
}
}
renderName(function, builder);
renderValueParameters(function, builder);
JetType returnType = function.getReturnType();
if (unitReturnType || !KotlinBuiltIns.getInstance().isUnit(returnType)) {
builder.append(": ").append(returnType == null ? "[NULL]" : escape(renderType(returnType)));
}
renderWhereSuffix(function.getTypeParameters(), builder);
}
@NotNull
@Override
public String renderFunctionParameters(@NotNull FunctionDescriptor functionDescriptor) {
StringBuilder stringBuilder = new StringBuilder();
renderValueParameters(functionDescriptor, stringBuilder);
return stringBuilder.toString();
}
@NotNull
private String renderFqName(@NotNull List<Name> pathSegments) {
StringBuilder buf = new StringBuilder();
for (Name element : pathSegments) {
if (buf.length() != 0) {
buf.append(".");
}
buf.append(renderName(element));
}
return buf.toString();
}
@NotNull
@Override
public String render(@NotNull DeclarationDescriptor declarationDescriptor) {
StringBuilder stringBuilder = new StringBuilder();
declarationDescriptor.accept(new RenderDeclarationDescriptorVisitor(), stringBuilder);
if (withDefinedIn) {
appendDefinedIn(declarationDescriptor, stringBuilder);
}
return stringBuilder.toString();
}
private void appendTypeProjections(
@NotNull List<TypeProjection> typeProjections, @NotNull StringBuilder builder) {
for (Iterator<TypeProjection> iterator = typeProjections.iterator(); iterator.hasNext(); ) {
TypeProjection typeProjection = iterator.next();
if (typeProjection.getProjectionKind() != Variance.INVARIANT) {
builder.append(typeProjection.getProjectionKind()).append(" ");
}
builder.append(renderType(typeProjection.getType()));
if (iterator.hasNext()) {
builder.append(", ");
}
}
}
/* METHODS FOR ALL KINDS OF DESCRIPTORS */
private void appendDefinedIn(
@NotNull DeclarationDescriptor descriptor, @NotNull StringBuilder builder) {
if (descriptor instanceof ModuleDescriptor) {
builder.append(" is a module");
return;
}
builder.append(" ").append(renderMessage("defined in")).append(" ");
DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration();
if (containingDeclaration != null) {
FqNameUnsafe fqName = DescriptorUtils.getFQName(containingDeclaration);
builder.append(FqName.ROOT.equalsTo(fqName) ? "root package" : renderFqName(fqName));
}
}
private void renderOverride(
@NotNull CallableMemberDescriptor callableMember, @NotNull StringBuilder builder) {
if (!modifiers.contains(Modifier.OVERRIDE)) return;
if (overridesSomething(callableMember)) {
if (overrideRenderingPolicy != OverrideRenderingPolicy.RENDER_OPEN) {
builder.append("override ");
if (verbose) {
builder
.append("/*")
.append(callableMember.getOverriddenDescriptors().size())
.append("*/ ");
}
}
}
}
/* CLASSES */
private void renderClass(@NotNull ClassDescriptor klass, @NotNull StringBuilder builder) {
if (!startFromName) {
renderAnnotations(klass, builder);
renderVisibility(klass.getVisibility(), builder);
if (!(klass.getKind() == ClassKind.TRAIT && klass.getModality() == Modality.ABSTRACT
|| klass.getKind().isObject() && klass.getModality() == Modality.FINAL)) {
renderModality(klass.getModality(), builder);
}
renderInner(klass.isInner(), builder);
builder.append(renderKeyword(getClassKindPrefix(klass)));
}
if (klass.getKind() != ClassKind.CLASS_OBJECT || verbose) {
builder.append(" ");
renderName(klass, builder);
}
List<TypeParameterDescriptor> typeParameters = klass.getTypeConstructor().getParameters();
renderTypeParameters(typeParameters, builder, false);
if (!klass.getKind().isObject() && classWithPrimaryConstructor) {
ConstructorDescriptor primaryConstructor = klass.getUnsubstitutedPrimaryConstructor();
if (primaryConstructor != null) {
renderValueParameters(primaryConstructor, builder);
}
}
if (!klass.equals(KotlinBuiltIns.getInstance().getNothing())) {
Collection<JetType> supertypes = klass.getTypeConstructor().getSupertypes();
if (supertypes.isEmpty()
|| !alwaysRenderAny
&& supertypes.size() == 1
&& KotlinBuiltIns.getInstance().isAny(supertypes.iterator().next())) {
} else {
builder.append(" : ");
for (Iterator<JetType> iterator = supertypes.iterator(); iterator.hasNext(); ) {
JetType supertype = iterator.next();
builder.append(renderType(supertype));
if (iterator.hasNext()) {
builder.append(", ");
}
}
}
}
renderWhereSuffix(typeParameters, builder);
}
private void renderVisibility(@NotNull Visibility visibility, @NotNull StringBuilder builder) {
if (!modifiers.contains(Modifier.VISIBILITY)) return;
if (normalizedVisibilities) {
visibility = visibility.normalize();
}
if (!showInternalKeyword && visibility == Visibilities.INTERNAL) return;
builder.append(renderKeyword(visibility.toString())).append(" ");
}
/* TYPE PARAMETERS */
private void renderTypeParameter(
@NotNull TypeParameterDescriptor typeParameter,
@NotNull StringBuilder builder,
boolean topLevel) {
if (topLevel) {
builder.append(lt());
}
if (verbose) {
builder.append("/*").append(typeParameter.getIndex()).append("*/ ");
}
if (typeParameter.isReified()) {
builder.append(renderKeyword("reified")).append(" ");
}
String variance = typeParameter.getVariance().toString();
if (!variance.isEmpty()) {
builder.append(renderKeyword(variance)).append(" ");
}
renderName(typeParameter, builder);
int upperBoundsCount = typeParameter.getUpperBounds().size();
if ((upperBoundsCount > 1 && !topLevel) || upperBoundsCount == 1) {
JetType upperBound = typeParameter.getUpperBounds().iterator().next();
if (!KotlinBuiltIns.getInstance().getDefaultBound().equals(upperBound) || alwaysRenderAny) {
builder.append(" : ").append(renderType(upperBound));
}
} else if (topLevel) {
boolean first = true;
for (JetType upperBound : typeParameter.getUpperBounds()) {
if (upperBound.equals(KotlinBuiltIns.getInstance().getDefaultBound())) {
continue;
}
if (first) {
builder.append(" : ");
} else {
builder.append(" & ");
}
builder.append(renderType(upperBound));
first = false;
}
} else {
// rendered with "where"
}
if (topLevel) {
builder.append(">");
}
}
/* VARIABLES */
private void renderValueParameter(
@NotNull ValueParameterDescriptor valueParameter,
@NotNull StringBuilder builder,
boolean topLevel) {
if (topLevel) {
builder.append(renderKeyword("value-parameter")).append(" ");
}
if (verbose) {
builder.append("/*").append(valueParameter.getIndex()).append("*/ ");
}
renderAnnotations(valueParameter, builder);
renderVariable(valueParameter, builder, topLevel);
boolean withDefaultValue =
debugMode ? valueParameter.declaresDefaultValue() : valueParameter.hasDefaultValue();
if (withDefaultValue) {
builder.append(" = ...");
}
}
private void renderTypeParameters(
@NotNull List<TypeParameterDescriptor> typeParameters,
@NotNull StringBuilder builder,
boolean withSpace) {
if (!typeParameters.isEmpty()) {
builder.append(lt());
for (Iterator<TypeParameterDescriptor> iterator = typeParameters.iterator();
iterator.hasNext(); ) {
TypeParameterDescriptor typeParameterDescriptor = iterator.next();
renderTypeParameter(typeParameterDescriptor, builder, false);
if (iterator.hasNext()) {
builder.append(", ");
}
}
builder.append(">");
if (withSpace) {
builder.append(" ");
}
}
}
private void renderAnnotations(@NotNull Annotated annotated, @NotNull StringBuilder builder) {
if (!modifiers.contains(Modifier.ANNOTATIONS)) return;
for (AnnotationDescriptor annotation : annotated.getAnnotations()) {
ClassDescriptor annotationClass =
(ClassDescriptor) annotation.getType().getConstructor().getDeclarationDescriptor();
assert annotationClass != null;
if (!excludedAnnotationClasses.contains(
DescriptorUtils.getFQName(annotationClass).toSafe())) {
builder.append(renderType(annotation.getType()));
if (verbose) {
builder
.append("(")
.append(
StringUtil.join(DescriptorUtils.getSortedValueArguments(annotation, this), ", "))
.append(")");
}
builder.append(" ");
}
}
}
private void renderWhereSuffix(
@NotNull List<TypeParameterDescriptor> typeParameters, @NotNull StringBuilder builder) {
List<String> upperBoundStrings = Lists.newArrayList();
for (TypeParameterDescriptor typeParameter : typeParameters) {
if (typeParameter.getUpperBounds().size() > 1) {
boolean first = true;
for (JetType upperBound : typeParameter.getUpperBounds()) {
// first parameter is rendered by renderTypeParameter:
if (!first) {
upperBoundStrings.add(
renderName(typeParameter.getName()) + " : " + escape(renderType(upperBound)));
}
first = false;
}
}
}
if (!upperBoundStrings.isEmpty()) {
builder.append(" ").append(renderKeyword("where")).append(" ");
builder.append(StringUtil.join(upperBoundStrings, ", "));
}
}
private void renderProperty(
@NotNull PropertyDescriptor property, @NotNull StringBuilder builder) {
if (!startFromName) {
renderAnnotations(property, builder);
renderVisibility(property.getVisibility(), builder);
renderModalityForCallable(property, builder);
renderOverride(property, builder);
renderMemberKind(property, builder);
renderValVarPrefix(property, builder);
}
renderTypeParameters(property.getTypeParameters(), builder, true);
ReceiverParameterDescriptor receiver = property.getReceiverParameter();
if (receiver != null) {
builder.append(escape(renderType(receiver.getType()))).append(".");
}
renderName(property, builder);
builder.append(": ").append(escape(renderType(property.getType())));
renderWhereSuffix(property.getTypeParameters(), builder);
}
private void renderConstructor(
@NotNull ConstructorDescriptor constructor, @NotNull StringBuilder builder) {
renderAnnotations(constructor, builder);
renderVisibility(constructor.getVisibility(), builder);
renderMemberKind(constructor, builder);
builder.append(renderKeyword("constructor")).append(" ");
ClassDescriptor classDescriptor = constructor.getContainingDeclaration();
renderName(classDescriptor, builder);
renderTypeParameters(classDescriptor.getTypeConstructor().getParameters(), builder, false);
renderValueParameters(constructor, builder);
renderWhereSuffix(constructor.getTypeParameters(), builder);
}
private void renderVariable(
@NotNull VariableDescriptor variable, @NotNull StringBuilder builder, boolean topLevel) {
JetType realType = variable.getType();
JetType varargElementType =
variable instanceof ValueParameterDescriptor
? ((ValueParameterDescriptor) variable).getVarargElementType()
: null;
JetType typeToRender = varargElementType != null ? varargElementType : realType;
if (varargElementType != null) {
builder.append(renderKeyword("vararg")).append(" ");
}
if (topLevel && !startFromName) {
renderValVarPrefix(variable, builder);
}
renderName(variable, builder);
builder.append(": ").append(escape(renderType(typeToRender)));
if (verbose && varargElementType != null) {
builder.append(" /*").append(escape(renderType(realType))).append("*/");
}
}
@NotNull
private String renderDefaultType(@NotNull JetType type) {
StringBuilder sb = new StringBuilder();
sb.append(renderTypeName(type.getConstructor()));
if (!type.getArguments().isEmpty()) {
sb.append("<");
appendTypeProjections(type.getArguments(), sb);
sb.append(">");
}
if (type.isNullable()) {
sb.append("?");
}
return sb.toString();
}
@NotNull
private String renderFunctionType(@NotNull JetType type) {
StringBuilder sb = new StringBuilder();
JetType receiverType = KotlinBuiltIns.getInstance().getReceiverType(type);
if (receiverType != null) {
sb.append(renderType(receiverType));
sb.append(".");
}
sb.append("(");
appendTypeProjections(
KotlinBuiltIns.getInstance().getParameterTypeProjectionsFromFunctionType(type), sb);
sb.append(") " + arrow() + " ");
sb.append(renderType(KotlinBuiltIns.getInstance().getReturnTypeFromFunctionType(type)));
if (type.isNullable()) {
return "(" + sb + ")?";
}
return sb.toString();
}
private void renderMemberKind(CallableMemberDescriptor callableMember, StringBuilder builder) {
if (!modifiers.contains(Modifier.MEMBER_KIND)) return;
if (verbose && callableMember.getKind() != CallableMemberDescriptor.Kind.DECLARATION) {
builder.append("/*").append(callableMember.getKind().name().toLowerCase()).append("*/ ");
}
}
private void renderValVarPrefix(
@NotNull VariableDescriptor variable, @NotNull StringBuilder builder) {
builder.append(renderKeyword(variable.isVar() ? "var" : "val")).append(" ");
}
private void renderModality(@NotNull Modality modality, @NotNull StringBuilder builder) {
if (!modifiers.contains(Modifier.MODALITY)) return;
String keyword = modality.name().toLowerCase();
builder.append(renderKeyword(keyword)).append(" ");
}
private void renderInner(boolean isInner, @NotNull StringBuilder builder) {
if (!modifiers.contains(Modifier.INNER)) return;
if (isInner) {
builder.append(renderKeyword("inner")).append(" ");
}
}
private void renderNamespace(
@NotNull NamespaceDescriptor namespace, @NotNull StringBuilder builder) {
builder.append(renderKeyword("package")).append(" ");
renderName(namespace, builder);
}
private void renderName(
@NotNull DeclarationDescriptor descriptor, @NotNull StringBuilder builder) {
builder.append(renderName(descriptor.getName()));
}
