if (dependency != null) {
            sb.append(":").append(dependency.getScope());
        }

        return sb.toString();
    }

    @Override
    public String toString() {
        return getDependencyNode().toString();
    }

func _C_ai_socktype(ai *_C_struct_addrinfo) *_C_int          { return &ai.ai_socktype }

func _C_freeaddrinfo(ai *_C_struct_addrinfo) {
	C.freeaddrinfo(ai)
}

func _C_gai_strerror(eai _C_int) string {
	return C.GoString(C.gai_strerror(eai))
}

func _C_getaddrinfo(hostname, servname *_C_char, hints *_C_struct_addrinfo, res **_C_struct_addrinfo) (int, error) {
	x, err := C.getaddrinfo(hostname, servname, hints, res)

    @KaAnalysisNonPublicApi
    override val presentableText: String?
        get() = withValidityAssertion {
            qualifiers.joinToString(separator = ".") { it.name.asString() }
        }

    @KaAnalysisNonPublicApi
    override val errorMessage: String get() = withValidityAssertion { coneDiagnostic.reason }

    override val annotations: KaAnnotationList by cached {

        append(value.constantValue.renderAsKotlinConstant())
    }

    private fun StringBuilder.renderEnumEntryConstantValue(value: KaEnumEntryAnnotationValue) {
        append(value.callableId?.asSingleFqName()?.asString())
    }

    private fun StringBuilder.renderAnnotationConstantValue(application: KaAnnotationApplicationValue) {
        renderAnnotationApplication(application.annotationValue)
    }

// a string, the result is of type (possibly untyped) string.
func coreString(t Type) Type {
	t = Unalias(t)
	tpar, _ := t.(*TypeParam)
	if tpar == nil {
		return under(t) // string or untyped string
	}

	var su Type
	hasString := false
	if tpar.underIs(func(u Type) bool {
		if u == nil {
			return false
		}
		if isString(u) {
			u = NewSlice(universeByte)

            return securityHandler
        }

        void addConstraint(ConstraintSecurityHandler securityHandler, String path) {
            securityHandler.addConstraintMapping(createConstraintMapping(path))
        }

        private ConstraintMapping createConstraintMapping(String path) {
            def constraint = new Constraint()
            constraint.name = constraintName()

func isFloat(t Type) bool          { return isBasic(t, IsFloat) }
func isComplex(t Type) bool        { return isBasic(t, IsComplex) }
func isNumeric(t Type) bool        { return isBasic(t, IsNumeric) }
func isString(t Type) bool         { return isBasic(t, IsString) }
func isIntegerOrFloat(t Type) bool { return isBasic(t, IsInteger|IsFloat) }
func isConstType(t Type) bool      { return isBasic(t, IsConstType) }

        return new ModelVersionParser() {
            @Override
            public Version parseVersion(String version) {
                requireNonNull(version, "version");
                return new Version() {
                    @Override
                    public String asString() {
                        return version;
                    }

                    @Override

    String getBuildInvocationId() {
        scopeIds.buildInvocationId.asString()
    }

    String originBuildInvocationId(String taskPath) {
        outputOrigin.originId(taskPath)
    }

    OriginMetadata origin(String taskPath) {
        outputOrigin.origin(taskPath)
    }

    def setup() {

    def setup() {
        buildFile << """
class TextTask extends DefaultTask {
    @Nested
    TextResource text

    @TaskAction
    def go() {
        println text.asString()
    }
}

task text(type: TextTask)
"""
    }

    def "reports read of missing text file"() {
        given:
        buildFile << """
            text.text = resources.text.fromFile('no-such-file')