try {
                ClassGenerator.SerializationConstructor<?> constructor = constructorCache.get(implType, () -> classGenerator.generate(implType).getSerializationConstructor(baseClass));
                return implType.cast(constructor.newInstance(services, nestedGenerator));
            } catch (InvocationTargetException e) {

                } else {
                    return type.getEnclosingClass();
                }
            }

            @Override
            public SerializationConstructor<T> getSerializationConstructor(Class<? super T> baseClass) {
                throw new UnsupportedOperationException();
            }

            @Override
            public List<GeneratedConstructor<T>> getConstructors() {

        /**
         * Creates a serialization constructor. Note: this can be expensive and does not perform any caching.
         */
        SerializationConstructor<T> getSerializationConstructor(Class<? super T> baseClass);
    }

    interface SerializationConstructor<T> {
        /**

        def nested = Stub(InstanceGenerator)
        _ * nested.newInstanceWithDisplayName(_, _, _) >> { type, name, params -> create(type) }
        return generator.generate(clazz).getSerializationConstructor(Object).newInstance(defaultServices(), nested)
    }

    protected <T> T create(Class<T> clazz, Object... args) {
        return doCreate(generator, clazz, defaultServices(), null, args)
    }

        @Override
        public List<GeneratedConstructor<Object>> getConstructors() {
            return constructors;
        }

        @Override
        public SerializationConstructor<Object> getSerializationConstructor(Class<? super Object> baseClass) {
            return new SerializationConstructorImpl(baseClass);
        }

        private class SerializationConstructorImpl implements SerializationConstructor<Object> {