* @return requires a project
     */
    boolean projectRequired() default true;

    /**
     * if the Mojo uses the Maven project and its child modules.
     * @return uses the Maven project and its child modules
     */
    boolean aggregator() default false;

    /**
     * does this Mojo need to be online to be executed?
     * @return need to be online
     */

            patternSet.copyFrom(patterns);
            return patternSet;
        });
    }

    @Override
    public FileTree visit(FileVisitor visitor) {
        visitContentsAsFileTrees(child -> child.visit(visitor));
        return this;
    }

    @Override
    public void visitContentsAsFileTrees(Consumer<FileTreeInternal> visitor) {
        visitContents(new FileCollectionStructureVisitor() {

 * these proxies to have richer behaviour than just implementing the base interface.
 * <p>
 * For example. Let's say the TAPI model interface is {@code Animal}, but which also
 * has child interfaces such as {@code Dog}, {@code Cat}, {@code Bird}. When we
 * request a model typed as {@code Animal} on the TAPI client side, we will get
 * a Java dynamic proxy, on which we can call any method from the {@code Animal}

        setContentView(10);
    }

    public void setContentView(@Anno({"UnknownNullness", "MissingNullability"}) int id) {
    }
}

// MODULE: main(lib, lib2)
// FILE: main.kt
import p2.Parent

class Child: Parent() {
    override fun onCreate() {
        super.onCreate()
        bar()
    }

    private fun bar() {}

        DefaultResolvedDependency child = new DefaultResolvedDependency("someChildConfiguration", newId("someGroup", "someChild", "someVersion"), buildOperationProcessor)
        resolvedDependency.addChild(child)

        Set<ResolvedArtifact> childParent1SpecificArtifacts = newHashSet(createArtifact("childParent1Specific"))
        createAndAddParent("childParent1", child, childParent1SpecificArtifacts)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.process.internal.worker.child;

import org.gradle.process.internal.health.memory.JvmMemoryStatus;

public interface WorkerJvmMemoryInfoProtocol {
    void sendJvmMemoryStatus(JvmMemoryStatus jvmMemoryStatus);

    class ExternalizableBeanContainingSerializable(value: Int = 0, var child: Pair<Int, String>? = null) : ExternalizableBean(value) {
        override fun writeExternal(out: ObjectOutput) {
            super.writeExternal(out)
            out.writeObject(child)
        }

        override fun readExternal(`in`: ObjectInput) {
            value = `in`.readInt()
            child = `in`.readObject().uncheckedCast()
        }
    }

import org.gradle.process.internal.health.memory.MemoryManager;
import org.gradle.process.internal.worker.child.ApplicationClassesInSystemClassLoaderWorkerImplementationFactory;
import org.gradle.process.internal.worker.child.WorkerJvmMemoryInfoProtocol;
import org.gradle.process.internal.worker.child.WorkerLoggingProtocol;
import org.gradle.util.internal.GUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

                .run()
        }

        then:
        events.assertIsABuild()

        def configureBuild = events.operation("Configure build")

        def applyRootBuildScript = configureBuild.child("Configure project :").child(applyRootProjectBuildScript())

        def resolveCompileDependencies = events.operation("Resolve dependencies :compileClasspath", "Resolve dependencies of :compileClasspath")

  fileline->set_filename(loc.getFilename().str());
  fileline->set_line(loc.getLine());
  fileline->set_column(loc.getColumn());
}

// Defines a child class of Location to access its protected members.
class LocationExtractor : public Location {
 public:
  explicit LocationExtractor(const Location& loc) : Location(loc) {}