com.google.gwt.dev.CompilerContext.java Source code

Introduction

Here is the source code for com.google.gwt.dev.CompilerContext.java

Source

/*
 * 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;
    }
}