get() = withValidityAssertion {
            KaFirAnnotationListForDeclaration.create(firSymbol, builder)
        }

    @OptIn(UnexpandedTypeCheck::class)
    override val upperBounds: List<KaType> by cached {
        firSymbol.resolvedBounds.mapNotNull { type ->
            if (type.isNullableAny) return@mapNotNull null
            builder.typeBuilder.buildKtType(type)
        }
    }

  return statistics;
}

std::pair<int32_t, int32_t>
CalibrationStatisticsCollectorHistogram::ExpandHistogramIfNeeded(
    const float lower_bound, const float upper_bound) {
  int32_t lower_idx = CalculateBinIndex(lower_bound, lower_bound_, bin_width_);
  // If lower_idx < 0, then expand the histogram to the left.
  if (lower_idx < 0) {

    }

    TypeVariable<?> captureAsTypeVariable(Type[] upperBounds) {
      String name =
          "capture#" + id.incrementAndGet() + "-of ? extends " + Joiner.on('&').join(upperBounds);
      return Types.newArtificialTypeVariable(WildcardCapturer.class, name, upperBounds);
    }

    private WildcardCapturer forTypeVariable(TypeVariable<?> typeParam) {

    }

    TypeVariable<?> captureAsTypeVariable(Type[] upperBounds) {
      String name =
          "capture#" + id.incrementAndGet() + "-of ? extends " + Joiner.on('&').join(upperBounds);
      return Types.newArtificialTypeVariable(WildcardCapturer.class, name, upperBounds);
    }

    private WildcardCapturer forTypeVariable(TypeVariable<?> typeParam) {

    final override val typeParameters: List<KaTypeParameterSymbol>
        get() = withValidityAssertion { emptyList() }

    public abstract val upperBounds: List<KaType>
    public abstract val variance: Variance
    public abstract val isReified: Boolean
}

public typealias KtTypeParameterSymbol = KaTypeParameterSymbol

                return;
            }
            referencedTypes.add(type.toErasure());
            if (type instanceof JavaTypeVariable) {
                List<JavaType> upperBounds = ((JavaTypeVariable<?>) type).getUpperBounds();
                upperBounds.forEach(bound -> unpackJavaType(bound, referencedTypes, visited));
            } else if (type instanceof JavaGenericArrayType) {

  // incomplete reads may still go undetected.
  if (block->data.size() < block_size_) {
    Key fmax = std::make_pair(key.first, std::numeric_limits<size_t>::max());
    auto fcmp = block_map_.upper_bound(fmax);
    if (fcmp != block_map_.begin() && key < (--fcmp)->first) {
      return TF_SetStatus(status, TF_INTERNAL,
                          "Block cache contents are inconsistent.");
    }
  }

  Trim();

        // Type parameters cannot act as receiver types in KDoc
        if (actualReceiverType is KaTypeParameterType) return false

        if (type is KaTypeParameterType) {
            return type.symbol.upperBounds.all { isPossiblySuperTypeOf(it, actualReceiverType) }
        }

        val receiverExpanded = actualReceiverType.expandedSymbol
        val expectedExpanded = type.expandedSymbol

  TF_DerivedOperandTypeAttr Tnumsegments = TF_DerivedOperandTypeAttr<2>;

  let hasVerifier = 1;
}

def TF_UpperBoundOp : TF_Op<"UpperBound", [Pure]> {
  let summary = [{
Applies upper_bound(sorted_search_values, values) along each row.
  }];

  let description = [{
Each set of rows with the same index in (sorted_inputs, values) is treated

      }

      @Test
      @TestMetadata("upperBound1.kt")
      public void testUpperBound1() {
        runTest("analysis/analysis-api/testData/components/resolver/singleByPsi/typeArgument/functionCall/upperBound1.kt");
      }

      @Test
      @TestMetadata("upperBound2.kt")
      public void testUpperBound2() {