return (Class<T>) fieldType;
    }

    @Override
    public boolean isPublic() {
        return FieldUtil.isPublicField(field);
    }

    @Override
    public boolean isStatic() {
        return !FieldUtil.isInstanceField(field);
    }

    @Override
    public boolean isFinal() {
        return FieldUtil.isFinalField(field);
    }

    @Override

     */
    public static boolean isAbstract(final int modifier) {
        return Modifier.isAbstract(modifier);
    }

    /**
     * <code>static</code>かどうか返します。
     *
     * @param modifier
     *            モディファイヤ
     * @return <code>static</code>なら{@literal true}
     */
    public static boolean isStatic(final int modifier) {
        return Modifier.isStatic(modifier);

 * non-static scopes.
 */
internal class FirNonStaticMembersScope(
    private val delegate: FirContainingNamesAwareScope,
) : FirCallableFilteringScope(delegate) {
    override fun isTargetCallable(callable: FirCallableSymbol<*>): Boolean = !callable.fir.isStatic

    override fun processDeclaredConstructors(processor: (FirConstructorSymbol) -> Unit) {

 * governing permissions and limitations under the License.
 */
package org.codelibs.core.beans.impl;

import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertThat;

import org.codelibs.core.beans.BeanDesc;
import org.codelibs.core.beans.MethodDesc;

        super.getCallableSymbols(nameFilter).filter { symbol ->
            when (symbol) {
                is KtFunctionSymbol -> !symbol.isStatic
                is KtPropertySymbol -> !symbol.isStatic
                else -> true
            }
        }
    }
}

internal class KtFe10ScopeImporting(
    override val scope: ImportingScope,

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SourceMetaDataVisitor extends VoidVisitorAdapter<ClassMetaDataRepository<ClassMetaData>> {
    private static final Pattern GETTER_METHOD_NAME = Pattern.compile("(get|is)(.+)");
    private static final Pattern SETTER_METHOD_NAME = Pattern.compile("set(.+)");
    private final List<ClassMetaData> allClasses = new ArrayList<ClassMetaData>();

    internal
    val isIncubating: Boolean
        get() = owner.isIncubating || delegate.visibleAnnotations.has(incubatingAnnotationTypeDescriptor)

    internal
    val isStatic: Boolean =
        delegate.access.isStatic

    val typeParameters: List<ApiTypeUsage> by unsafeLazy {
        context.apiTypeParametersFor(visitedSignature)
    }

    val parameters: List<ApiFunctionParameter> by unsafeLazy {

		return "", obj.ABI0, false
	}
	name = p.qualifySymbol(name)
	// Parse optional <> (indicates a static symbol) or
	// <ABIxxx> (selecting text symbol with specific ABI).
	noErrMsg := false
	isStatic, abi := p.symRefAttrs(name, noErrMsg)
	if isStatic {
		return "", obj.ABI0, false // This function rejects static symbols.
	}
	tok = p.next()
	if tok.ScanToken == '+' {
		if p.next().ScanToken != scanner.Int {

        return (Class<T>) returnType;
    }

    @Override
    public boolean isPublic() {
        return MethodUtil.isPublic(method);
    }

    @Override
    public boolean isStatic() {
        return MethodUtil.isStatic(method);
    }

    @Override
    public boolean isFinal() {
        return MethodUtil.isFinal(method);
    }

    @Override
    public boolean isAbstract() {

 */

package com.google.common.collect;

import static com.google.common.collect.Lists.transform;
import static com.google.common.collect.Sets.difference;
import static com.google.common.collect.Sets.newHashSet;
import static java.lang.reflect.Modifier.isPublic;
import static java.lang.reflect.Modifier.isStatic;
import static org.junit.Assert.assertThrows;

import com.google.common.base.Function;