// as it provides access to the TAC module.
template <typename T>
class TacPass : public OperationPass<T> {
 public:
  using OperationPass<T>::OperationPass;
  explicit TacPass(const TacModule* module)
      : OperationPass<T>::OperationPass(mlir::TypeID::get<T>()),
        module_(module) {}

  ~TacPass() override = default;

  const TargetHardware* GetTargetHardware(

        }

        private CacheEntry fetchNext(WeaklyClassReferencingCache cur, Class<?> aClass) {
            CacheEntry last;
            last = cur.get(aClass);
            if (last == null) {
                last = new CacheEntry();
                cur.put(aClass, last);
            }
            return last;
        }
    }

    private class CacheEntry {

            Assert.fail()
        } catch (ClassNotFoundException) {
            // expected
        }
    }

    ClassLoader filter(Class<?> aClass) {
        def spec = new FilteringClassLoader.Spec()
        spec.allowClass(aClass)
        return new FilteringClassLoader(aClass.classLoader, spec)
    }

    ClassLoader isolated(ClassLoader parent = ClassLoader.systemClassLoader.parent, Class<?>... classes) {

    @Override
    protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException {
        Class<?> aClass = readClass();
        ObjectStreamClass descriptor = ObjectStreamClass.lookupAny(aClass);
        if (descriptor == null) {
            throw new ClassNotFoundException(aClass.getName());
        }
        return descriptor;
    }

    @Override

    static String format(Type type) {
        if (type instanceof Class) {
            Class<?> aClass = (Class) type;
            Class<?> enclosingClass = aClass.getEnclosingClass();
            if (enclosingClass != null) {
                return format(enclosingClass) + "$" + aClass.getSimpleName();
            } else {
                return aClass.getSimpleName();
            }
        } else if (type instanceof ParameterizedType) {

        run ":impl:compileGroovy"

        when:
        aClass.text = "class A { void m1() {}; void m2() {}; }"
        eClass.text = "class E { boolean isCacheEnabled = D.cache; garbage }"

        then:
        runAndFail ":impl:compileGroovy"

        when:
        impl.snapshot {
            aClass.text = "class A { void m1() {}; void m2() {}; }"

        analyze(SomeSourceAnnotation).privateClassDependencies.isEmpty()
        analyze(SomeSourceAnnotation).dependencyToAllReason
    }

    InputStream classStream(Class aClass) {
        aClass.classLoader.getResourceAsStream(aClass.getName().replace(".", "/") + ".class")
    }

            SecurityManager securityManager;
            try {
                Class<?> aClass = systemClassLoader.loadClass(securityManagerType);
                securityManager = (SecurityManager) JavaReflectionUtil.newInstance(aClass);
            } catch (Exception e) {

                        implementation project(':library')
                    }
                }
            """.stripIndent()
        }
        file("app/src/main/${language.name}/AClass.${language.name}") << 'public class AClass { }'
    }

    String getAppCompileTask(CompiledLanguage language = CompiledLanguage.JAVA) {
        ":app:${language.compileTaskName}"
    }

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

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