when (val possiblyRawVisibility = firSymbol.fir.visibility) {
                Visibilities.Unknown -> if (firSymbol.fir.isLocal) Visibilities.Local else Visibilities.Public
                else -> possiblyRawVisibility
            }
        }

    override val annotations by cached {
        KaFirAnnotationListForDeclaration.create(firSymbol, builder)
    }

        get() = analysisContext.token

    override fun isEmpty(): Boolean = withValidityAssertion {
        return if (ignoredAnnotations.isEmpty()) {
            fe10Annotations.isEmpty()
        } else {
            backingAnnotations.isEmpty()
        }
    }

    override val size: Int
        get() = withValidityAssertion { backingAnnotations.size }

        ) {
            printer {
                val classId = annotation.classId
                if (classId != null) {
                    append(classId.asSingleFqName().render())
                } else {
                    append("ERROR_ANNOTATION")
                }
            }
        }
    }

    public object WITH_SHORT_NAMES : KaAnnotationQualifierRenderer {
        override fun renderQualifier(

                    }
                }
                if (isMarkedNullable) "$renderedQualifier?" else renderedQualifier
            }
            is FirFunctionTypeRef -> {
                val classId = if (isSuspend) {
                    StandardNames.getSuspendFunctionClassId(parametersCount)
                } else {
                    StandardNames.getFunctionClassId(parametersCount)
                }

        val typeToRender = if (renderExpandedTypes) type.fullyExpandedType else type

        renderFrontendIndependentKClassNameOf(typeToRender, printer)
        printer.withIndent {
            appendLine()
            if (renderTypeByProperties) {
                renderByPropertyNames(typeToRender, printer)
            } else {
                append("annotations: ")

                is FirAbstractSimpleImportingScope -> EXPLICIT
                else -> LOCAL
            }
        }

        fun fromShortenOption(option: ShortenStrategy): ImportKind? = when (option) {
            ShortenStrategy.SHORTEN_AND_IMPORT -> EXPLICIT
            ShortenStrategy.SHORTEN_AND_STAR_IMPORT -> STAR
            else -> null
        }
    }
}

private data class AvailableSymbol<out T>(

                return false
            }

            is KaScriptSymbol -> {
                // Scripts are always top-level
                return false
            }

            else -> {}
        }

        if (symbol is KaSymbolWithKind && symbol.symbolKind == KaSymbolKind.TOP_LEVEL) {
            val containingFile = (symbol.firSymbol.fir as? FirElementWithResolveState)?.getContainingFile()

        is KaFirNamedClassOrObjectSymbol -> firSymbol.fir
        is KaFirPsiJavaClassSymbol -> firSymbol.fir
        is KaFirAnonymousObjectSymbol -> firSymbol.fir
        else -> error(
            "`${this::class.qualifiedName}` needs to be specially handled by the scope provider or is an unknown" +
                    " ${KaSymbolWithDeclarations::class.simpleName} implementation."
        )
    }

                // E.g., project/app/src
                addAll(collectSourceFilePaths(path))
                if (includeDirectoryRoot) {
                    add(path)
                }
            } else {
                // E.g., project/app/src/some/pkg/main.kt
                add(path)
            }
        }
    }
}

/**
 * Collect source file path from the given [root]
 *

              echo "TEMP_MAVEN_BIN_DIR=$maven_bin_dir" >> $GITHUB_ENV
            else
              echo "$maven_bin_dir does not exist."
              exit 1;
            fi
          else
            echo "${{ env.TAR_BALL }} does not exist."
            exit 1;
          fi
        env:
          TAR_BALL: apache-maven/target/apache-maven-bin.tar.gz