declareClass(visitor, interfacesToImplement, generatedType, superclassType);
        declareStateField(visitor);
        declareTypeConverterField(visitor);
        declareManagedTypeField(visitor);
        declareCanCallSettersField(visitor);
        writeStaticConstructor(visitor, generatedType, viewClass);

            }
            if (needGroovyObject) {
                visitor.mixInGroovyObject();
            }
            visitor.addDynamicMethods();
            addMissingClosureOverloads(visitor);
            addSetMethods(visitor);
        }

        private void addSetMethods(AbstractClassGenerator.ClassGenerationVisitor visitor) {
            for (PropertyMetadata property : mutableProperties) {

        }

        @Override
        public Visitor getAll(Class<?> serviceType, ServiceProvider.Visitor visitor) {
            for (ServiceProvider serviceProvider : getProviders(serviceType)) {
                visitor = serviceProvider.getAll(serviceType, visitor);
            }
            return visitor;
        }

        @Override
        public void stop() {

        when:
        collection.visitStructure(visitor)

        then:
        1 * visitor.startVisit(_, collection) >> true
        1 * fileResolver.resolve("file") >> file
        1 * visitor.startVisit(_, _) >> true
        1 * visitor.visitCollection(_, { it.toList() == [file] })
        1 * fileCollectionMock.visitStructure(visitor)
        0 * visitor._
    }

    def "resolves path to file when finalized"() {

            }
            return serviceFor(factory)
        }

        @Override
        Visitor getAll(Class<?> serviceType, Visitor visitor) {
            parentServices.getAll(serviceType).forEach {
                visitor.visit(serviceFor(it))
            }
            return visitor
        }

        @Override
        void stop() {
            throw new UnsupportedOperationException()

        Stub(SelectedArtifactSet) {
            visitFiles(_, _) >> { ResolvedFileVisitor visitor, boolean l ->
                files.each {
                    visitor.visitFile(it)
                }
                visitor.endVisitCollection(null)
            }
        }
    }

    private SelectedArtifactSet selectedArtifacts(Throwable failure) {

                    addPlatformEdges(discoveredEdges, platformId, cs);
                    visitor.markNotPending(platformId.getModuleIdentifier());
                }
            }
            visitor.complete();
        }
    }

    @Override
    public Iterator<File> iterator() {
        return getIntrinsicFiles().iterator();
    }

    @Override
    protected void visitContents(FileCollectionStructureVisitor visitor) {
        getIntrinsicFiles().visitStructure(visitor);
    }

    @Override
    protected void appendContents(TreeFormatter formatter) {
        formatter.node("configuration: " + identityPath);
    }

    /**

        void visitPreExecutionNodes(Consumer<? super Node> visitor) {
            for (final node in preExecuteNodes) {
                visitor.accept(node)
            }
            preExecuteNodes.clear()
        }

        @Override
        void visitPostExecutionNodes(Consumer<? super Node> visitor) {
            for (final node in postExecuteNodes) {
                visitor.accept(node)
            }
        }