use of org.apache.beam.vendor.calcite.v1_28_0.com.google.common.collect.ImmutableSet in project buck by facebook.
the class TargetPatternEvaluator method resolveFilePattern.
ImmutableSet<QueryTarget> resolveFilePattern(String pattern) throws IOException {
ImmutableSet<Path> filePaths = PathArguments.getCanonicalFilesUnderProjectRoot(projectRoot, ImmutableList.of(pattern)).relativePathsUnderProjectRoot;
ImmutableSet.Builder<QueryTarget> builder = ImmutableSortedSet.naturalOrder();
for (Path filePath : filePaths) {
builder.add(QueryFileTarget.of(filePath));
}
return builder.build();
}
use of org.apache.beam.vendor.calcite.v1_28_0.com.google.common.collect.ImmutableSet in project buck by facebook.
the class TargetsCommand method getDependentNodes.
/**
* @param graph A graph used to resolve dependencies between targets.
* @param nodes A set of nodes.
* @param detectTestChanges If true, tests are considered to be dependencies of the targets they
* are testing.
* @return A set of all nodes that transitively depend on {@code nodes}
* (a superset of {@code nodes}).
*/
private static ImmutableSet<TargetNode<?, ?>> getDependentNodes(final TargetGraph graph, ImmutableSet<TargetNode<?, ?>> nodes, boolean detectTestChanges) {
ImmutableMultimap.Builder<TargetNode<?, ?>, TargetNode<?, ?>> extraEdgesBuilder = ImmutableMultimap.builder();
if (detectTestChanges) {
for (TargetNode<?, ?> node : graph.getNodes()) {
if (node.getConstructorArg() instanceof HasTests) {
ImmutableSortedSet<BuildTarget> tests = ((HasTests) node.getConstructorArg()).getTests();
for (BuildTarget testTarget : tests) {
Optional<TargetNode<?, ?>> testNode = graph.getOptional(testTarget);
if (!testNode.isPresent()) {
throw new HumanReadableException("'%s' (test of '%s') is not in the target graph.", testTarget, node);
}
extraEdgesBuilder.put(testNode.get(), node);
}
}
}
}
final ImmutableMultimap<TargetNode<?, ?>, TargetNode<?, ?>> extraEdges = extraEdgesBuilder.build();
final ImmutableSet.Builder<TargetNode<?, ?>> builder = ImmutableSet.builder();
AbstractBreadthFirstTraversal<TargetNode<?, ?>> traversal = new AbstractBreadthFirstTraversal<TargetNode<?, ?>>(nodes) {
@Override
public ImmutableSet<TargetNode<?, ?>> visit(TargetNode<?, ?> targetNode) {
builder.add(targetNode);
return FluentIterable.from(graph.getIncomingNodesFor(targetNode)).append(extraEdges.get(targetNode)).toSet();
}
};
traversal.start();
return builder.build();
}
use of org.apache.beam.vendor.calcite.v1_28_0.com.google.common.collect.ImmutableSet in project buck by facebook.
the class PathHashing method hashPath.
public static ImmutableSet<Path> hashPath(Hasher hasher, ProjectFileHashLoader fileHashLoader, ProjectFilesystem projectFilesystem, Path root) throws IOException {
Preconditions.checkArgument(!root.equals(EMPTY_PATH), "Path to hash (%s) must not be empty", root);
ImmutableSet.Builder<Path> children = ImmutableSet.builder();
for (Path path : ImmutableSortedSet.copyOf(projectFilesystem.getFilesUnderPath(root))) {
StringHashing.hashStringAndLength(hasher, MorePaths.pathWithUnixSeparators(path));
if (!root.equals(path)) {
children.add(root.relativize(path));
}
hasher.putBytes(fileHashLoader.get(path).asBytes());
}
return children.build();
}
use of org.apache.beam.vendor.calcite.v1_28_0.com.google.common.collect.ImmutableSet in project buck by facebook.
the class HaskellDescriptionUtils method createCompileRule.
/**
* Create a Haskell compile rule that compiles all the given haskell sources in one step and
* pulls interface files from all transitive haskell dependencies.
*/
private static HaskellCompileRule createCompileRule(BuildTarget target, final BuildRuleParams baseParams, final BuildRuleResolver resolver, SourcePathRuleFinder ruleFinder, ImmutableSet<BuildRule> deps, final CxxPlatform cxxPlatform, HaskellConfig haskellConfig, final Linker.LinkableDepType depType, Optional<String> main, Optional<HaskellPackageInfo> packageInfo, ImmutableList<String> flags, HaskellSources sources) throws NoSuchBuildTargetException {
final Map<BuildTarget, ImmutableList<String>> depFlags = new TreeMap<>();
final Map<BuildTarget, ImmutableList<SourcePath>> depIncludes = new TreeMap<>();
final ImmutableSortedMap.Builder<String, HaskellPackage> exposedPackagesBuilder = ImmutableSortedMap.naturalOrder();
final ImmutableSortedMap.Builder<String, HaskellPackage> packagesBuilder = ImmutableSortedMap.naturalOrder();
new AbstractBreadthFirstThrowingTraversal<BuildRule, NoSuchBuildTargetException>(deps) {
private final ImmutableSet<BuildRule> empty = ImmutableSet.of();
@Override
public Iterable<BuildRule> visit(BuildRule rule) throws NoSuchBuildTargetException {
ImmutableSet<BuildRule> ruleDeps = empty;
if (rule instanceof HaskellCompileDep) {
ruleDeps = rule.getDeps();
HaskellCompileInput compileInput = ((HaskellCompileDep) rule).getCompileInput(cxxPlatform, depType);
depFlags.put(rule.getBuildTarget(), compileInput.getFlags());
depIncludes.put(rule.getBuildTarget(), compileInput.getIncludes());
// We add packages from first-order deps as expose modules, and transitively included
// packages as hidden ones.
boolean firstOrderDep = deps.contains(rule);
for (HaskellPackage pkg : compileInput.getPackages()) {
if (firstOrderDep) {
exposedPackagesBuilder.put(pkg.getInfo().getIdentifier(), pkg);
} else {
packagesBuilder.put(pkg.getInfo().getIdentifier(), pkg);
}
}
}
return ruleDeps;
}
}.start();
Collection<CxxPreprocessorInput> cxxPreprocessorInputs = CxxPreprocessables.getTransitiveCxxPreprocessorInput(cxxPlatform, deps);
ExplicitCxxToolFlags.Builder toolFlagsBuilder = CxxToolFlags.explicitBuilder();
PreprocessorFlags.Builder ppFlagsBuilder = PreprocessorFlags.builder();
toolFlagsBuilder.setPlatformFlags(CxxSourceTypes.getPlatformPreprocessFlags(cxxPlatform, CxxSource.Type.C));
for (CxxPreprocessorInput input : cxxPreprocessorInputs) {
ppFlagsBuilder.addAllIncludes(input.getIncludes());
ppFlagsBuilder.addAllFrameworkPaths(input.getFrameworks());
toolFlagsBuilder.addAllRuleFlags(input.getPreprocessorFlags().get(CxxSource.Type.C));
}
ppFlagsBuilder.setOtherFlags(toolFlagsBuilder.build());
PreprocessorFlags ppFlags = ppFlagsBuilder.build();
ImmutableList<String> compileFlags = ImmutableList.<String>builder().addAll(haskellConfig.getCompilerFlags()).addAll(flags).addAll(Iterables.concat(depFlags.values())).build();
ImmutableList<SourcePath> includes = ImmutableList.copyOf(Iterables.concat(depIncludes.values()));
ImmutableSortedMap<String, HaskellPackage> exposedPackages = exposedPackagesBuilder.build();
ImmutableSortedMap<String, HaskellPackage> packages = packagesBuilder.build();
return HaskellCompileRule.from(target, baseParams, ruleFinder, haskellConfig.getCompiler().resolve(resolver), haskellConfig.getHaskellVersion(), compileFlags, ppFlags, cxxPlatform, depType == Linker.LinkableDepType.STATIC ? CxxSourceRuleFactory.PicType.PDC : CxxSourceRuleFactory.PicType.PIC, main, packageInfo, includes, exposedPackages, packages, sources, CxxSourceTypes.getPreprocessor(cxxPlatform, CxxSource.Type.C).resolve(resolver));
}
use of org.apache.beam.vendor.calcite.v1_28_0.com.google.common.collect.ImmutableSet in project buck by facebook.
the class DefaultSuggestBuildRules method isMissingBuildRule.
/**
* @param transitiveNotDeclaredRule A {@link BuildRule} that is contained in the transitive
* dependency list but is not declared as a dependency.
* @param failedImports A Set of remaining failed imports. This function will mutate this set
* and remove any imports satisfied by {@code transitiveNotDeclaredDep}.
* @return whether or not adding {@code transitiveNotDeclaredDep} as a dependency to this build
* rule would have satisfied one of the {@code failedImports}.
*/
private boolean isMissingBuildRule(BuildRule transitiveNotDeclaredRule, Set<String> failedImports, JarResolver jarResolver) {
if (!(transitiveNotDeclaredRule instanceof JavaLibrary)) {
return false;
}
ImmutableSet<Path> classPaths = ((JavaLibrary) transitiveNotDeclaredRule).getOutputClasspaths().stream().map(c -> pathResolver.getAbsolutePath(c)).collect(MoreCollectors.toImmutableSet());
boolean containsMissingBuildRule = false;
// classpath.
for (Path classPath : classPaths) {
ImmutableSet<String> topLevelSymbols = jarResolver.resolve(classPath);
for (String symbolName : topLevelSymbols) {
if (failedImports.contains(symbolName)) {
failedImports.remove(symbolName);
containsMissingBuildRule = true;
// If we've found all of the missing imports, bail out early.
if (failedImports.isEmpty()) {
return true;
}
}
}
}
return containsMissingBuildRule;
}
Aggregations