collectDescendantsOfType<KtClassOrObject> { it.fqName?.asString() == member.name }.singleOrNull()


private
val SINCE_REGEX = Regex("""@since ([^\s]+)""")


fun KtDeclaration.getSince(): String? =
    docComment?.let { SINCE_REGEX.find(it.text)?.groupValues?.get(1) }


private
fun String.mapJavaTypeToKotlinType(): String {
    val javaTypeName = this

private
fun <T> T.getSinceIfMatchesName(candidateName: String): SinceTagStatus? where T : BodyDeclaration<*>, T : NodeWithSimpleName<*> =
    takeIf { it.matchesName(candidateName) }?.getSince()?.let { SinceTagStatus.Present(it) }


private
fun <T : NodeWithSimpleName<*>> T.matchesName(candidateName: String) =
    matchesName(name.asString(), candidateName)


private
fun matchesName(name: String, candidateName: String) =

		return nil
	}
	if x, ok := v.bytesToBool(); ok {
		v.setBool(x)
		return nil
	}

	asString := strings.TrimSpace(v.bytesToString())
	if len(b) > 0 &&
		(strings.HasPrefix(asString, "{") || strings.HasPrefix(asString, "[")) {
		return nil
	}

	if t, err := parseSQLTimestamp(asString); err == nil {
		v.setTimestamp(t)
		return nil
	}
	if !utf8.Valid(b) {

        get() = annotationEntries.any { it.shortName?.asString() == "Incubating" }

    private
    val KtNamedDeclaration.typeParametersString: String
        get() = (this as? KtCallableDeclaration)?.typeParameterList?.let { "${it.text} " } ?: ""

    private
    val KtNamedDeclaration.fullyQualifiedName: String
        get() = fqName!!.asString()

    private

            return;
        }
        ClassMetaData outerClass = classStack.isEmpty() ? null : getCurrentClass();
        String baseName = typeDeclaration.getNameAsString();
        String className = outerClass == null ? packageName + '.' + baseName : outerClass.getClassName() + '.' + baseName;
        String comment = getJavadocComment(typeDeclaration);

     *   <li>Conflict resolution information (if the dependency was omitted due to conflicts or duplicates)</li>
     * </ul>
     *
     * @return a string representation of this dependency node with optional detailed information
     */
    @Nonnull
    String asString();

    /**
     * Obtain a Stream containing this node and all its descendants.
     *
     * @return a stream containing this node and its descendants

    TRUE,
  }

  static class Foo {
    private final String aString;
    private final int anInt;
    private final @Nullable TriState anEnum;

    Foo(String aString, int anInt, @Nullable TriState anEnum) {
      this.aString = aString;
      this.anInt = anInt;
      this.anEnum = anEnum;
    }

    @Override
    public String toString() {
      return toStringHelper(this)

	case int64:
		return v, nil
	case int:
		return int64(v), nil
	case string:
		i, err := strconv.Atoi(v)
		return int64(i), err
	default:
		return 0, errors.New("Invalid number format")
	}
}

// isString - Safely check if val is of type string without causing panic.
func isString(val any) bool {
	_, ok := val.(string)
	return ok
}

// ContentLengthRange - policy content-length-range field.

        val performanceTestsCiJsonObj: Map<String, List<Map<String, Any>>> = objectMapper.readValue(performanceTestsCiJson)

        return performanceTestsCiJsonObj["performanceTests"]!!.map { scenarioObj ->
            val testId = scenarioObj["testId"] as String
            val groups =
                (scenarioObj["groups"] as List<Map<String, Any>>).map { groupObj ->

    incubatingAnnotationTypeDescriptor: String,
    outputDirectory: File,
    packageName: String,
    sourceFilesBaseName: String,
    hashTypeSourceName: java.util.function.Function<String, String>,
    classPath: List<File>,
    classPathDependencies: List<File>,
    apiSpec: java.util.function.Function<String, Boolean>,
    sinceSupplier: java.util.function.Function<String, String?>,
): List<File> =

    apiTypeProviderFor(