connections[HttpConnection.currentConnection] = connectionAuth
        }

        if (connectionAuth.failed) {
            httpResponse.setHeader(HttpHeader.WWW_AUTHENTICATE.asString(), "basic realm=\"" + _loginService.getName() + '"')
            httpResponse.sendError(HttpServletResponse.SC_UNAUTHORIZED)
            return Authentication.SEND_CONTINUE
        } else if (connectionAuth.user != null) {

            analysisSession: KaSession,
            name: Name,
            owner: KaType,
            typeRenderer: KaTypeRenderer,
            printer: PrettyPrinter,
        ) {
            printer.append(name.asString())
        }
    }
}

                }?.fqNameForClassNameWithoutDollars?.asString()
            }
            else -> {
                return if (containingSymbolOrSelf.symbolKind == KaSymbolKind.TOP_LEVEL) {
                    descriptor?.let(DescriptorToSourceUtils::getContainingFile)
                        ?.takeUnless { it.isScript() }
                        ?.javaFileFacadeFqName?.asString()
                } else {

type TestSliceAlias []byte

func fSliceAlias(a TestSliceAlias) TestSliceAlias { return a }

func fString(a string) string { return a }

type TestStringAlias string

func fStringAlias(a TestStringAlias) TestStringAlias { return a }

type TestStruct struct {
	A int
	B string
}

func fStruct(a TestStruct) TestStruct { return a }

type TestStructAlias TestStruct

    }

    public void addField(String name, PBXObject obj) {
        if (obj != null) {
            String gid = serializeObject(obj);
            currentObject.put(name, gid);
        }
    }

    public void addField(String name, int val) {
        currentObject.put(name, val);
    }

    public void addField(String name, String val) {
        if (val != null) {

	b, err := AsBytes(filename)
	if err != nil {
		return "", err
	}
	return string(b), nil
}

// AsStringOrFail calls AsBytesOrFail and then converts to string.
func AsStringOrFail(t test.Failer, filename string) string {
	t.Helper()
	return string(AsBytesOrFail(t, filename))
}

// MustAsString calls MustAsBytes and then converts to string.
func MustAsString(filename string) string {

        return KaFirPsiJavaClassSymbol(psiClass, analysisSession)
    }

    private fun PsiClass.isKotlinCompiledClass() =
        this is ClsElementImpl && hasAnnotation(JvmAnnotationNames.METADATA_FQ_NAME.asString())

    override fun getCallableSymbol(callable: PsiMember): KaCallableSymbol? {
        if (callable !is PsiMethod && callable !is PsiField) return null
        val name = callable.name?.let(Name::identifier) ?: return null

        }
    }

    private fun render(symbol: KaSymbol): String {
        val qualifiedName = when (symbol) {
            is KaCallableSymbol -> symbol.callableId?.toString()
            is KaClassLikeSymbol -> symbol.classId?.toString()
            else -> null
        }

        return qualifiedName ?: (symbol as? KaNamedSymbol)?.name?.asString() ?: "Unnamed"
    }

var _AlgKind_index = [...]uint8{0, 3, 7, 12, 15, 19, 23, 28, 33, 38, 44, 50, 55, 63, 70, 77, 83, 90, 97}

func (i AlgKind) String() string {
	if i < 0 || i >= AlgKind(len(_AlgKind_index)-1) {
		return "AlgKind(" + strconv.FormatInt(int64(i), 10) + ")"
	}
	return _AlgKind_name[_AlgKind_index[i]:_AlgKind_index[i+1]]

//sys	remove(path string) (err error)

func Remove(path string) error {
	fixwd()
	return remove(path)
}

//sys	stat(path string, edir []byte) (n int, err error)

func Stat(path string, edir []byte) (n int, err error) {
	fixwd()
	return stat(path, edir)
}

//sys	bind(name string, old string, flag int) (err error)

func Bind(name string, old string, flag int) (err error) {
	fixwd()