property(a, literal(1))
                    literal(1)
                element(addingNested, [literal(1)], content.size = 1)
                    literal(1)
                    property(a, literal(2))
                        literal(2)
                property(b, literal(5))
                    literal(5)
                element(addingNested, [literal(1)], content.size = 1)
                    literal(1)

                property(a, literal(1)[16..16])[12..16]
                property(b, valueFactory(f, literal(x)[28..30], valueFactory(z.f, literal(y)[37..39])[35..40])[26..41])[22..41]
                property(c, literal(true)[51..54])[47..54]
                element(nested)[60..89]
                    property(x, literal(y)[81..83])[77..83]
                element(factory, literal(1)[103..103])[95..104]

            """.trimIndent(),

   * of their natural ordering.
   */
  public static <E extends Comparable<?>> Builder<E> reverseOrder() {
    return new Builder<>(Collections.reverseOrder());
  }

  /**
   * Returns a builder that creates immutable sorted sets whose elements are ordered by their
   * natural ordering. The sorted sets use {@link Ordering#natural()} as the comparator. This method

  private static final Comparator<?> NATURAL_ORDER = Ordering.natural();

  private static final ImmutableSortedMap<Comparable<?>, Object> NATURAL_EMPTY_MAP =
      new ImmutableSortedMap<>(
          ImmutableSortedSet.emptySet(Ordering.natural()), ImmutableList.<Object>of());

  static <K, V> ImmutableSortedMap<K, V> emptyMap(Comparator<? super K> comparator) {
    if (Ordering.natural().equals(comparator)) {
      return of();
    } else {

   * ordering.
   *
   * @throws NullPointerException if any element is null
   */
  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(E e1, E e2, E e3) {
    return copyOf(Ordering.natural(), Arrays.asList(e1, e2, e3));
  }

  /**
   * Returns an immutable sorted multiset containing the given elements sorted by their natural
   * ordering.
   *

        }
        source(blockElement.failingResult)
    } else blockElement.sourceData

    return DefaultErrorNode(sourceData, errors)
}


private

}

public typealias KtEnumEntryAnnotationValue = KaEnumEntryAnnotationValue

/**
 * Some constant value (which may be used as initializer of `const val`) used as annotation argument. It may be String literal, number literal or some simple expression.
 * E.g: `@A(1 +2, "a" + "b")` -- both arguments here are [KaConstantAnnotationValue]
 * @see [KaConstantValue]
 */
public class KaConstantAnnotationValue @KaAnalysisApiInternals constructor(

// CHECK-LABEL: avg_pool2d_7
// CHECK: %cst = arith.constant dense<[0, 2, 3, 1]> : tensor<4xi32>
// CHECK{LITERAL}: %0 = "tfl.transpose"(%arg0, %cst) : (tensor<1x1x1x8xf32>, tensor<4xi32>) -> tensor<1x1x8x1xf32>
// CHECK{LITERAL}: %cst_0 = arith.constant dense<[[0, 0], [0, 0], [1, 2], [0, 0]]> : tensor<4x2xi32>

            val value: Any
        }

        interface ValueFactoryNode : ValueNode {
            val factoryName: String
            val values: List<ValueNode> // TODO: restrict to a single value? or even a single literal?
        }
    }

}


internal
data class DefaultLiteralNode(
    override val value: Any,
    override val sourceData: SourceData
) : DeclarativeDocument.ValueNode.LiteralValueNode {
    override fun toString(): String = "literal($value)"
}


internal
data class DefaultValueFactoryNode(
    override val factoryName: String,
    override val sourceData: SourceData,
    override val values: List<DeclarativeDocument.ValueNode>