private fun simplifyType(type: UnwrappedType): KotlinType {
        var result = type
        do {
            val oldResult = result
            result = when (type) {
                is FlexibleType -> type.upperBound
                is DefinitelyNotNullType -> type.original
                else -> type
            }
        } while (result !== oldResult)
        return result
    }

  @Override
  public abstract ImmutableSortedMultiset<E> headMultiset(E upperBound, BoundType boundType);

  @Override
  public ImmutableSortedMultiset<E> subMultiset(
      E lowerBound, BoundType lowerBoundType, E upperBound, BoundType upperBoundType) {
    checkArgument(
        comparator().compare(lowerBound, upperBound) <= 0,
        "Expected lowerBound <= upperBound but %s > %s",
        lowerBound,
        upperBound);

        withValidityAssertion { analysisSession.typeProvider.withNullability(this, newNullability) }

    public fun KaType.upperBoundIfFlexible(): KaType = withValidityAssertion { (this as? KaFlexibleType)?.upperBound ?: this }
    public fun KaType.lowerBoundIfFlexible(): KaType = withValidityAssertion { (this as? KaFlexibleType)?.lowerBound ?: this }

        val lowerBoundText = prettyPrint { renderType(type.lowerBound, this@prettyPrint) }
        val upperBoundText = prettyPrint { renderType(type.upperBound, this@prettyPrint) }
        printer.append(DescriptorRenderer.COMPACT.renderFlexibleType(lowerBoundText, upperBoundText, type.builtIns))
    }

            </ul>
          </description>
          <type>String</type>
        </field>
        <field>
          <name>provides</name>
          <version>1.0.0/1.0.99</version> <!-- fake upperbound, it's inclusive -->
          <type>DOM</type> <!-- DOM for Maven 2.0.9/2.3.3 -->
          <description>
            Toolchain identification information, which will be matched against project requirements.

    /** Returns true if the type is a platform flexible type and may or may not be marked nullable. */
    public val KaType.hasFlexibleNullability: Boolean get() = withValidityAssertion { this is KaFlexibleType && this.upperBound.isMarkedNullable != this.lowerBound.isMarkedNullable }

    public val KaType.isUnit: Boolean get() = withValidityAssertion { isClassTypeWithClassId(DefaultTypeClassIds.UNIT) }

       * effectiveRange.isEmpty() would have returned true.
       */
      C afterLower = requireNonNull(range.lowerBound.leastValueAbove(domain));
      C beforeUpper = requireNonNull(range.upperBound.greatestValueBelow(domain));
      // Per class spec, we are allowed to throw CCE if necessary
      empty = Range.compareOrThrow(afterLower, beforeUpper) > 0;
    }

    return empty

       * effectiveRange.isEmpty() would have returned true.
       */
      C afterLower = requireNonNull(range.lowerBound.leastValueAbove(domain));
      C beforeUpper = requireNonNull(range.upperBound.greatestValueBelow(domain));
      // Per class spec, we are allowed to throw CCE if necessary
      empty = Range.compareOrThrow(afterLower, beforeUpper) > 0;
    }

    return empty

                    ),
                    typeParameters = listOf(
                        newTypeParameterOf(name = "T", variance = KmVariance.INVARIANT, upperBound = GradleType.dependency)
                    ),
                    signature = signature
                )
            },
            signature = JvmMethodSignature(
                propertyName,

        when (this) {
            is ConeErrorType -> null
            is ConeLookupTagBasedType -> lookupTag.name.asString().toConstantValueKind()
            is ConeFlexibleType -> upperBound.toConstantValueKind()
            is ConeCapturedType -> lowerType?.toConstantValueKind() ?: constructor.supertypes!!.first().toConstantValueKind()
            is ConeDefinitelyNotNullType -> original.toConstantValueKind()