args.add("-fPIC");
            }
        }
        if (spec.isDebuggable()) {
            args.add("-g");
        }
        if (spec.isOptimized()) {
            args.add("-O3");
        }
    }

    protected void addIncludeArgs(T spec, List<String> args) {
        if (!needsStandardIncludes(spec.getTargetPlatform())) {
            args.add("-nostdinc");

        }

        @Override
        boolean isDebuggable() {
            throw new UnsupportedOperationException()
        }

        @Override
        boolean isOptimized() {
            throw new UnsupportedOperationException()
        }

        @Override
        TargetMachine getTargetMachine() {
            throw new UnsupportedOperationException()
        }

        return debuggable;
    }

    @Override
    public void setDebuggable(boolean debuggable) {
        this.debuggable = debuggable;
    }

    @Override
    public boolean isOptimized() {
        return optimized;
    }

    @Override
    public void setOptimized(boolean optimized) {
        this.optimized = optimized;
    }

    @Override

        }
        if (runtimeVariant !=null) {
            variants.add(runtimeVariant);
        }
    }

    public boolean isDebuggable() {
        return debuggable;
    }

    public boolean isOptimized() {
        return optimized;
    }

    public TargetMachine getTargetMachine() {
        return targetMachine;
    }

    public Linkage getLinkage() {
        return linkage;
    }

        spec.setMacros(getMacros());
        spec.args(getCompilerArgs().get());
        spec.setPositionIndependentCode(isPositionIndependentCode());
        spec.setDebuggable(isDebuggable());
        spec.setOptimized(isOptimized());
        spec.setIncrementalCompile(inputs.isIncremental());
        spec.setOperationLogger(operationLogger);

        configureSpec(spec);

    }

    @Override
    public String getVisualStudioConfigurationName() {
        // TODO: this is terrible
        String buildType = "debug";
        if (getBinary().isOptimized()) {
            buildType = "release";
        }

                task.getSource().from(binary.getSwiftSource());
                task.getDebuggable().set(binary.isDebuggable());
                task.getOptimized().set(binary.isOptimized());
                if (binary.isTestable()) {
                    task.getCompilerArgs().add("-enable-testing");
                }
                if (binary.getTargetMachine().getOperatingSystemFamily().isMacOs()) {

                task.source(binary.getCppSource());
                if (binary.isDebuggable()) {
                    task.setDebuggable(true);
                }
                if (binary.isOptimized()) {
                    task.setOptimized(true);
                }
                task.getTargetPlatform().set(binary.getNativePlatform());
                task.getToolChain().set(binary.getToolChain());

            getName() >> "debug"
            getTargetMachine() >> targetMachine(OperatingSystemFamily.WINDOWS, MachineArchitecture.X86_64)
            isDebuggable() >> true
            isOptimized() >> false
        }
    }

    private TargetMachine targetMachine(String os, String arch) {
        def objectFactory = TestUtil.objectFactory()
        return Stub(TargetMachine) {

            }

            private Stream<CppBinary> getDebugStream() {
                return library.getBinaries().get().stream().filter(binary -> !binary.isOptimized());
            }

            private Stream<CppBinary> getDebugSharedStream() {
                return getDebugStream().filter(CppSharedLibrary.class::isInstance);
            }