@Override
        public <S> S fromState(Class<S> type, Object state) {
            if (!type.isAssignableFrom(PUBLIC_TYPE)) {
                return null;
            }
            // TODO - should preserve the property type (which may be different to the provider type)
            ProviderInternal<S> provider = Cast.uncheckedNonnullCast(state);
            return type.cast(propertyOf(provider.getType(), provider));
        }

    private final multiply = new SwiftMultiply()
    private final main = new SwiftMain(greeter, sum)

    final List<IncrementalElement.Transform> incrementalChanges = [
        preserve(greeter),
        rename(sum),
        delete(multiply),
        preserve(main)
    ]
    final String expectedOutput = main.expectedOutput
    final String expectedAlternateOutput = main.expectedOutput
    final String moduleName = "App"

  }

  std::vector<string> output_tensor_names;
  output_tensor_names.reserve(fetch_outputs.size());
  for (auto const& output : fetch_outputs) {
    output_tensor_names.push_back(output.name());
  }
  std::vector<string> target_node_names;
  target_node_names.reserve(run_outputs.size());
  for (auto const& output : run_outputs) {
    target_node_names.push_back(output.node()->name());

    private final main = new SwiftMain(greeter, sum)
    private final alternateMain = new SwiftAlternateMain(greeter)

    final List<IncrementalElement.Transform> incrementalChanges = [
        preserve(greeter), preserve(sum), modify(main, alternateMain)]
    final String expectedOutput = main.expectedOutput
    final String expectedAlternateOutput = alternateMain.expectedOutput
    final String moduleName = "App"

        final greeter = new SwiftGreeter()
        final sum = new SwiftSum()

        final String moduleName = "Greeter"
        final List<IncrementalElement.Transform> incrementalChanges = [preserve(greeter), preserve(sum)]
    }

    class IncrementalSwiftAppWithDep extends IncrementalSwiftElement implements AppElement {
        final SwiftMain main

        IncrementalSwiftAppWithDep(IncrementalSwiftLib library) {

rootProject.name = 'preserve-order'...

include("root-build")

// Shared information about external modules
include("dependency-modules")

// Special purpose build logic for root project - please preserve alphabetical order
include("cleanup")
include("idea")
include("lifecycle")

// Special purpose build logic for subproject - please preserve alphabetical order
include("binary-compatibility")
include("build-init-samples")
include("buildquality")
include("documentation")

        final alternateGreeter = new SwiftAlternateGreeter()

        final String moduleName = "Greeter"
        final List<IncrementalElement.Transform> incrementalChanges = [modify(greeter, alternateGreeter), preserve(sum)]

        @Override
        int sum(int a, int b) {
            return sum.sum(a, b)
        }
    }

    class IncrementalSwiftAppWithDep extends IncrementalSwiftApp {
        final SwiftMain main

  SmallVector<Value, 4> operands;
  operands.reserve(operands_size);
  operands.append(while_op.getOperands().begin(), while_op.getOperands().end());
  operands.append(extra_operands.begin(), extra_operands.end());
  SmallVector<Type, 4> new_types;
  new_types.reserve(operands_size);
  new_types.append(while_op.getResultTypes().begin(),

        writeFile(value.file)
        IvyArtifactNameSerializer.INSTANCE.write(this, value.artifactName)
        // TODO - preserve the artifact id implementation instead of unpacking the component id
        componentIdSerializer.write(this, value.id.componentIdentifier)
        // TODO - preserve the artifact's owner id (or get rid of it as it's not used for transforms)
    }