dev/core/src/com/google/gwt/dev/CompilerContext.java

/*
 * Copyright 2013 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.gwt.dev;

import com.google.gwt.dev.cfg.ModuleDef;
import com.google.gwt.dev.javac.CompilationErrorsIndex;
import com.google.gwt.dev.javac.CompilationErrorsIndexImpl;
import com.google.gwt.dev.javac.MemoryUnitCache;
import com.google.gwt.dev.javac.UnitCache;
import com.google.gwt.dev.resource.ResourceOracle;

/**
 * Contains most global read-only compiler state and makes it easily accessible to the far flung
 * reaches of the compiler call graph without the constant accumulation of more and more function
 * parameters.
 */
public class CompilerContext {

  /**
   * CompilerContext builder.
   */
  public static class Builder {

    private ResourceOracle buildResourceOracle;
    private CompilationErrorsIndex compilationErrorsIndex;
    private MinimalRebuildCache minimalRebuildCache = new MinimalRebuildCache();
    private ModuleDef module;
    private PrecompileTaskOptions options = new PrecompileTaskOptionsImpl();
    private ResourceOracle publicResourceOracle;
    private ResourceOracle sourceResourceOracle;
    private UnitCache unitCache = new MemoryUnitCache();

    public CompilerContext build() {
      if (options != null && module != null) {
        module.getProperties().setProperties(options.getProperties());
      }
      initializeResourceOracles();
      initializeCompilationErrorIndexes();

      CompilerContext compilerContext = new CompilerContext();
      compilerContext.buildResourceOracle = buildResourceOracle;
      compilerContext.minimalRebuildCache = minimalRebuildCache;
      compilerContext.module = module;
      compilerContext.options = options;
      compilerContext.publicResourceOracle = publicResourceOracle;
      compilerContext.sourceResourceOracle = sourceResourceOracle;
      compilerContext.compilationErrorsIndex = compilationErrorsIndex;
      compilerContext.unitCache = unitCache;
      return compilerContext;
    }

    public Builder minimalRebuildCache(MinimalRebuildCache minimalRebuildCache) {
      assert minimalRebuildCache != null;
      this.minimalRebuildCache = minimalRebuildCache;
      return this;
    }

    /**
     * Sets the module and uses it to set resource oracles as well.
     */
    public Builder module(ModuleDef module) {
      this.module = module;
      return this;
    }

    public Builder options(PrecompileTaskOptions options) {
      this.options = options;
      return this;
    }

    public Builder unitCache(UnitCache unitCache) {
      this.unitCache = unitCache;
      return this;
    }

    private void initializeCompilationErrorIndexes() {
      compilationErrorsIndex = new CompilationErrorsIndexImpl();
    }

    /**
     * Initialize source, build, and public resource oracles using the most complete currently
     * available moduleDef.<br />
     *
     * There will likely only be a moduleDef available. That will result in sourcing resource
     * oracles only from it, which is what monolithic compilation expects.
     */
    private void initializeResourceOracles() {
      if (module != null) {
        sourceResourceOracle = module.getSourceResourceOracle();
        buildResourceOracle = module.getBuildResourceOracle();
        publicResourceOracle = module.getPublicResourceOracle();
      } else {
        sourceResourceOracle = null;
        buildResourceOracle = null;
        publicResourceOracle = null;
      }
    }
  }

  private ResourceOracle buildResourceOracle;
  private CompilationErrorsIndex compilationErrorsIndex = new CompilationErrorsIndexImpl();
  private MinimalRebuildCache minimalRebuildCache = new MinimalRebuildCache();
  private ModuleDef module;
  // TODO(stalcup): split this into module parsing, precompilation, compilation, and linking option
  // sets.
  private PrecompileTaskOptions options = new PrecompileTaskOptionsImpl();

  private ResourceOracle publicResourceOracle;
  private ResourceOracle sourceResourceOracle;
  private UnitCache unitCache = new MemoryUnitCache();
  public ResourceOracle getBuildResourceOracle() {
    return buildResourceOracle;
  }

  /**
   * Returns the mutable index of compilation errors for the current compile.
   */
  public CompilationErrorsIndex getCompilationErrorsIndex() {
    return compilationErrorsIndex;
  }

  public MinimalRebuildCache getMinimalRebuildCache() {
    return minimalRebuildCache;
  }

  public ModuleDef getModule() {
    return module;
  }

  public PrecompileTaskOptions getOptions() {
    return options;
  }

  public ResourceOracle getPublicResourceOracle() {
    return publicResourceOracle;
  }

  public ResourceOracle getSourceResourceOracle() {
    return sourceResourceOracle;
  }

  public UnitCache getUnitCache() {
    return unitCache;
  }
}