private InterceptScope(CallType callType) {
        this.callType = callType;
    }

    /**
     * The returned scope includes calls to all constructors of class {@code constructorClass}.
     *
     * @param constructorClass the class whose constructors are to be intercepted
     * @return the scope object
     */
    public static InterceptScope constructorsOf(Class<?> constructorClass) {

        InterceptScope.readsOfPropertiesNamed("property1") | InterceptScope.readsOfPropertiesNamed("property2")
        InterceptScope.methodsNamed("method1")             | InterceptScope.methodsNamed("method2")
    }

    def "method and property scopes with the same name are not equal"() {
        when:
        InterceptScope methodScope = InterceptScope.methodsNamed("name")

        switch (callType) {
            case "invoke":
                maybeApplyInterceptor(ccs, caller, flags, interceptors.get(InterceptScope.methodsNamed(name)));
                break;
            case "getProperty":
                maybeApplyInterceptor(ccs, caller, flags, interceptors.get(InterceptScope.readsOfPropertiesNamed(name)));
                break;
            case "init":

            throw new GradleException("Failed to set up an interceptor method", e);
        }
    }

    private final Set<InterceptScope> interceptScopes;

    protected AbstractCallInterceptor(InterceptScope... interceptScopes) {
        this.interceptScopes = ImmutableSet.copyOf(interceptScopes);
    }

    @Override

        public SystemGetPropertiesInterceptor() {
            super(System.class,
                InterceptScope.readsOfPropertiesNamed("properties"),
                InterceptScope.methodsNamed("getProperties"));
        }

        @Override
        protected Object interceptSafe(Invocation invocation, String consumer) throws Throwable {

import org.gradle.internal.classpath.intercept.CallInterceptorResolver;
import org.gradle.internal.classpath.intercept.CallInterceptorResolver.ClosureCallInterceptorResolver;
import org.gradle.internal.classpath.intercept.InterceptScope;
import org.gradle.internal.instrumentation.api.annotations.CallableKind;
import org.gradle.internal.instrumentation.api.annotations.InterceptJvmCalls;

        if (matchedCaller != null) {
            InterceptScope scope =
                kind == INVOKE_METHOD ? InterceptScope.methodsNamed(name) :
                    kind == GET_PROPERTY ? InterceptScope.readsOfPropertiesNamed(name) :
                        kind == SET_PROPERTY ? InterceptScope.writesOfPropertiesNamed(name) :
                            null;
            if (scope == null) {

import static org.gradle.internal.classpath.intercept.CallInterceptorRegistry.getGroovyCallDecorator;

@NonNullApi
public interface CallInterceptorResolver {

    @Nullable
    CallInterceptor resolveCallInterceptor(InterceptScope scope);

    boolean isAwareOfCallSiteName(String name);

    @NonNullApi
    final class ClosureCallInterceptorResolver implements CallInterceptorResolver {

 * as a scope already guarantees that the invocation would have the given class object as the receiver.
 */
public abstract class ClassBoundCallInterceptor extends AbstractCallInterceptor {
    private final Class<?> expectedReceiver;

    public ClassBoundCallInterceptor(Class<?> expectedReceiver, InterceptScope... scopes) {
        super(scopes);

            public Object callOriginal() throws Throwable {
                return second.intercept(invocation, consumer);
            }
        }, consumer);
    }

    @Override
    public Set<InterceptScope> getInterceptScopes() {
        return Sets.union(first.getInterceptScopes(), second.getInterceptScopes());
    }

    @Nullable
    @Override
    public Class<?> matchesProperty(Class<?> receiverClass) {