return "service scopes " + join(", ", scopes, new InternalTransformer<String, Class<? extends Scope>>() {
            @Override
            public String transform(Class<? extends Scope> aClass) {
                return "'" + aClass.getSimpleName() + "'";
            }
        });
    }

    @Nullable
    private static Class<? extends Scope>[] scopeOf(Class<?> serviceType) {

	a1 := int(p.Optab)
	if a1 != 0 {
		return &optab[a1-1]
	}
	a1 = int(p.From.Class)
	if a1 == 0 {
		a1 = c.aclass(&p.From) + 1
		p.From.Class = int8(a1)
	}

	a1--
	a3 := int(p.To.Class)
	if a3 == 0 {
		a3 = c.aclass(&p.To) + 1
		p.To.Class = int8(a3)
	}

	a3--
	a2 := C_NONE
	if p.Reg != 0 {
		switch {

        this.classInfos = cacheFactory.newClassCache();
    }

    @Override
    public TaskClassInfo getTaskClassInfo(Class<? extends Task> type) {
        return classInfos.get(type, aClass -> createTaskClassInfo(aClass.asSubclass(Task.class)));
    }

    private static TaskClassInfo createTaskClassInfo(Class<? extends Task> type) {
        boolean cacheable = type.isAnnotationPresent(CacheableTask.class);

            @Override
            public Class<T> transform(T original) {
                @SuppressWarnings("unchecked")
                Class<T> aClass = (Class<T>) original.getClass();
                return aClass;
            }
        };
    }

    public static <R> Transformer<R, Object> toTransformer(final Factory<R> factory) {
        return new Transformer<R, Object>() {

            Runner runner = allExceptIgnoredTestRunnerBuilder.runnerForClass(testClass);
            if (runner == null) {
                // Fall back to default runner
                runner = Request.aClass(testClass).getRunner();
            }
            return runner;
        } catch (NoClassDefFoundError e) {
            return getRunnerLegacy(testClass);
        } catch (NoSuchMethodError e) {

            verifyJUnitCategorySupport();
            filters.add(new CategoryFilter(spec.getIncludeCategories(), spec.getExcludeCategories(), applicationClassLoader));
        }

        Request request = Request.aClass(testClass);
        Runner runner = request.getRunner();

        TestFilterSpec filterSpec = spec.getFilter();
        if (!filterSpec.getIncludedTests().isEmpty()

    def "does not attempt to re-compile module-info.java if the file does not exist"() {
        def aClass = file("src/main/java/foo/Foo.java") << """
            package foo;
            public class Foo {
                String v = "value1";
            }
        """
        run language.compileTaskName
        aClass.text = aClass.text.replace('1', '2')
        run language.compileTaskName, '-d'

        expect:

		case int:
			expect = []int{tst.output.(int), tst.output.(int), tst.output.(int), tst.output.(int)}
		}
		for i := range ctxts {
			if output := ctxts[i].aclass(&tst.arg); output != expect[i] {
				t.Errorf("%s.aclass(%v) = %v, expected %v\n", name[i], tst.arg, DRconv(output), DRconv(expect[i]))
			}
		}
	}
}

// The optab size should remain constant when reinitializing the PPC64 assembler backend.

	DISP12 = 4096
	DISP16 = 65536
	DISP20 = 1048576
)

const (
	// mark flags
	LEAF = 1 << iota
	BRANCH
	USETMP // generated code of this Prog uses REGTMP
)

const ( // comments from func aclass in asmz.go
	C_NONE     = iota
	C_REG      // general-purpose register (64-bit)
	C_FREG     // floating-point register (64-bit)
	C_VREG     // vector register (128-bit)
	C_AREG     // access register (32-bit)

	}

	a1 := int(p.Optab)
	if a1 != 0 {
		return &optab[a1-1]
	}
	a1 = int(p.From.Class)
	if a1 == 0 {
		a1 = c.aclass(&p.From) + 1
		p.From.Class = int8(a1)
	}

	a1--
	a3 := int(p.To.Class)
	if a3 == 0 {
		a3 = c.aclass(&p.To) + 1
		p.To.Class = int8(a3)
	}

	a3--
	a2 := C_NONE
	if p.Reg != obj.REG_NONE {
		a2 = C_REG
	}