Got rid of DescriptorRendererBuilder providing new scheme for creating DescriptorRenderer's

This commit is contained in:
Valentin Kipyatkov
2015-06-05 15:28:36 +03:00
parent ce2ce44d7b
commit a1ff2f20ed
25 changed files with 499 additions and 548 deletions
@@ -100,7 +100,7 @@ public final class JvmAnnotationNames {
public static final FqName OLD_KOTLIN_TRAIT_IMPL = new FqName("jet.KotlinTraitImpl");
// When these annotations appear on a declaration, they are copied to the _type_ of the declaration, becoming type annotations
// See also DescriptorRendererBuilder#excludedTypeAnnotationClasses
// See also DescriptorRendererOptions#excludedTypeAnnotationClasses
public static final Set<FqName> ANNOTATIONS_COPIED_TO_TYPES = KotlinPackage.setOf(
JETBRAINS_READONLY_ANNOTATION,
JETBRAINS_MUTABLE_ANNOTATION,
@@ -21,13 +21,20 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.FunctionDescriptor
import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.FqNameBase
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.types.JetType
import org.jetbrains.kotlin.types.TypeProjection
public interface DescriptorRenderer : Renderer<DeclarationDescriptor> {
public fun withOptions(changeOptions: DescriptorRendererOptions.() -> Unit): DescriptorRenderer {
val options = (this as DescriptorRendererImpl).options.copy()
options.changeOptions()
options.lock()
return DescriptorRendererImpl(options)
}
public fun renderType(type: JetType): String
public fun renderTypeArguments(typeArguments: List<TypeProjection>): String
@@ -70,121 +77,157 @@ public interface DescriptorRenderer : Renderer<DeclarationDescriptor> {
MEMBER_KIND
}
/** @see DefaultValueParameterHandler
*/
public interface ValueParametersHandler {
public fun appendBeforeValueParameters(function: FunctionDescriptor, stringBuilder: StringBuilder)
public fun appendAfterValueParameters(function: FunctionDescriptor, stringBuilder: StringBuilder)
public fun appendBeforeValueParameters(function: FunctionDescriptor, builder: StringBuilder)
public fun appendAfterValueParameters(function: FunctionDescriptor, builder: StringBuilder)
public fun appendBeforeValueParameter(parameter: ValueParameterDescriptor, stringBuilder: StringBuilder)
public fun appendAfterValueParameter(parameter: ValueParameterDescriptor, stringBuilder: StringBuilder)
}
public fun appendBeforeValueParameter(parameter: ValueParameterDescriptor, builder: StringBuilder)
public fun appendAfterValueParameter(parameter: ValueParameterDescriptor, builder: StringBuilder)
public class DefaultValueParameterHandler : ValueParametersHandler {
override fun appendBeforeValueParameters(function: FunctionDescriptor, stringBuilder: StringBuilder) {
stringBuilder.append("(")
}
public object DEFAULT : ValueParametersHandler {
override fun appendBeforeValueParameters(function: FunctionDescriptor, builder: StringBuilder) {
builder.append("(")
}
override fun appendAfterValueParameters(function: FunctionDescriptor, stringBuilder: StringBuilder) {
stringBuilder.append(")")
}
override fun appendAfterValueParameters(function: FunctionDescriptor, builder: StringBuilder) {
builder.append(")")
}
override fun appendBeforeValueParameter(parameter: ValueParameterDescriptor, stringBuilder: StringBuilder) {
}
override fun appendBeforeValueParameter(parameter: ValueParameterDescriptor, builder: StringBuilder) {
}
override fun appendAfterValueParameter(parameter: ValueParameterDescriptor, stringBuilder: StringBuilder) {
val function = parameter.getContainingDeclaration() as FunctionDescriptor
if (parameter.getIndex() != function.getValueParameters().size() - 1) {
stringBuilder.append(", ")
override fun appendAfterValueParameter(parameter: ValueParameterDescriptor, builder: StringBuilder) {
val function = parameter.getContainingDeclaration() as FunctionDescriptor
if (parameter.getIndex() != function.getValueParameters().size() - 1) {
builder.append(", ")
}
}
}
}
companion object {
public val COMPACT_WITH_MODIFIERS: DescriptorRenderer = DescriptorRendererBuilder()
.setWithDefinedIn(false)
.build()
public fun withOptions(changeOptions: DescriptorRendererOptions.() -> Unit): DescriptorRenderer {
val options = DescriptorRendererOptionsImpl()
options.changeOptions()
options.lock()
return DescriptorRendererImpl(options)
}
public val COMPACT: DescriptorRenderer = DescriptorRendererBuilder()
.setWithDefinedIn(false)
.setModifiers()
.build()
public val COMPACT_WITH_MODIFIERS: DescriptorRenderer = withOptions {
withDefinedIn = false
}
public val COMPACT_WITH_SHORT_TYPES: DescriptorRenderer = DescriptorRendererBuilder()
.setModifiers()
.setNameShortness(NameShortness.SHORT)
.setParameterNameRenderingPolicy(ParameterNameRenderingPolicy.ONLY_NON_SYNTHESIZED)
.build()
public val COMPACT: DescriptorRenderer = withOptions {
withDefinedIn = false
modifiers = emptySet()
}
public val STARTS_FROM_NAME: DescriptorRenderer = DescriptorRendererBuilder()
.setWithDefinedIn(false)
.setModifiers()
.setStartFromName(true)
.build()
public val COMPACT_WITH_SHORT_TYPES: DescriptorRenderer = withOptions {
modifiers = emptySet()
nameShortness = NameShortness.SHORT
parameterNameRenderingPolicy = ParameterNameRenderingPolicy.ONLY_NON_SYNTHESIZED
}
public val ONLY_NAMES_WITH_SHORT_TYPES: DescriptorRenderer = DescriptorRendererBuilder()
.setWithDefinedIn(false)
.setModifiers()
.setNameShortness(NameShortness.SHORT)
.setWithoutTypeParameters(true)
.setParameterNameRenderingPolicy(ParameterNameRenderingPolicy.NONE)
.setReceiverAfterName(true)
.setRenderCompanionObjectName(true)
.setWithoutSuperTypes(true)
.setStartFromName(true)
.build()
public val STARTS_FROM_NAME: DescriptorRenderer = withOptions {
withDefinedIn = false
modifiers = emptySet()
startFromName = true
}
public val FQ_NAMES_IN_TYPES: DescriptorRenderer = DescriptorRendererBuilder().build()
public val ONLY_NAMES_WITH_SHORT_TYPES: DescriptorRenderer = withOptions {
withDefinedIn = false
modifiers = emptySet()
nameShortness = NameShortness.SHORT
withoutTypeParameters = true
parameterNameRenderingPolicy = ParameterNameRenderingPolicy.NONE
receiverAfterName = true
renderCompanionObjectName = true
withoutSuperTypes = true
startFromName = true
}
public val SHORT_NAMES_IN_TYPES: DescriptorRenderer = DescriptorRendererBuilder()
.setNameShortness(NameShortness.SHORT)
.setParameterNameRenderingPolicy(ParameterNameRenderingPolicy.ONLY_NON_SYNTHESIZED)
.build()
public val FQ_NAMES_IN_TYPES: DescriptorRenderer = withOptions { }
public val DEBUG_TEXT: DescriptorRenderer = DescriptorRendererBuilder()
.setDebugMode(true)
.setNameShortness(NameShortness.FULLY_QUALIFIED)
.build()
public val SHORT_NAMES_IN_TYPES: DescriptorRenderer = withOptions {
nameShortness = NameShortness.SHORT
parameterNameRenderingPolicy = ParameterNameRenderingPolicy.ONLY_NON_SYNTHESIZED
}
public val FLEXIBLE_TYPES_FOR_CODE: DescriptorRenderer = DescriptorRendererBuilder()
.setFlexibleTypesForCode(true)
.build()
public val DEBUG_TEXT: DescriptorRenderer = withOptions {
debugMode = true
nameShortness = NameShortness.FULLY_QUALIFIED
}
public val HTML_COMPACT_WITH_MODIFIERS: DescriptorRenderer = DescriptorRendererBuilder()
.setWithDefinedIn(false)
.setTextFormat(TextFormat.HTML)
.build()
public val FLEXIBLE_TYPES_FOR_CODE: DescriptorRenderer = withOptions {
flexibleTypesForCode = true
}
public val HTML_NAMES_WITH_SHORT_TYPES: DescriptorRenderer = DescriptorRendererBuilder()
.setWithDefinedIn(false)
.setNameShortness(NameShortness.SHORT)
.setRenderCompanionObjectName(true)
.setTextFormat(TextFormat.HTML)
.build()
public val HTML_COMPACT_WITH_MODIFIERS: DescriptorRenderer = withOptions {
withDefinedIn = false
textFormat = TextFormat.HTML
}
public val HTML: DescriptorRenderer = DescriptorRendererBuilder()
.setTextFormat(TextFormat.HTML)
.build()
public val HTML_NAMES_WITH_SHORT_TYPES: DescriptorRenderer = withOptions {
withDefinedIn = false
nameShortness = NameShortness.SHORT
renderCompanionObjectName = true
textFormat = TextFormat.HTML
}
public val HTML_FOR_UNINFERRED_TYPE_PARAMS: DescriptorRenderer = DescriptorRendererBuilder()
.setUninferredTypeParameterAsName(true)
.setModifiers()
.setNameShortness(NameShortness.SHORT)
.setTextFormat(TextFormat.HTML)
.build()
public val HTML: DescriptorRenderer = withOptions {
textFormat = TextFormat.HTML
}
public val DEPRECATION: DescriptorRenderer = DescriptorRendererBuilder()
.setWithDefinedIn(false)
.setModifiers()
.setNameShortness(NameShortness.SHORT)
.setWithoutTypeParameters(false)
.setParameterNameRenderingPolicy(ParameterNameRenderingPolicy.NONE)
.setReceiverAfterName(false)
.setRenderCompanionObjectName(true)
.setRenderAccessors(true)
.setWithoutSuperTypes(true)
.setRenderDefaultValues(false)
.setStartFromName(true)
.build()
public val HTML_FOR_UNINFERRED_TYPE_PARAMS: DescriptorRenderer = withOptions {
uninferredTypeParameterAsName = true
modifiers = emptySet()
nameShortness = NameShortness.SHORT
textFormat = TextFormat.HTML
}
public val DEPRECATION: DescriptorRenderer = withOptions {
withDefinedIn = false
modifiers = emptySet()
nameShortness = NameShortness.SHORT
withoutTypeParameters = false
parameterNameRenderingPolicy = ParameterNameRenderingPolicy.NONE
receiverAfterName = false
renderCompanionObjectName = true
renderAccessors = true
withoutSuperTypes = true
renderDefaultValues = false
startFromName = true
}
}
}
public interface DescriptorRendererOptions {
public var nameShortness: NameShortness
public var withDefinedIn: Boolean
public var modifiers: Set<DescriptorRenderer.Modifier>
public var startFromName: Boolean
public var debugMode: Boolean
public var classWithPrimaryConstructor: Boolean
public var verbose: Boolean
public var unitReturnType: Boolean
public var normalizedVisibilities: Boolean
public var showInternalKeyword: Boolean
public var prettyFunctionTypes: Boolean
public var uninferredTypeParameterAsName: Boolean
public var overrideRenderingPolicy: DescriptorRenderer.OverrideRenderingPolicy
public var valueParametersHandler: DescriptorRenderer.ValueParametersHandler
public var textFormat: DescriptorRenderer.TextFormat
public var excludedAnnotationClasses: Set<FqName>
public var excludedTypeAnnotationClasses: Set<FqName>
public var includePropertyConstant: Boolean
public var parameterNameRenderingPolicy: DescriptorRenderer.ParameterNameRenderingPolicy
public var withoutTypeParameters: Boolean
public var receiverAfterName: Boolean
public var renderCompanionObjectName: Boolean
public var withoutSuperTypes: Boolean
public var typeNormalizer: (JetType) -> JetType
public var renderDefaultValues: Boolean
public var flexibleTypesForCode: Boolean
public var secondaryConstructorsAsPrimary: Boolean
public var renderAccessors: Boolean
}
@@ -1,212 +0,0 @@
/*
* Copyright 2010-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.renderer
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.types.JetType
import java.util.Collections
import java.util.EnumSet
public class DescriptorRendererBuilder {
private var nameShortness = NameShortness.SOURCE_CODE_QUALIFIED
private var withDefinedIn = true
private var modifiers: Set<DescriptorRenderer.Modifier> = EnumSet.allOf(javaClass<DescriptorRenderer.Modifier>())
private var startFromName = false
private var debugMode = false
private var classWithPrimaryConstructor = false
private var verbose = false
private var unitReturnType = true
private var normalizedVisibilities = false
private var showInternalKeyword = true
private var prettyFunctionTypes = true
private var uninferredTypeParameterAsName = false
private var includePropertyConstant = false
private var withoutTypeParameters = false
private var withoutSuperTypes = false
private var typeNormalizer: Function1<JetType, JetType> = object : Function1<JetType, JetType> {
override fun invoke(type: JetType): JetType {
return type
}
}
private var renderDefaultValues = true
private var flexibleTypesForCode = false
private var secondaryConstructorsAsPrimary = true
private var overrideRenderingPolicy: DescriptorRenderer.OverrideRenderingPolicy = DescriptorRenderer.OverrideRenderingPolicy.RENDER_OPEN
private var valueParametersHandler: DescriptorRenderer.ValueParametersHandler = DescriptorRenderer.DefaultValueParameterHandler()
private var textFormat: DescriptorRenderer.TextFormat = DescriptorRenderer.TextFormat.PLAIN
private var parameterNameRenderingPolicy: DescriptorRenderer.ParameterNameRenderingPolicy = DescriptorRenderer.ParameterNameRenderingPolicy.ALL
private var excludedAnnotationClasses: Collection<FqName> = emptyList()
private var receiverAfterName = false
private var renderCompanionObjectName = false
private var renderAccessors = false
// See JvmAnnotationNames#ANNOTATIONS_COPIED_TO_TYPES
private var excludedTypeAnnotationClasses: Collection<FqName> = setOf(
FqName("org.jetbrains.annotations.ReadOnly"),
FqName("org.jetbrains.annotations.Mutable"),
FqName("org.jetbrains.annotations.NotNull"),
FqName("org.jetbrains.annotations.Nullable"))
public fun setNameShortness(shortness: NameShortness): DescriptorRendererBuilder {
this.nameShortness = shortness
return this
}
public fun setWithDefinedIn(withDefinedIn: Boolean): DescriptorRendererBuilder {
this.withDefinedIn = withDefinedIn
return this
}
public fun setModifiers(modifiers: Set<DescriptorRenderer.Modifier>): DescriptorRendererBuilder {
this.modifiers = modifiers
return this
}
public fun setModifiers(vararg modifiers: DescriptorRenderer.Modifier): DescriptorRendererBuilder {
return setModifiers(setOf(*modifiers))
}
public fun setStartFromName(startFromName: Boolean): DescriptorRendererBuilder {
this.startFromName = startFromName
return this
}
public fun setDebugMode(debugMode: Boolean): DescriptorRendererBuilder {
this.debugMode = debugMode
return this
}
public fun setClassWithPrimaryConstructor(classWithPrimaryConstructor: Boolean): DescriptorRendererBuilder {
this.classWithPrimaryConstructor = classWithPrimaryConstructor
return this
}
public fun setVerbose(verbose: Boolean): DescriptorRendererBuilder {
this.verbose = verbose
return this
}
public fun setUnitReturnType(unitReturnType: Boolean): DescriptorRendererBuilder {
this.unitReturnType = unitReturnType
return this
}
public fun setNormalizedVisibilities(normalizedVisibilities: Boolean): DescriptorRendererBuilder {
this.normalizedVisibilities = normalizedVisibilities
return this
}
public fun setShowInternalKeyword(showInternalKeyword: Boolean): DescriptorRendererBuilder {
this.showInternalKeyword = showInternalKeyword
return this
}
public fun setOverrideRenderingPolicy(overrideRenderingPolicy: DescriptorRenderer.OverrideRenderingPolicy): DescriptorRendererBuilder {
this.overrideRenderingPolicy = overrideRenderingPolicy
return this
}
public fun setValueParametersHandler(valueParametersHandler: DescriptorRenderer.ValueParametersHandler): DescriptorRendererBuilder {
this.valueParametersHandler = valueParametersHandler
return this
}
public fun setTextFormat(textFormat: DescriptorRenderer.TextFormat): DescriptorRendererBuilder {
this.textFormat = textFormat
return this
}
public fun setExcludedAnnotationClasses(excludedAnnotationClasses: Collection<FqName>): DescriptorRendererBuilder {
this.excludedAnnotationClasses = excludedAnnotationClasses
return this
}
public fun setExcludedTypeAnnotationClasses(excludedTypeAnnotationClasses: Collection<FqName>): DescriptorRendererBuilder {
this.excludedTypeAnnotationClasses = excludedTypeAnnotationClasses
return this
}
public fun setPrettyFunctionTypes(prettyFunctionTypes: Boolean): DescriptorRendererBuilder {
this.prettyFunctionTypes = prettyFunctionTypes
return this
}
public fun setUninferredTypeParameterAsName(uninferredTypeParameterAsName: Boolean): DescriptorRendererBuilder {
this.uninferredTypeParameterAsName = uninferredTypeParameterAsName
return this
}
public fun setIncludePropertyConstant(includePropertyConstant: Boolean): DescriptorRendererBuilder {
this.includePropertyConstant = includePropertyConstant
return this
}
public fun setParameterNameRenderingPolicy(parameterNameRenderingPolicy: DescriptorRenderer.ParameterNameRenderingPolicy): DescriptorRendererBuilder {
this.parameterNameRenderingPolicy = parameterNameRenderingPolicy
return this
}
public fun setWithoutTypeParameters(withoutTypeParameters: Boolean): DescriptorRendererBuilder {
this.withoutTypeParameters = withoutTypeParameters
return this
}
public fun setReceiverAfterName(receiverAfterName: Boolean): DescriptorRendererBuilder {
this.receiverAfterName = receiverAfterName
return this
}
public fun setRenderCompanionObjectName(renderCompanionObjectName: Boolean): DescriptorRendererBuilder {
this.renderCompanionObjectName = renderCompanionObjectName
return this
}
public fun setWithoutSuperTypes(withoutSuperTypes: Boolean): DescriptorRendererBuilder {
this.withoutSuperTypes = withoutSuperTypes
return this
}
public fun setRenderDefaultValues(renderDefaultValues: Boolean): DescriptorRendererBuilder {
this.renderDefaultValues = renderDefaultValues
return this
}
public fun setTypeNormalizer(typeNormalizer: Function1<JetType, JetType>): DescriptorRendererBuilder {
this.typeNormalizer = typeNormalizer
return this
}
public fun setFlexibleTypesForCode(flexibleTypesForCode: Boolean): DescriptorRendererBuilder {
this.flexibleTypesForCode = flexibleTypesForCode
return this
}
public fun setSecondaryConstructorsAsPrimary(secondaryConstructorsAsPrimary: Boolean): DescriptorRendererBuilder {
this.secondaryConstructorsAsPrimary = secondaryConstructorsAsPrimary
return this
}
public fun setRenderAccessors(renderAccessors: Boolean): DescriptorRendererBuilder {
this.renderAccessors = renderAccessors
return this
}
public fun build(): DescriptorRenderer {
return DescriptorRendererImpl(nameShortness, withDefinedIn, modifiers, startFromName, debugMode, classWithPrimaryConstructor, verbose, unitReturnType, normalizedVisibilities, showInternalKeyword, prettyFunctionTypes, uninferredTypeParameterAsName, overrideRenderingPolicy, valueParametersHandler, textFormat, excludedAnnotationClasses, excludedTypeAnnotationClasses, includePropertyConstant, parameterNameRenderingPolicy, withoutTypeParameters, receiverAfterName, renderCompanionObjectName, withoutSuperTypes, typeNormalizer, renderDefaultValues, flexibleTypesForCode, secondaryConstructorsAsPrimary, renderAccessors)
}
}
@@ -38,42 +38,12 @@ import java.util.*
import org.jetbrains.kotlin.resolve.DescriptorUtils.isCompanionObject
import org.jetbrains.kotlin.types.TypeUtils.CANT_INFER_FUNCTION_PARAM_TYPE
public class DescriptorRendererImpl internal constructor(
private val nameShortness: NameShortness,
private val withDefinedIn: Boolean,
private val modifiers: Set<DescriptorRenderer.Modifier>,
private val startFromName: Boolean,
private val debugMode: Boolean,
private val classWithPrimaryConstructor: Boolean,
private val verbose: Boolean,
private val unitReturnType: Boolean,
private val normalizedVisibilities: Boolean,
private val showInternalKeyword: Boolean,
private val prettyFunctionTypes: Boolean,
private val uninferredTypeParameterAsName: Boolean,
private val overrideRenderingPolicy: DescriptorRenderer.OverrideRenderingPolicy,
private val handler: DescriptorRenderer.ValueParametersHandler,
private val textFormat: DescriptorRenderer.TextFormat,
excludedAnnotationClasses: Collection<FqName>,
excludedTypeAnnotationClasses: Collection<FqName>,
private val includePropertyConstant: Boolean,
private val parameterNameRenderingPolicy: DescriptorRenderer.ParameterNameRenderingPolicy,
private val withoutTypeParameters: Boolean,
private val receiverAfterName: Boolean,
private val renderCompanionObjectName: Boolean,
private val withoutSuperTypes: Boolean,
private val typeNormalizer: Function1<JetType, JetType>,
private val renderDefaultValues: Boolean,
private val flexibleTypesForCode: Boolean,
private val secondaryConstructorsAsPrimary: Boolean,
private val renderAccessors: Boolean
) : DescriptorRenderer {
private val excludedAnnotationClasses: Set<FqName>
private val excludedTypeAnnotationClasses: Set<FqName>
public/*TODO*/ class DescriptorRendererImpl internal constructor(
public val options: DescriptorRendererOptionsImpl
) : DescriptorRenderer, DescriptorRendererOptions by options/* this gives access to options without qualifier */ {
init {
this.excludedAnnotationClasses = HashSet(excludedAnnotationClasses)
this.excludedTypeAnnotationClasses = HashSet(excludedTypeAnnotationClasses)
assert(options.isLocked)
}
/* FORMATTING */
@@ -682,13 +652,13 @@ public class DescriptorRendererImpl internal constructor(
private fun renderValueParameters(function: FunctionDescriptor, builder: StringBuilder) {
val includeNames = shouldRenderParameterNames(function)
handler.appendBeforeValueParameters(function, builder)
valueParametersHandler.appendBeforeValueParameters(function, builder)
for (parameter in function.getValueParameters()) {
handler.appendBeforeValueParameter(parameter, builder)
valueParametersHandler.appendBeforeValueParameter(parameter, builder)
renderValueParameter(parameter, includeNames, builder, false)
handler.appendAfterValueParameter(parameter, builder)
valueParametersHandler.appendAfterValueParameter(parameter, builder)
}
handler.appendAfterValueParameters(function, builder)
valueParametersHandler.appendAfterValueParameters(function, builder)
}
private fun shouldRenderParameterNames(function: FunctionDescriptor): Boolean {
@@ -0,0 +1,97 @@
/*
* Copyright 2010-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.renderer
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.types.JetType
import java.lang.reflect.Modifier
import java.util.EnumSet
import kotlin.properties.Delegates
import kotlin.properties.ObservableProperty
import kotlin.properties.ReadWriteProperty
internal class DescriptorRendererOptionsImpl : DescriptorRendererOptions {
public var isLocked: Boolean = false
private set
public fun lock() {
assert(!isLocked)
isLocked = true
}
public fun copy(): DescriptorRendererOptionsImpl {
val copy = DescriptorRendererOptionsImpl()
//TODO: use Kotlin reflection when it's ready
for (field in this.javaClass.getDeclaredFields()) {
if (field.getModifiers().and(Modifier.STATIC) != 0) continue
field.setAccessible(true)
val property = field.get(this) as? ObservableProperty<*> ?: continue
val value = property.get(this, PropertyMetadataImpl("")/* not used*/)
field.set(copy, copy.property(value as Any))
}
return copy
}
private fun <T> property(initialValue: T): ReadWriteProperty<DescriptorRendererOptionsImpl, T> {
return Delegates.vetoable(initialValue) { property, oldValue, newValue ->
if (isLocked) {
throw IllegalStateException("Cannot modify readonly DescriptorRendererOptions")
}
else {
true
}
}
}
override var nameShortness by property(NameShortness.SOURCE_CODE_QUALIFIED)
override var withDefinedIn by property(true)
override var modifiers: Set<DescriptorRenderer.Modifier> by property(EnumSet.allOf(javaClass<DescriptorRenderer.Modifier>()))
override var startFromName by property(false)
override var debugMode by property(false)
override var classWithPrimaryConstructor by property(false)
override var verbose by property(false)
override var unitReturnType by property(true)
override var normalizedVisibilities by property(false)
override var showInternalKeyword by property(true)
override var prettyFunctionTypes by property(true)
override var uninferredTypeParameterAsName by property(false)
override var includePropertyConstant by property(false)
override var withoutTypeParameters by property(false)
override var withoutSuperTypes by property(false)
override var typeNormalizer by property<(JetType) -> JetType>({ it })
override var renderDefaultValues by property(true)
override var flexibleTypesForCode by property(false)
override var secondaryConstructorsAsPrimary by property(true)
override var overrideRenderingPolicy by property(DescriptorRenderer.OverrideRenderingPolicy.RENDER_OPEN)
override var valueParametersHandler: DescriptorRenderer.ValueParametersHandler by property(DescriptorRenderer.ValueParametersHandler.DEFAULT)
override var textFormat by property(DescriptorRenderer.TextFormat.PLAIN)
override var parameterNameRenderingPolicy by property(DescriptorRenderer.ParameterNameRenderingPolicy.ALL)
override var receiverAfterName by property(false)
override var renderCompanionObjectName by property(false)
override var renderAccessors by property(false)
override var excludedAnnotationClasses by property(emptySet<FqName>())
override var excludedTypeAnnotationClasses by property(setOf(
FqName("org.jetbrains.annotations.ReadOnly"),
FqName("org.jetbrains.annotations.Mutable"),
FqName("org.jetbrains.annotations.NotNull"),
FqName("org.jetbrains.annotations.Nullable")
))
}
@@ -16,10 +16,12 @@
package org.jetbrains.kotlin.resolve;
import kotlin.Unit;
import kotlin.jvm.functions.Function1;
import org.jetbrains.kotlin.descriptors.*;
import org.jetbrains.kotlin.name.Name;
import org.jetbrains.kotlin.renderer.DescriptorRenderer;
import org.jetbrains.kotlin.renderer.DescriptorRendererBuilder;
import org.jetbrains.kotlin.renderer.DescriptorRendererOptions;
import java.util.Comparator;
import java.util.List;
@@ -29,7 +31,15 @@ import static org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry;
public class MemberComparator implements Comparator<DeclarationDescriptor> {
public static final MemberComparator INSTANCE = new MemberComparator();
private static final DescriptorRenderer RENDERER = new DescriptorRendererBuilder().setWithDefinedIn(false).setVerbose(true).build();
private static final DescriptorRenderer RENDERER = DescriptorRenderer.Companion.withOptions(
new Function1<DescriptorRendererOptions, Unit>() {
@Override
public Unit invoke(DescriptorRendererOptions options) {
options.setWithDefinedIn(false);
options.setVerbose(true);
return Unit.INSTANCE$;
}
});
private MemberComparator() {
}