return new ArchCondition<JavaClass>(" override method " + getMethodDescription(name, parameterTypes)) {

            @Override
            public void check(JavaClass javaClass, ConditionEvents events) {
                Optional<JavaMethod> method = getMethodRecursively(javaClass);
                if (method.isPresent()) {
                    JavaClass sourceClass = method.get().getSourceCodeLocation().getSourceClass();

     *
     * <p>
     * When invoked on a property with no value, this method first sets the value
     * of the property to its current convention value, if set, or an empty collection.
     * </p>
     * <p>Even if the given provider has no value, after this method is invoked,
     * the actual value of this property is guaranteed to be present.</p>
     *

     * the lease prior to doing any meaningful work.
     *
     * This method is reentrant so that a thread can call this method from the given action.
     *
     * This method blocks until a worker lease is available.
     */
    <T> T runAsWorkerThread(Factory<T> action);

    /**

    // source: 'fragment.kt'
    public method <init>(): void
    public final static method run(p0: Foo, p1: java.lang.String, p2: kotlin.jvm.internal.Ref$IntRef): void
    public final inner class kotlin/jvm/internal/Ref$IntRef
}

public final class ContextKt

public final class Foo {
    // source: 'context.kt'
    public method <init>(): void

        if (result == null) {
            return null;
        } else {
            return targetClass.cast(result);
        }
    }

    /**
     * Utility method to invoke a method on an object by reflective means.
     *
     * @return the result of the method invocation as an {@link Object}
     * @see #invokeMethod(Object, String, Class) for the generic version of this method
     */
    @Nullable

      }
    };
  }

  @J2ktIncompatible
  @GwtIncompatible // java.lang.reflect
  private static Object invokeAccessibleNonThrowingMethod(
      Method method, Object receiver, Object... params) {
    try {
      return method.invoke(receiver, params);
    } catch (IllegalAccessException e) {
      throw new RuntimeException(e);
    } catch (InvocationTargetException e) {

    public static ParameterizedClassDesc createParameterizedClassDesc(final Method method, final int index,
            final Map<TypeVariable<?>, Type> map) {
        assertArgumentNotNull("method", method);
        assertArgumentArrayIndex("index", index, method.getParameterTypes().length);
        assertArgumentNotNull("map", map);

        return createParameterizedClassDesc(method.getGenericParameterTypes()[index], map);
    }

    /**

// LookupFieldOrMethod looks up a field or method with given package and name
// in T and returns the corresponding *Var or *Func, an index sequence, and a
// bool indicating if there were any pointer indirections on the path to the
// field or method. If addressable is set, T is the type of an addressable
// variable (only matters for method lookups). T must not be nil.
//
// The last index entry is the field or method index in the (possibly embedded)

// LookupFieldOrMethod looks up a field or method with given package and name
// in T and returns the corresponding *Var or *Func, an index sequence, and a
// bool indicating if there were any pointer indirections on the path to the
// field or method. If addressable is set, T is the type of an addressable
// variable (only matters for method lookups). T must not be nil.
//
// The last index entry is the field or method index in the (possibly embedded)

   *       {@code cls}, no test is performed.
   *   <li>Equality test is not performed on method return values unless the method is a non-private
   *       static factory method whose return type is {@code cls} or {@code cls}'s subtype.
   *   <li>Inequality check is not performed against state mutation methods such as {@link
   *       List#add}, or functional update methods such as {@link