private final CompilationState finalState;
    private final List<File> recompile;
    private final List<File> removed;
    private final Set<File> existingHeaders;
    private final boolean macroIncludesUsedInSources;

    public DefaultIncrementalCompilation(CompilationState finalState, List<File> recompile, List<File> removed, Set<File> existingHeaders, boolean macroIncludesUsedInSources) {

       * successfully changed and the result is available.
       */
      @Override
      protected boolean tryReleaseShared(int finalState) {
        setState(finalState);
        return true;
      }

      /**
       * Blocks until the task is complete or the timeout expires. Throws a {@link TimeoutException}

       * successfully changed and the result is available.
       */
      @Override
      protected boolean tryReleaseShared(int finalState) {
        setState(finalState);
        return true;
      }

      /**
       * Blocks until the task is complete or the timeout expires. Throws a {@link TimeoutException}

    public abstract boolean shouldFinalize(Describable displayName, @Nullable ModelObject producer);

    /**
     * Returns the state to replace this state once is finalized.
     */
    public abstract ValueState<S> finalState();

    /**
     * Sets a new convention value, replacing the existing one if set.
     *
     * @param convention the new convention value
     */
    public abstract void setConvention(S convention);

        modifiedFiles.clear()
        true
    }

    def getState() {
        def incrementalState = incrementalCompileProcessor.processSourceFiles(sourceFiles)
        stateCache.set(incrementalState.finalState)
        return incrementalState
    }

    def sourceFile(def name) {
        tmpDir.createFile(name) << name
    }

    class DummyObjectHolder implements ObjectHolder<CompilationState> {

            } else {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }
        state = state.finalState();
    }

    /**
     * Returns the current value of this property, if explicitly defined, otherwise the given default. Does not apply the convention.
     */
    protected S getExplicitValue(S defaultValue) {

            finalizeNow();
        }
    }

    private void finalizeNow() {
        calculateFinalizedValue();
        valueState = valueState.finalState();
    }

    public boolean isFinalizing() {
        return valueState.isFinalizing();
    }

    @Override
    public void disallowChanges() {
        valueState.disallowChanges();
    }

func (g *GoroutineSummary) finalize(lastTs Time, trigger *Event) {
	if trigger != nil {
		g.EndTime = trigger.Time()
	}
	finalStat := g.snapshotStat(lastTs)

	g.GoroutineExecStats = finalStat

	// System goroutines are never part of regions, even though they
	// "inherit" a task due to creation (EvGoCreate) from within a region.