src/main/java/com/google/devtools/build/lib/rules/java/JavaTargetAttributes.java - bazel - Git at Google

 // Copyright 2014 The Bazel Authors. All rights reserved.
 //
 // 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.devtools.build.lib.rules.java;

 import com.google.common.base.Predicates;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.devtools.build.lib.actions.Artifact;
 import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
 import com.google.devtools.build.lib.cmdline.Label;
 import com.google.devtools.build.lib.collect.nestedset.NestedSet;
 import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
 import com.google.devtools.build.lib.rules.cpp.CppFileTypes;
 import com.google.devtools.build.lib.util.Preconditions;
 import com.google.devtools.build.lib.vfs.PathFragment;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;

 /**
  * An object that captures the temporary state we need to pass around while
  * the initialization hook for a java rule is running.
  */
 public class JavaTargetAttributes {

   private static void checkJar(Artifact classPathEntry) {
     if (!JavaSemantics.JAR.matches(classPathEntry.getFilename())) {
       throw new IllegalArgumentException(
           "not a jar file: " + classPathEntry.prettyPrint());
     }
   }

   /**
    * A builder class for JavaTargetAttributes.
    */
   public static class Builder {

     // The order of source files is important, and there must not be duplicates.
     // Unfortunately, there is no interface in Java that represents a collection
     // without duplicates that has a stable and deterministic iteration order,
     // but is not sorted according to a property of the elements. Thus we are
     // stuck with Set.
     private final Set<Artifact> sourceFiles = new LinkedHashSet<>();
     private final Set<Artifact> compileTimeJarFiles = new LinkedHashSet<>();

     private final NestedSetBuilder<Artifact> runtimeClassPath =
         NestedSetBuilder.naiveLinkOrder();

     private final NestedSetBuilder<Artifact> compileTimeClassPath =
         NestedSetBuilder.naiveLinkOrder();

     private final List<Artifact> bootClassPath = new ArrayList<>();
     private final List<Artifact> nativeLibraries = new ArrayList<>();

     private final Set<Artifact> processorPath = new LinkedHashSet<>();
     // Classpath directories can't be represented as artifacts (TreeArtifact isn't appropriate
     // here since all we need is a path string to apply to the command line).
     private final Set<PathFragment> processorPathDirs = new LinkedHashSet<>();
     private final Set<String> processorNames = new LinkedHashSet<>();

     private final Set<Artifact> apiGeneratingProcessorPath = new LinkedHashSet<>();
     private final Set<String> apiGeneratingProcessorNames = new LinkedHashSet<>();

     private final Map<PathFragment, Artifact> resources = new LinkedHashMap<>();
     private final NestedSetBuilder<Artifact> resourceJars = NestedSetBuilder.stableOrder();
     private final List<Artifact> messages = new ArrayList<>();
     private final List<Artifact> instrumentationMetadata = new ArrayList<>();
     private final List<Artifact> sourceJars = new ArrayList<>();

     private final List<Artifact> classPathResources = new ArrayList<>();

     private final Set<Artifact> additionalOutputs = new LinkedHashSet<>();

     private BuildConfiguration.StrictDepsMode strictJavaDeps =
         BuildConfiguration.StrictDepsMode.OFF;
     private final NestedSetBuilder<Artifact> directJars = NestedSetBuilder.naiveLinkOrder();
     private final List<Artifact> compileTimeDependencyArtifacts = new ArrayList<>();
     private String ruleKind;
     private Label targetLabel;

     private final NestedSetBuilder<Artifact> excludedArtifacts =
         NestedSetBuilder.naiveLinkOrder();

     private boolean built = false;

     private final JavaSemantics semantics;

     public Builder(JavaSemantics semantics) {
       this.semantics = semantics;
     }

     public Builder addSourceArtifacts(Iterable<Artifact> sourceArtifacts) {
       Preconditions.checkArgument(!built);
       for (Artifact srcArtifact : sourceArtifacts) {
         String srcFilename = srcArtifact.getExecPathString();
         if (JavaSemantics.SOURCE_JAR.matches(srcFilename)) {
           sourceJars.add(srcArtifact);
         } else if (JavaSemantics.PROPERTIES.matches(srcFilename)) {
           // output files of the message compiler
           resources.put(
               semantics.getDefaultJavaResourcePath(srcArtifact.getRootRelativePath()), srcArtifact);
         } else if (JavaSemantics.JAVA_SOURCE.matches(srcFilename)) {
           sourceFiles.add(srcArtifact);
         } else {
           // try specific cases from the semantics.
           semantics.addArtifactToJavaTargetAttribute(this, srcArtifact);
         }
       }
       return this;
     }

     public Builder addSourceFiles(Iterable<Artifact> sourceFiles) {
       Preconditions.checkArgument(!built);
       for (Artifact artifact : sourceFiles) {
         if (JavaSemantics.JAVA_SOURCE.matches(artifact.getFilename())) {
           this.sourceFiles.add(artifact);
         }
       }
       return this;
     }

     public Builder merge(JavaCompilationArgs context) {
       Preconditions.checkArgument(!built);
       addCompileTimeClassPathEntries(context.getCompileTimeJars());
       addRuntimeClassPathEntries(context.getRuntimeJars());
       addInstrumentationMetadataEntries(context.getInstrumentationMetadata());
       return this;
     }

     public Builder addSourceJars(Collection<Artifact> sourceJars) {
       Preconditions.checkArgument(!built);
       this.sourceJars.addAll(sourceJars);
       return this;
     }

     public Builder addSourceJar(Artifact sourceJar) {
       Preconditions.checkArgument(!built);
       this.sourceJars.add(sourceJar);
       return this;
     }

     public Builder addCompileTimeJarFiles(Iterable<Artifact> jars) {
       Preconditions.checkArgument(!built);
       Iterables.addAll(compileTimeJarFiles, jars);
       return this;
     }

     public Builder addRuntimeClassPathEntry(Artifact classPathEntry) {
       Preconditions.checkArgument(!built);
       checkJar(classPathEntry);
       runtimeClassPath.add(classPathEntry);
       return this;
     }

     public Builder addRuntimeClassPathEntries(NestedSet<Artifact> classPathEntries) {
       Preconditions.checkArgument(!built);
       runtimeClassPath.addTransitive(classPathEntries);
       return this;
     }

     public Builder addCompileTimeClassPathEntries(NestedSet<Artifact> entries) {
       Preconditions.checkArgument(!built);
       compileTimeClassPath.addTransitive(entries);
       return this;
     }

     public Builder setRuleKind(String ruleKind) {
       Preconditions.checkArgument(!built);
       this.ruleKind = ruleKind;
       return this;
     }

     public Builder setTargetLabel(Label targetLabel) {
       Preconditions.checkArgument(!built);
       this.targetLabel = targetLabel;
       return this;
     }

     /**
      * Sets the bootclasspath to be passed to the Java compiler.
      *
      * <p>If this method is called, then the bootclasspath specified in this JavaTargetAttributes
      * instance overrides the default bootclasspath.
      */
     public Builder setBootClassPath(List<Artifact> jars) {
       Preconditions.checkArgument(!built);
       Preconditions.checkArgument(!jars.isEmpty());
       Preconditions.checkState(bootClassPath.isEmpty());
       bootClassPath.addAll(jars);
       return this;
     }

     public Builder addExcludedArtifacts(NestedSet<Artifact> toExclude) {
       Preconditions.checkArgument(!built);
       excludedArtifacts.addTransitive(toExclude);
       return this;
     }

     /**
      * Controls how strict the javac compiler will be in checking correct use of
      * direct dependencies.
      *
      * @param strictDeps one of WARN, ERROR or OFF
      */
     public Builder setStrictJavaDeps(BuildConfiguration.StrictDepsMode strictDeps) {
       Preconditions.checkArgument(!built);
       strictJavaDeps = strictDeps;
       return this;
     }

     /**
      * In tandem with strictJavaDeps, directJars represents a subset of the compile-time, classpath
      * jars that were provided by direct dependencies. When strictJavaDeps is OFF, there is no need
      * to provide directJars, and no extra information is passed to javac. When strictJavaDeps is
      * set to WARN or ERROR, the compiler command line will include extra flags to indicate the
      * warning/error policy and to map the classpath jars to direct or transitive dependencies,
      * using the information in directJars. The extra flags are formatted like this (same for
      * --indirect_dependency): <pre>
      * --direct_dependency
      * foo/bar/lib.jar
      * //java/com/google/foo:bar
      * </pre>
      */
     public Builder addDirectJars(NestedSet<Artifact> directJars) {
       Preconditions.checkArgument(!built);
       this.directJars.addTransitive(directJars);
       return this;
     }

     public Builder addCompileTimeDependencyArtifacts(Iterable<Artifact> dependencyArtifacts) {
       Preconditions.checkArgument(!built);
       Iterables.addAll(this.compileTimeDependencyArtifacts, dependencyArtifacts);
       return this;
     }

     public Builder addInstrumentationMetadataEntries(Iterable<Artifact> metadataEntries) {
       Preconditions.checkArgument(!built);
       Iterables.addAll(instrumentationMetadata, metadataEntries);
       return this;
     }

     public Builder addNativeLibrary(Artifact nativeLibrary) {
       Preconditions.checkArgument(!built);
       String name = nativeLibrary.getFilename();
       if (CppFileTypes.INTERFACE_SHARED_LIBRARY.matches(name)) {
         return this;
       }
       if (!(CppFileTypes.SHARED_LIBRARY.matches(name)
           || CppFileTypes.VERSIONED_SHARED_LIBRARY.matches(name))) {
         throw new IllegalArgumentException("not a shared library :" + nativeLibrary.prettyPrint());
       }
       nativeLibraries.add(nativeLibrary);
       return this;
     }

     public Builder addNativeLibraries(Iterable<Artifact> nativeLibraries) {
       Preconditions.checkArgument(!built);
       for (Artifact nativeLibrary : nativeLibraries) {
         addNativeLibrary(nativeLibrary);
       }
       return this;
     }

     public Builder addMessages(Collection<Artifact> messages) {
       Preconditions.checkArgument(!built);
       this.messages.addAll(messages);
       return this;
     }

     public Builder addMessage(Artifact messagesArtifact) {
       Preconditions.checkArgument(!built);
       this.messages.add(messagesArtifact);
       return this;
     }

     public Builder addResource(PathFragment execPath, Artifact resource) {
       Preconditions.checkArgument(!built);
       this.resources.put(execPath, resource);
       return this;
     }

     public Builder addResourceJars(NestedSet<Artifact> resourceJars) {
       Preconditions.checkArgument(!built);
       this.resourceJars.addTransitive(resourceJars);
       return this;
     }

     public Builder addProcessorName(String processor) {
       Preconditions.checkArgument(!built);
       processorNames.add(processor);
       return this;
     }

     public Builder addProcessorPath(Iterable<Artifact> jars) {
       Preconditions.checkArgument(!built);
       Iterables.addAll(processorPath, jars);
       return this;
     }

     public Builder addProcessorPathDir(PathFragment dir) {
       Preconditions.checkArgument(!built);
       processorPathDirs.add(dir);
       return this;
     }

     public Builder addApiGeneratingProcessorName(String processor) {
       Preconditions.checkArgument(!built);
       apiGeneratingProcessorNames.add(processor);
       return this;
     }

     public Builder addApiGeneratingProcessorPath(Iterable<Artifact> jars) {
       Preconditions.checkArgument(!built);
       Iterables.addAll(apiGeneratingProcessorPath, jars);
       return this;
     }

     public Builder addClassPathResources(List<Artifact> classPathResources) {
       Preconditions.checkArgument(!built);
       this.classPathResources.addAll(classPathResources);
       return this;
     }

     public Builder addClassPathResource(Artifact classPathResource) {
       Preconditions.checkArgument(!built);
       this.classPathResources.add(classPathResource);
       return this;
     }

     /**
      * Adds additional outputs to this target's compile action.
      */
     public Builder addAdditionalOutputs(Iterable<Artifact> outputs) {
       Preconditions.checkArgument(!built);
       Iterables.addAll(additionalOutputs, outputs);
       return this;
     }

     public JavaTargetAttributes build() {
       built = true;
       return new JavaTargetAttributes(
           sourceFiles,
           compileTimeJarFiles,
           runtimeClassPath,
           compileTimeClassPath,
           bootClassPath,
           nativeLibraries,
           processorPath,
           processorPathDirs,
           processorNames,
           apiGeneratingProcessorPath,
           apiGeneratingProcessorNames,
           resources,
           resourceJars.build(),
           messages,
           sourceJars,
           classPathResources,
           additionalOutputs,
           directJars.build(),
           compileTimeDependencyArtifacts,
           ruleKind,
           targetLabel,
           excludedArtifacts,
           strictJavaDeps);
     }

     // TODO(bazel-team): Remove these 5 methods.
     @Deprecated
     public Set<Artifact> getSourceFiles() {
       return sourceFiles;
     }

     @Deprecated
     public boolean hasSourceFiles() {
       return !sourceFiles.isEmpty();
     }

     @Deprecated
     public List<Artifact> getInstrumentationMetadata() {
       return instrumentationMetadata;
     }

     @Deprecated
     public boolean hasSourceJars() {
       return !sourceJars.isEmpty();
     }
   }

   //
   // -------------------------- END OF BUILDER CLASS -------------------------
   //

   private final ImmutableSet<Artifact> sourceFiles;
   private final ImmutableSet<Artifact> compileTimeJarFiles;

   private final NestedSet<Artifact> runtimeClassPath;
   private final NestedSet<Artifact> compileTimeClassPath;

   private final ImmutableList<Artifact> bootClassPath;
   private final ImmutableList<Artifact> nativeLibraries;

   private final ImmutableSet<Artifact> processorPath;
   private final ImmutableSet<PathFragment> processorPathDirs;
   private final ImmutableSet<String> processorNames;

   private final ImmutableSet<Artifact> apiGeneratingProcessorPath;
   private final ImmutableSet<String> apiGeneratingProcessorNames;

   private final ImmutableMap<PathFragment, Artifact> resources;
   private final NestedSet<Artifact> resourceJars;

   private final ImmutableList<Artifact> messages;
   private final ImmutableList<Artifact> sourceJars;

   private final ImmutableList<Artifact> classPathResources;

   private final ImmutableSet<Artifact> additionalOutputs;

   private final NestedSet<Artifact> directJars;
   private final ImmutableList<Artifact> compileTimeDependencyArtifacts;
   private final String ruleKind;
   private final Label targetLabel;

   private final NestedSet<Artifact> excludedArtifacts;
   private final BuildConfiguration.StrictDepsMode strictJavaDeps;

   /** Constructor of JavaTargetAttributes. */
   private JavaTargetAttributes(
       Set<Artifact> sourceFiles,
       Set<Artifact> compileTimeJarFiles,
       NestedSetBuilder<Artifact> runtimeClassPath,
       NestedSetBuilder<Artifact> compileTimeClassPath,
       List<Artifact> bootClassPath,
       List<Artifact> nativeLibraries,
       Set<Artifact> processorPath,
       Set<PathFragment> processorPathDirs,
       Set<String> processorNames,
       Set<Artifact> apiGeneratingProcessorPath,
       Set<String> apiGeneratingProcessorNames,
       Map<PathFragment, Artifact> resources,
       NestedSet<Artifact> resourceJars,
       List<Artifact> messages,
       List<Artifact> sourceJars,
       List<Artifact> classPathResources,
       Set<Artifact> additionalOutputs,
       NestedSet<Artifact> directJars,
       List<Artifact> compileTimeDependencyArtifacts,
       String ruleKind,
       Label targetLabel,
       NestedSetBuilder<Artifact> excludedArtifacts,
       BuildConfiguration.StrictDepsMode strictJavaDeps) {
     this.sourceFiles = ImmutableSet.copyOf(sourceFiles);
     this.compileTimeJarFiles = ImmutableSet.copyOf(compileTimeJarFiles);
     this.runtimeClassPath = runtimeClassPath.build();
     this.directJars = directJars;
     this.compileTimeClassPath =
         NestedSetBuilder.<Artifact>naiveLinkOrder()
             .addTransitive(directJars)
             .addTransitive(compileTimeClassPath.build())
             .build();
     this.bootClassPath = ImmutableList.copyOf(bootClassPath);
     this.nativeLibraries = ImmutableList.copyOf(nativeLibraries);
     this.processorPath = ImmutableSet.copyOf(processorPath);
     this.processorPathDirs = ImmutableSet.copyOf(processorPathDirs);
     this.processorNames = ImmutableSet.copyOf(processorNames);
     this.apiGeneratingProcessorPath = ImmutableSet.copyOf(apiGeneratingProcessorPath);
     this.apiGeneratingProcessorNames = ImmutableSet.copyOf(apiGeneratingProcessorNames);
     this.resources = ImmutableMap.copyOf(resources);
     this.resourceJars = resourceJars;
     this.messages = ImmutableList.copyOf(messages);
     this.sourceJars = ImmutableList.copyOf(sourceJars);
     this.classPathResources = ImmutableList.copyOf(classPathResources);
     this.additionalOutputs = ImmutableSet.copyOf(additionalOutputs);
     this.compileTimeDependencyArtifacts = ImmutableList.copyOf(compileTimeDependencyArtifacts);
     this.ruleKind = ruleKind;
     this.targetLabel = targetLabel;
     this.excludedArtifacts = excludedArtifacts.build();
     this.strictJavaDeps = strictJavaDeps;
   }

   public NestedSet<Artifact> getDirectJars() {
     return directJars;
   }

   public List<Artifact> getCompileTimeDependencyArtifacts() {
     return compileTimeDependencyArtifacts;
   }

   public List<Artifact> getSourceJars() {
     return sourceJars;
   }

   public Map<PathFragment, Artifact> getResources() {
     return resources;
   }

   public NestedSet<Artifact> getResourceJars() {
     return resourceJars;
   }

   public List<Artifact> getMessages() {
     return messages;
   }

   public ImmutableList<Artifact> getClassPathResources() {
     return classPathResources;
   }

   public ImmutableSet<Artifact> getAdditionalOutputs() {
     return additionalOutputs;
   }

   private NestedSet<Artifact> getExcludedArtifacts() {
     return excludedArtifacts;
   }

   /**
    * Returns the artifacts needed on the runtime classpath of this target.
    *
    * See also {@link #getRuntimeClassPathForArchive()}.
    */
   public NestedSet<Artifact> getRuntimeClassPath() {
     return runtimeClassPath;
   }

   /**
    * Returns the classpath artifacts needed in a deploy jar for this target.
    *
    * This excludes the artifacts made available by jars in the deployment
    * environment.
    */
   public Iterable<Artifact> getRuntimeClassPathForArchive() {
     Iterable<Artifact> runtimeClasspath = getRuntimeClassPath();

     if (getExcludedArtifacts().isEmpty()) {
       return runtimeClasspath;
     } else {
       return Iterables.filter(runtimeClasspath,
           Predicates.not(Predicates.in(getExcludedArtifacts().toSet())));
     }
   }

   public NestedSet<Artifact> getCompileTimeClassPath() {
     return compileTimeClassPath;
   }

   public ImmutableList<Artifact> getBootClassPath() {
     return bootClassPath;
   }

   public ImmutableSet<Artifact> getProcessorPath() {
     return processorPath;
   }

   public ImmutableSet<PathFragment> getProcessorPathDirs() {
     return processorPathDirs;
   }

   public Collection<Artifact> getApiGeneratingProcessorPath() {
     return apiGeneratingProcessorPath;
   }

   public ImmutableSet<String> getApiGeneratingProcessorNames() {
     return apiGeneratingProcessorNames;
   }

   public Set<Artifact> getSourceFiles() {
     return sourceFiles;
   }

   public Set<Artifact> getCompileTimeJarFiles() {
     return compileTimeJarFiles;
   }

   public List<Artifact> getNativeLibraries() {
     return nativeLibraries;
   }

   public Collection<String> getProcessorNames() {
     return processorNames;
   }

   public boolean hasSourceFiles() {
     return !sourceFiles.isEmpty();
   }

   public boolean hasSourceJars() {
     return !sourceJars.isEmpty();
   }

   public boolean hasResources() {
     return !resources.isEmpty();
   }

   public boolean hasMessages() {
     return !messages.isEmpty();
   }

   public boolean hasClassPathResources() {
     return !classPathResources.isEmpty();
   }

   public String getRuleKind() {
     return ruleKind;
   }

   public Label getTargetLabel() {
     return targetLabel;
   }

   public BuildConfiguration.StrictDepsMode getStrictJavaDeps() {
     return strictJavaDeps;
   }
 }
	// Copyright 2014 The Bazel Authors. All rights reserved.
	//
	// 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.devtools.build.lib.rules.java;

	import com.google.common.base.Predicates;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.ImmutableMap;
	import com.google.common.collect.ImmutableSet;
	import com.google.common.collect.Iterables;
	import com.google.devtools.build.lib.actions.Artifact;
	import com.google.devtools.build.lib.analysis.config.BuildConfiguration;
	import com.google.devtools.build.lib.cmdline.Label;
	import com.google.devtools.build.lib.collect.nestedset.NestedSet;
	import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
	import com.google.devtools.build.lib.rules.cpp.CppFileTypes;
	import com.google.devtools.build.lib.util.Preconditions;
	import com.google.devtools.build.lib.vfs.PathFragment;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.LinkedHashMap;
	import java.util.LinkedHashSet;
	import java.util.List;
	import java.util.Map;
	import java.util.Set;

	/**
	* An object that captures the temporary state we need to pass around while
	* the initialization hook for a java rule is running.
	*/
	public class JavaTargetAttributes {

	private static void checkJar(Artifact classPathEntry) {
	if (!JavaSemantics.JAR.matches(classPathEntry.getFilename())) {
	throw new IllegalArgumentException(
	"not a jar file: " + classPathEntry.prettyPrint());
	}
	}

	/**
	* A builder class for JavaTargetAttributes.
	*/
	public static class Builder {

	// The order of source files is important, and there must not be duplicates.
	// Unfortunately, there is no interface in Java that represents a collection
	// without duplicates that has a stable and deterministic iteration order,
	// but is not sorted according to a property of the elements. Thus we are
	// stuck with Set.
	private final Set<Artifact> sourceFiles = new LinkedHashSet<>();
	private final Set<Artifact> compileTimeJarFiles = new LinkedHashSet<>();

	private final NestedSetBuilder<Artifact> runtimeClassPath =
	NestedSetBuilder.naiveLinkOrder();

	private final NestedSetBuilder<Artifact> compileTimeClassPath =
	NestedSetBuilder.naiveLinkOrder();

	private final List<Artifact> bootClassPath = new ArrayList<>();
	private final List<Artifact> nativeLibraries = new ArrayList<>();

	private final Set<Artifact> processorPath = new LinkedHashSet<>();
	// Classpath directories can't be represented as artifacts (TreeArtifact isn't appropriate
	// here since all we need is a path string to apply to the command line).
	private final Set<PathFragment> processorPathDirs = new LinkedHashSet<>();
	private final Set<String> processorNames = new LinkedHashSet<>();

	private final Set<Artifact> apiGeneratingProcessorPath = new LinkedHashSet<>();
	private final Set<String> apiGeneratingProcessorNames = new LinkedHashSet<>();

	private final Map<PathFragment, Artifact> resources = new LinkedHashMap<>();
	private final NestedSetBuilder<Artifact> resourceJars = NestedSetBuilder.stableOrder();
	private final List<Artifact> messages = new ArrayList<>();
	private final List<Artifact> instrumentationMetadata = new ArrayList<>();
	private final List<Artifact> sourceJars = new ArrayList<>();

	private final List<Artifact> classPathResources = new ArrayList<>();

	private final Set<Artifact> additionalOutputs = new LinkedHashSet<>();

	private BuildConfiguration.StrictDepsMode strictJavaDeps =
	BuildConfiguration.StrictDepsMode.OFF;
	private final NestedSetBuilder<Artifact> directJars = NestedSetBuilder.naiveLinkOrder();
	private final List<Artifact> compileTimeDependencyArtifacts = new ArrayList<>();
	private String ruleKind;
	private Label targetLabel;

	private final NestedSetBuilder<Artifact> excludedArtifacts =
	NestedSetBuilder.naiveLinkOrder();

	private boolean built = false;

	private final JavaSemantics semantics;

	public Builder(JavaSemantics semantics) {
	this.semantics = semantics;
	}

	public Builder addSourceArtifacts(Iterable<Artifact> sourceArtifacts) {
	Preconditions.checkArgument(!built);
	for (Artifact srcArtifact : sourceArtifacts) {
	String srcFilename = srcArtifact.getExecPathString();
	if (JavaSemantics.SOURCE_JAR.matches(srcFilename)) {
	sourceJars.add(srcArtifact);
	} else if (JavaSemantics.PROPERTIES.matches(srcFilename)) {
	// output files of the message compiler
	resources.put(
	semantics.getDefaultJavaResourcePath(srcArtifact.getRootRelativePath()), srcArtifact);
	} else if (JavaSemantics.JAVA_SOURCE.matches(srcFilename)) {
	sourceFiles.add(srcArtifact);
	} else {
	// try specific cases from the semantics.
	semantics.addArtifactToJavaTargetAttribute(this, srcArtifact);
	}
	}
	return this;
	}

	public Builder addSourceFiles(Iterable<Artifact> sourceFiles) {
	Preconditions.checkArgument(!built);
	for (Artifact artifact : sourceFiles) {
	if (JavaSemantics.JAVA_SOURCE.matches(artifact.getFilename())) {
	this.sourceFiles.add(artifact);
	}
	}
	return this;
	}

	public Builder merge(JavaCompilationArgs context) {
	Preconditions.checkArgument(!built);
	addCompileTimeClassPathEntries(context.getCompileTimeJars());
	addRuntimeClassPathEntries(context.getRuntimeJars());
	addInstrumentationMetadataEntries(context.getInstrumentationMetadata());
	return this;
	}

	public Builder addSourceJars(Collection<Artifact> sourceJars) {
	Preconditions.checkArgument(!built);
	this.sourceJars.addAll(sourceJars);
	return this;
	}

	public Builder addSourceJar(Artifact sourceJar) {
	Preconditions.checkArgument(!built);
	this.sourceJars.add(sourceJar);
	return this;
	}

	public Builder addCompileTimeJarFiles(Iterable<Artifact> jars) {
	Preconditions.checkArgument(!built);
	Iterables.addAll(compileTimeJarFiles, jars);
	return this;
	}

	public Builder addRuntimeClassPathEntry(Artifact classPathEntry) {
	Preconditions.checkArgument(!built);
	checkJar(classPathEntry);
	runtimeClassPath.add(classPathEntry);
	return this;
	}

	public Builder addRuntimeClassPathEntries(NestedSet<Artifact> classPathEntries) {
	Preconditions.checkArgument(!built);
	runtimeClassPath.addTransitive(classPathEntries);
	return this;
	}

	public Builder addCompileTimeClassPathEntries(NestedSet<Artifact> entries) {
	Preconditions.checkArgument(!built);
	compileTimeClassPath.addTransitive(entries);
	return this;
	}

	public Builder setRuleKind(String ruleKind) {
	Preconditions.checkArgument(!built);
	this.ruleKind = ruleKind;
	return this;
	}

	public Builder setTargetLabel(Label targetLabel) {
	Preconditions.checkArgument(!built);
	this.targetLabel = targetLabel;
	return this;
	}

	/**
	* Sets the bootclasspath to be passed to the Java compiler.
	*
	* <p>If this method is called, then the bootclasspath specified in this JavaTargetAttributes
	* instance overrides the default bootclasspath.
	*/
	public Builder setBootClassPath(List<Artifact> jars) {
	Preconditions.checkArgument(!built);
	Preconditions.checkArgument(!jars.isEmpty());
	Preconditions.checkState(bootClassPath.isEmpty());
	bootClassPath.addAll(jars);
	return this;
	}

	public Builder addExcludedArtifacts(NestedSet<Artifact> toExclude) {
	Preconditions.checkArgument(!built);
	excludedArtifacts.addTransitive(toExclude);
	return this;
	}

	/**
	* Controls how strict the javac compiler will be in checking correct use of
	* direct dependencies.
	*
	* @param strictDeps one of WARN, ERROR or OFF
	*/
	public Builder setStrictJavaDeps(BuildConfiguration.StrictDepsMode strictDeps) {
	Preconditions.checkArgument(!built);
	strictJavaDeps = strictDeps;
	return this;
	}

	/**
	* In tandem with strictJavaDeps, directJars represents a subset of the compile-time, classpath
	* jars that were provided by direct dependencies. When strictJavaDeps is OFF, there is no need
	* to provide directJars, and no extra information is passed to javac. When strictJavaDeps is
	* set to WARN or ERROR, the compiler command line will include extra flags to indicate the
	* warning/error policy and to map the classpath jars to direct or transitive dependencies,
	* using the information in directJars. The extra flags are formatted like this (same for
	* --indirect_dependency): <pre>
	* --direct_dependency
	* foo/bar/lib.jar
	* //java/com/google/foo:bar
	* </pre>
	*/
	public Builder addDirectJars(NestedSet<Artifact> directJars) {
	Preconditions.checkArgument(!built);
	this.directJars.addTransitive(directJars);
	return this;
	}

	public Builder addCompileTimeDependencyArtifacts(Iterable<Artifact> dependencyArtifacts) {
	Preconditions.checkArgument(!built);
	Iterables.addAll(this.compileTimeDependencyArtifacts, dependencyArtifacts);
	return this;
	}

	public Builder addInstrumentationMetadataEntries(Iterable<Artifact> metadataEntries) {
	Preconditions.checkArgument(!built);
	Iterables.addAll(instrumentationMetadata, metadataEntries);
	return this;
	}

	public Builder addNativeLibrary(Artifact nativeLibrary) {
	Preconditions.checkArgument(!built);
	String name = nativeLibrary.getFilename();
	if (CppFileTypes.INTERFACE_SHARED_LIBRARY.matches(name)) {
	return this;
	}
	if (!(CppFileTypes.SHARED_LIBRARY.matches(name)
	\|\| CppFileTypes.VERSIONED_SHARED_LIBRARY.matches(name))) {
	throw new IllegalArgumentException("not a shared library :" + nativeLibrary.prettyPrint());
	}
	nativeLibraries.add(nativeLibrary);
	return this;
	}

	public Builder addNativeLibraries(Iterable<Artifact> nativeLibraries) {
	Preconditions.checkArgument(!built);
	for (Artifact nativeLibrary : nativeLibraries) {
	addNativeLibrary(nativeLibrary);
	}
	return this;
	}

	public Builder addMessages(Collection<Artifact> messages) {
	Preconditions.checkArgument(!built);
	this.messages.addAll(messages);
	return this;
	}

	public Builder addMessage(Artifact messagesArtifact) {
	Preconditions.checkArgument(!built);
	this.messages.add(messagesArtifact);
	return this;
	}

	public Builder addResource(PathFragment execPath, Artifact resource) {
	Preconditions.checkArgument(!built);
	this.resources.put(execPath, resource);
	return this;
	}

	public Builder addResourceJars(NestedSet<Artifact> resourceJars) {
	Preconditions.checkArgument(!built);
	this.resourceJars.addTransitive(resourceJars);
	return this;
	}

	public Builder addProcessorName(String processor) {
	Preconditions.checkArgument(!built);
	processorNames.add(processor);
	return this;
	}

	public Builder addProcessorPath(Iterable<Artifact> jars) {
	Preconditions.checkArgument(!built);
	Iterables.addAll(processorPath, jars);
	return this;
	}

	public Builder addProcessorPathDir(PathFragment dir) {
	Preconditions.checkArgument(!built);
	processorPathDirs.add(dir);
	return this;
	}

	public Builder addApiGeneratingProcessorName(String processor) {
	Preconditions.checkArgument(!built);
	apiGeneratingProcessorNames.add(processor);
	return this;
	}

	public Builder addApiGeneratingProcessorPath(Iterable<Artifact> jars) {
	Preconditions.checkArgument(!built);
	Iterables.addAll(apiGeneratingProcessorPath, jars);
	return this;
	}

	public Builder addClassPathResources(List<Artifact> classPathResources) {
	Preconditions.checkArgument(!built);
	this.classPathResources.addAll(classPathResources);
	return this;
	}

	public Builder addClassPathResource(Artifact classPathResource) {
	Preconditions.checkArgument(!built);
	this.classPathResources.add(classPathResource);
	return this;
	}

	/**
	* Adds additional outputs to this target's compile action.
	*/
	public Builder addAdditionalOutputs(Iterable<Artifact> outputs) {
	Preconditions.checkArgument(!built);
	Iterables.addAll(additionalOutputs, outputs);
	return this;
	}

	public JavaTargetAttributes build() {
	built = true;
	return new JavaTargetAttributes(
	sourceFiles,
	compileTimeJarFiles,
	runtimeClassPath,
	compileTimeClassPath,
	bootClassPath,
	nativeLibraries,
	processorPath,
	processorPathDirs,
	processorNames,
	apiGeneratingProcessorPath,
	apiGeneratingProcessorNames,
	resources,
	resourceJars.build(),
	messages,
	sourceJars,
	classPathResources,
	additionalOutputs,
	directJars.build(),
	compileTimeDependencyArtifacts,
	ruleKind,
	targetLabel,
	excludedArtifacts,
	strictJavaDeps);
	}

	// TODO(bazel-team): Remove these 5 methods.
	@Deprecated
	public Set<Artifact> getSourceFiles() {
	return sourceFiles;
	}

	@Deprecated
	public boolean hasSourceFiles() {
	return !sourceFiles.isEmpty();
	}

	@Deprecated
	public List<Artifact> getInstrumentationMetadata() {
	return instrumentationMetadata;
	}

	@Deprecated
	public boolean hasSourceJars() {
	return !sourceJars.isEmpty();
	}
	}

	//
	// -------------------------- END OF BUILDER CLASS -------------------------
	//

	private final ImmutableSet<Artifact> sourceFiles;
	private final ImmutableSet<Artifact> compileTimeJarFiles;

	private final NestedSet<Artifact> runtimeClassPath;
	private final NestedSet<Artifact> compileTimeClassPath;

	private final ImmutableList<Artifact> bootClassPath;
	private final ImmutableList<Artifact> nativeLibraries;

	private final ImmutableSet<Artifact> processorPath;
	private final ImmutableSet<PathFragment> processorPathDirs;
	private final ImmutableSet<String> processorNames;

	private final ImmutableSet<Artifact> apiGeneratingProcessorPath;
	private final ImmutableSet<String> apiGeneratingProcessorNames;

	private final ImmutableMap<PathFragment, Artifact> resources;
	private final NestedSet<Artifact> resourceJars;

	private final ImmutableList<Artifact> messages;
	private final ImmutableList<Artifact> sourceJars;

	private final ImmutableList<Artifact> classPathResources;

	private final ImmutableSet<Artifact> additionalOutputs;

	private final NestedSet<Artifact> directJars;
	private final ImmutableList<Artifact> compileTimeDependencyArtifacts;
	private final String ruleKind;
	private final Label targetLabel;

	private final NestedSet<Artifact> excludedArtifacts;
	private final BuildConfiguration.StrictDepsMode strictJavaDeps;

	/** Constructor of JavaTargetAttributes. */
	private JavaTargetAttributes(
	Set<Artifact> sourceFiles,
	Set<Artifact> compileTimeJarFiles,
	NestedSetBuilder<Artifact> runtimeClassPath,
	NestedSetBuilder<Artifact> compileTimeClassPath,
	List<Artifact> bootClassPath,
	List<Artifact> nativeLibraries,
	Set<Artifact> processorPath,
	Set<PathFragment> processorPathDirs,
	Set<String> processorNames,
	Set<Artifact> apiGeneratingProcessorPath,
	Set<String> apiGeneratingProcessorNames,
	Map<PathFragment, Artifact> resources,
	NestedSet<Artifact> resourceJars,
	List<Artifact> messages,
	List<Artifact> sourceJars,
	List<Artifact> classPathResources,
	Set<Artifact> additionalOutputs,
	NestedSet<Artifact> directJars,
	List<Artifact> compileTimeDependencyArtifacts,
	String ruleKind,
	Label targetLabel,
	NestedSetBuilder<Artifact> excludedArtifacts,
	BuildConfiguration.StrictDepsMode strictJavaDeps) {
	this.sourceFiles = ImmutableSet.copyOf(sourceFiles);
	this.compileTimeJarFiles = ImmutableSet.copyOf(compileTimeJarFiles);
	this.runtimeClassPath = runtimeClassPath.build();
	this.directJars = directJars;
	this.compileTimeClassPath =
	NestedSetBuilder.<Artifact>naiveLinkOrder()
	.addTransitive(directJars)
	.addTransitive(compileTimeClassPath.build())
	.build();
	this.bootClassPath = ImmutableList.copyOf(bootClassPath);
	this.nativeLibraries = ImmutableList.copyOf(nativeLibraries);
	this.processorPath = ImmutableSet.copyOf(processorPath);
	this.processorPathDirs = ImmutableSet.copyOf(processorPathDirs);
	this.processorNames = ImmutableSet.copyOf(processorNames);
	this.apiGeneratingProcessorPath = ImmutableSet.copyOf(apiGeneratingProcessorPath);
	this.apiGeneratingProcessorNames = ImmutableSet.copyOf(apiGeneratingProcessorNames);
	this.resources = ImmutableMap.copyOf(resources);
	this.resourceJars = resourceJars;
	this.messages = ImmutableList.copyOf(messages);
	this.sourceJars = ImmutableList.copyOf(sourceJars);
	this.classPathResources = ImmutableList.copyOf(classPathResources);
	this.additionalOutputs = ImmutableSet.copyOf(additionalOutputs);
	this.compileTimeDependencyArtifacts = ImmutableList.copyOf(compileTimeDependencyArtifacts);
	this.ruleKind = ruleKind;
	this.targetLabel = targetLabel;
	this.excludedArtifacts = excludedArtifacts.build();
	this.strictJavaDeps = strictJavaDeps;
	}

	public NestedSet<Artifact> getDirectJars() {
	return directJars;
	}

	public List<Artifact> getCompileTimeDependencyArtifacts() {
	return compileTimeDependencyArtifacts;
	}

	public List<Artifact> getSourceJars() {
	return sourceJars;
	}

	public Map<PathFragment, Artifact> getResources() {
	return resources;
	}

	public NestedSet<Artifact> getResourceJars() {
	return resourceJars;
	}

	public List<Artifact> getMessages() {
	return messages;
	}

	public ImmutableList<Artifact> getClassPathResources() {
	return classPathResources;
	}

	public ImmutableSet<Artifact> getAdditionalOutputs() {
	return additionalOutputs;
	}

	private NestedSet<Artifact> getExcludedArtifacts() {
	return excludedArtifacts;
	}

	/**
	* Returns the artifacts needed on the runtime classpath of this target.
	*
	* See also {@link #getRuntimeClassPathForArchive()}.
	*/
	public NestedSet<Artifact> getRuntimeClassPath() {
	return runtimeClassPath;
	}

	/**
	* Returns the classpath artifacts needed in a deploy jar for this target.
	*
	* This excludes the artifacts made available by jars in the deployment
	* environment.
	*/
	public Iterable<Artifact> getRuntimeClassPathForArchive() {
	Iterable<Artifact> runtimeClasspath = getRuntimeClassPath();

	if (getExcludedArtifacts().isEmpty()) {
	return runtimeClasspath;
	} else {
	return Iterables.filter(runtimeClasspath,
	Predicates.not(Predicates.in(getExcludedArtifacts().toSet())));
	}
	}

	public NestedSet<Artifact> getCompileTimeClassPath() {
	return compileTimeClassPath;
	}

	public ImmutableList<Artifact> getBootClassPath() {
	return bootClassPath;
	}

	public ImmutableSet<Artifact> getProcessorPath() {
	return processorPath;
	}

	public ImmutableSet<PathFragment> getProcessorPathDirs() {
	return processorPathDirs;
	}

	public Collection<Artifact> getApiGeneratingProcessorPath() {
	return apiGeneratingProcessorPath;
	}

	public ImmutableSet<String> getApiGeneratingProcessorNames() {
	return apiGeneratingProcessorNames;
	}

	public Set<Artifact> getSourceFiles() {
	return sourceFiles;
	}

	public Set<Artifact> getCompileTimeJarFiles() {
	return compileTimeJarFiles;
	}

	public List<Artifact> getNativeLibraries() {
	return nativeLibraries;
	}

	public Collection<String> getProcessorNames() {
	return processorNames;
	}

	public boolean hasSourceFiles() {
	return !sourceFiles.isEmpty();
	}

	public boolean hasSourceJars() {
	return !sourceJars.isEmpty();
	}

	public boolean hasResources() {
	return !resources.isEmpty();
	}

	public boolean hasMessages() {
	return !messages.isEmpty();
	}

	public boolean hasClassPathResources() {
	return !classPathResources.isEmpty();
	}

	public String getRuleKind() {
	return ruleKind;
	}

	public Label getTargetLabel() {
	return targetLabel;
	}

	public BuildConfiguration.StrictDepsMode getStrictJavaDeps() {
	return strictJavaDeps;
	}
	}