use of java.util.Optional in project buck by facebook.
the class JavaFileParser method extractFeaturesFromJavaCode.
public JavaFileFeatures extractFeaturesFromJavaCode(String code) {
// For now, we will harcode this. Ultimately, we probably want to make this configurable via
// .buckconfig. For example, the Buck project itself is diligent about disallowing wildcard
// imports, but the one exception is the Java code generated via Thrift in src-gen.
final boolean shouldThrowForUnsupportedWildcardImport = false;
final AtomicBoolean isPoisonedByUnsupportedWildcardImport = new AtomicBoolean(false);
final CompilationUnit compilationUnit = makeCompilationUnitFromSource(code);
final ImmutableSortedSet.Builder<String> providedSymbols = ImmutableSortedSet.naturalOrder();
final ImmutableSortedSet.Builder<String> requiredSymbols = ImmutableSortedSet.naturalOrder();
final ImmutableSortedSet.Builder<String> exportedSymbols = ImmutableSortedSet.naturalOrder();
final ImmutableSortedSet.Builder<String> requiredSymbolsFromExplicitImports = ImmutableSortedSet.naturalOrder();
compilationUnit.accept(new ASTVisitor() {
@Nullable
private String packageName;
/** Maps simple name to fully-qualified name. */
private Map<String, String> simpleImportedTypes = new HashMap<>();
/**
* Maps wildcard import prefixes, such as {@code "java.util"} to the types in the respective
* package if a wildcard import such as {@code import java.util.*} is used.
*/
private Map<String, ImmutableSet<String>> wildcardImports = new HashMap<>();
@Override
public boolean visit(PackageDeclaration node) {
Preconditions.checkState(packageName == null, "There should be at most one package declaration");
packageName = node.getName().getFullyQualifiedName();
return false;
}
// providedSymbols
@Override
public boolean visit(TypeDeclaration node) {
// Local classes can be declared inside of methods. Skip over these.
if (node.getParent() instanceof TypeDeclarationStatement) {
return true;
}
String fullyQualifiedName = getFullyQualifiedTypeName(node);
if (fullyQualifiedName != null) {
providedSymbols.add(fullyQualifiedName);
}
@SuppressWarnings("unchecked") List<Type> interfaceTypes = node.superInterfaceTypes();
for (Type interfaceType : interfaceTypes) {
tryAddType(interfaceType, DependencyType.EXPORTED);
}
Type superclassType = node.getSuperclassType();
if (superclassType != null) {
tryAddType(superclassType, DependencyType.EXPORTED);
}
return true;
}
@Override
public boolean visit(EnumDeclaration node) {
String fullyQualifiedName = getFullyQualifiedTypeName(node);
if (fullyQualifiedName != null) {
providedSymbols.add(fullyQualifiedName);
}
return true;
}
@Override
public boolean visit(AnnotationTypeDeclaration node) {
String fullyQualifiedName = getFullyQualifiedTypeName(node);
if (fullyQualifiedName != null) {
providedSymbols.add(fullyQualifiedName);
}
return true;
}
// requiredSymbols
/**
* Uses heuristics to try to figure out what type of QualifiedName this is. Returns a non-null
* value if this is believed to be a reference that qualifies as a "required symbol"
* relationship.
*/
@Override
public boolean visit(QualifiedName node) {
QualifiedName ancestor = findMostQualifiedAncestor(node);
ASTNode parent = ancestor.getParent();
if (!(parent instanceof PackageDeclaration) && !(parent instanceof ImportDeclaration)) {
String symbol = ancestor.getFullyQualifiedName();
// lookup.
if (CharMatcher.javaUpperCase().matches(symbol.charAt(0))) {
addTypeFromDotDelimitedSequence(symbol, DependencyType.REQUIRED);
}
}
return false;
}
/**
* @param expr could be "Example", "Example.field", "com.example.Example". Note it could also
* be a built-in type, such as "java.lang.Integer", in which case it will not be added to
* the set of required symbols.
*/
private void addTypeFromDotDelimitedSequence(String expr, DependencyType dependencyType) {
// check it against JAVA_LANG_TYPES.
if (startsWithUppercaseChar(expr)) {
int index = expr.indexOf('.');
if (index >= 0) {
String leftmostComponent = expr.substring(0, index);
if (JAVA_LANG_TYPES.contains(leftmostComponent)) {
return;
}
}
}
expr = qualifyWithPackageNameIfNecessary(expr);
addSymbol(expr, dependencyType);
}
@Override
public boolean visit(ImportDeclaration node) {
String fullyQualifiedName = node.getName().getFullyQualifiedName();
// third-party code. As such, we will tolerate these for some of the common cases.
if (node.isOnDemand()) {
ImmutableSet<String> value = SUPPORTED_WILDCARD_IMPORTS.get(fullyQualifiedName);
if (value != null) {
wildcardImports.put(fullyQualifiedName, value);
return false;
} else if (shouldThrowForUnsupportedWildcardImport) {
throw new RuntimeException(String.format("Use of wildcard 'import %s.*' makes it impossible to statically determine " + "required symbols in this file. Please enumerate explicit imports.", fullyQualifiedName));
} else {
isPoisonedByUnsupportedWildcardImport.set(true);
return false;
}
}
// Only worry about the dependency on the enclosing type.
Optional<String> simpleName = getSimpleNameFromFullyQualifiedName(fullyQualifiedName);
if (simpleName.isPresent()) {
String name = simpleName.get();
int index = fullyQualifiedName.indexOf("." + name);
String enclosingType = fullyQualifiedName.substring(0, index + name.length() + 1);
requiredSymbolsFromExplicitImports.add(enclosingType);
simpleImportedTypes.put(name, enclosingType);
} else {
LOG.warn("Suspicious import lacks obvious enclosing type: %s", fullyQualifiedName);
// The one example we have seen of this in the wild is
// "org.whispersystems.curve25519.java.curve_sigs". In practice, we still need to add it
// as a required symbol in this case.
requiredSymbols.add(fullyQualifiedName);
}
return false;
}
@Override
public boolean visit(MethodInvocation node) {
if (node.getExpression() == null) {
return true;
}
String receiver = node.getExpression().toString();
if (looksLikeAType(receiver)) {
addTypeFromDotDelimitedSequence(receiver, DependencyType.REQUIRED);
}
return true;
}
/** An annotation on a member with zero arguments. */
@Override
public boolean visit(MarkerAnnotation node) {
DependencyType dependencyType = findDependencyTypeForAnnotation(node);
addSimpleTypeName(node.getTypeName(), dependencyType);
return true;
}
/** An annotation on a member with named arguments. */
@Override
public boolean visit(NormalAnnotation node) {
DependencyType dependencyType = findDependencyTypeForAnnotation(node);
addSimpleTypeName(node.getTypeName(), dependencyType);
return true;
}
/** An annotation on a member with a single, unnamed argument. */
@Override
public boolean visit(SingleMemberAnnotation node) {
DependencyType dependencyType = findDependencyTypeForAnnotation(node);
addSimpleTypeName(node.getTypeName(), dependencyType);
return true;
}
private DependencyType findDependencyTypeForAnnotation(Annotation annotation) {
ASTNode parentNode = annotation.getParent();
if (parentNode == null) {
return DependencyType.REQUIRED;
}
if (parentNode instanceof BodyDeclaration) {
// Note that BodyDeclaration is an abstract class. Its subclasses are things like
// FieldDeclaration and MethodDeclaration. We want to be sure that an annotation on any
// non-private declaration is considered an exported symbol.
BodyDeclaration declaration = (BodyDeclaration) parentNode;
int modifiers = declaration.getModifiers();
if ((modifiers & Modifier.PRIVATE) == 0) {
return DependencyType.EXPORTED;
}
}
return DependencyType.REQUIRED;
}
@Override
public boolean visit(SimpleType node) {
// This method is responsible for finding the overwhelming majority of the required symbols
// in the AST.
tryAddType(node, DependencyType.REQUIRED);
return true;
}
// exportedSymbols
@Override
public boolean visit(MethodDeclaration node) {
// Types from private method signatures need not be exported.
if ((node.getModifiers() & Modifier.PRIVATE) != 0) {
return true;
}
Type returnType = node.getReturnType2();
if (returnType != null) {
tryAddType(returnType, DependencyType.EXPORTED);
}
@SuppressWarnings("unchecked") List<SingleVariableDeclaration> params = node.parameters();
for (SingleVariableDeclaration decl : params) {
tryAddType(decl.getType(), DependencyType.EXPORTED);
}
@SuppressWarnings("unchecked") List<Type> exceptions = node.thrownExceptionTypes();
for (Type exception : exceptions) {
tryAddType(exception, DependencyType.EXPORTED);
}
return true;
}
@Override
public boolean visit(FieldDeclaration node) {
// Types from private fields need not be exported.
if ((node.getModifiers() & Modifier.PRIVATE) == 0) {
tryAddType(node.getType(), DependencyType.EXPORTED);
}
return true;
}
private void tryAddType(Type type, DependencyType dependencyType) {
if (type.isSimpleType()) {
SimpleType simpleType = (SimpleType) type;
Name simpleTypeName = simpleType.getName();
String simpleName = simpleTypeName.toString();
// rather than simply required.
if (!CharMatcher.javaUpperCase().matchesAllOf(simpleName) || (dependencyType == DependencyType.EXPORTED && simpleImportedTypes.containsKey(simpleName))) {
addSimpleTypeName(simpleTypeName, dependencyType);
}
} else if (type.isArrayType()) {
ArrayType arrayType = (ArrayType) type;
tryAddType(arrayType.getElementType(), dependencyType);
} else if (type.isParameterizedType()) {
ParameterizedType parameterizedType = (ParameterizedType) type;
tryAddType(parameterizedType.getType(), dependencyType);
@SuppressWarnings("unchecked") List<Type> argTypes = parameterizedType.typeArguments();
for (Type argType : argTypes) {
tryAddType(argType, dependencyType);
}
}
}
private void addSimpleTypeName(Name simpleTypeName, DependencyType dependencyType) {
String simpleName = simpleTypeName.toString();
if (JAVA_LANG_TYPES.contains(simpleName)) {
return;
}
String fullyQualifiedNameForSimpleName = simpleImportedTypes.get(simpleName);
if (fullyQualifiedNameForSimpleName != null) {
// May need to promote from required to exported in this case.
if (dependencyType == DependencyType.EXPORTED) {
addSymbol(fullyQualifiedNameForSimpleName, DependencyType.EXPORTED);
}
return;
}
// the iterator most of the time.
if (!wildcardImports.isEmpty()) {
for (Map.Entry<String, ImmutableSet<String>> entry : wildcardImports.entrySet()) {
Set<String> types = entry.getValue();
if (types.contains(simpleName)) {
String packageName = entry.getKey();
addSymbol(packageName + "." + simpleName, dependencyType);
return;
}
}
}
String symbol = simpleTypeName.getFullyQualifiedName();
symbol = qualifyWithPackageNameIfNecessary(symbol);
addSymbol(symbol, dependencyType);
}
private void addSymbol(String symbol, DependencyType dependencyType) {
((dependencyType == DependencyType.REQUIRED) ? requiredSymbols : exportedSymbols).add(symbol);
}
private String qualifyWithPackageNameIfNecessary(String symbol) {
if (!startsWithUppercaseChar(symbol)) {
return symbol;
}
// If the symbol starts with a capital letter, then we assume that it is a reference to
// a type in the same package.
int index = symbol.indexOf('.');
if (index >= 0) {
symbol = symbol.substring(0, index);
}
if (packageName != null) {
symbol = packageName + "." + symbol;
}
return symbol;
}
});
// TODO(bolinfest): Special treatment for exportedSymbols when poisoned by wildcard import.
ImmutableSortedSet<String> totalExportedSymbols = exportedSymbols.build();
// If we were poisoned by an unsupported wildcard import, then we should rely exclusively on
// the explicit imports to determine the required symbols.
Set<String> totalRequiredSymbols = new HashSet<>();
if (isPoisonedByUnsupportedWildcardImport.get()) {
totalRequiredSymbols.addAll(requiredSymbolsFromExplicitImports.build());
} else {
totalRequiredSymbols.addAll(requiredSymbolsFromExplicitImports.build());
totalRequiredSymbols.addAll(requiredSymbols.build());
}
// Make sure that required and exported symbols are disjoint sets.
totalRequiredSymbols.removeAll(totalExportedSymbols);
return new JavaFileFeatures(providedSymbols.build(), ImmutableSortedSet.copyOf(totalRequiredSymbols), totalExportedSymbols);
}
use of java.util.Optional in project buck by facebook.
the class PythonTestDescription method createBuildRule.
@Override
public <A extends Arg> PythonTest createBuildRule(TargetGraph targetGraph, final BuildRuleParams params, final BuildRuleResolver resolver, final A args) throws HumanReadableException, NoSuchBuildTargetException {
PythonPlatform pythonPlatform = pythonPlatforms.getValue(params.getBuildTarget()).orElse(pythonPlatforms.getValue(args.platform.<Flavor>map(InternalFlavor::of).orElse(pythonPlatforms.getFlavors().iterator().next())));
CxxPlatform cxxPlatform = cxxPlatforms.getValue(params.getBuildTarget()).orElse(defaultCxxPlatform);
SourcePathRuleFinder ruleFinder = new SourcePathRuleFinder(resolver);
SourcePathResolver pathResolver = new SourcePathResolver(ruleFinder);
Path baseModule = PythonUtil.getBasePath(params.getBuildTarget(), args.baseModule);
Optional<ImmutableMap<BuildTarget, Version>> selectedVersions = targetGraph.get(params.getBuildTarget()).getSelectedVersions();
ImmutableMap<Path, SourcePath> srcs = PythonUtil.getModules(params.getBuildTarget(), resolver, ruleFinder, pathResolver, pythonPlatform, cxxPlatform, "srcs", baseModule, args.srcs, args.platformSrcs, args.versionedSrcs, selectedVersions);
ImmutableMap<Path, SourcePath> resources = PythonUtil.getModules(params.getBuildTarget(), resolver, ruleFinder, pathResolver, pythonPlatform, cxxPlatform, "resources", baseModule, args.resources, args.platformResources, args.versionedResources, selectedVersions);
// Convert the passed in module paths into test module names.
ImmutableSet.Builder<String> testModulesBuilder = ImmutableSet.builder();
for (Path name : srcs.keySet()) {
testModulesBuilder.add(PythonUtil.toModuleName(params.getBuildTarget(), name.toString()));
}
ImmutableSet<String> testModules = testModulesBuilder.build();
// Construct a build rule to generate the test modules list source file and
// add it to the build.
BuildRule testModulesBuildRule = createTestModulesSourceBuildRule(params, getTestModulesListPath(params.getBuildTarget(), params.getProjectFilesystem()), testModules);
resolver.addToIndex(testModulesBuildRule);
String mainModule;
if (args.mainModule.isPresent()) {
mainModule = args.mainModule.get();
} else {
mainModule = PythonUtil.toModuleName(params.getBuildTarget(), getTestMainName().toString());
}
// Build up the list of everything going into the python test.
PythonPackageComponents testComponents = PythonPackageComponents.of(ImmutableMap.<Path, SourcePath>builder().put(getTestModulesListName(), testModulesBuildRule.getSourcePathToOutput()).put(getTestMainName(), pythonBuckConfig.getPathToTestMain(params.getProjectFilesystem())).putAll(srcs).build(), resources, ImmutableMap.of(), ImmutableSet.of(), args.zipSafe);
PythonPackageComponents allComponents = PythonUtil.getAllComponents(params, resolver, ruleFinder, testComponents, pythonPlatform, cxxBuckConfig, cxxPlatform, args.linkerFlags.stream().map(MacroArg.toMacroArgFunction(PythonUtil.MACRO_HANDLER, params.getBuildTarget(), params.getCellRoots(), resolver)::apply).collect(MoreCollectors.toImmutableList()), pythonBuckConfig.getNativeLinkStrategy(), args.preloadDeps);
// Build the PEX using a python binary rule with the minimum dependencies.
PythonBinary binary = binaryDescription.createPackageRule(params.withBuildTarget(getBinaryBuildTarget(params.getBuildTarget())), resolver, ruleFinder, pythonPlatform, cxxPlatform, mainModule, args.extension, allComponents, args.buildArgs, args.packageStyle.orElse(pythonBuckConfig.getPackageStyle()), PythonUtil.getPreloadNames(resolver, cxxPlatform, args.preloadDeps));
resolver.addToIndex(binary);
ImmutableList.Builder<Pair<Float, ImmutableSet<Path>>> neededCoverageBuilder = ImmutableList.builder();
for (NeededCoverageSpec coverageSpec : args.neededCoverage) {
BuildRule buildRule = resolver.getRule(coverageSpec.getBuildTarget());
if (params.getDeps().contains(buildRule) && buildRule instanceof PythonLibrary) {
PythonLibrary pythonLibrary = (PythonLibrary) buildRule;
ImmutableSortedSet<Path> paths;
if (coverageSpec.getPathName().isPresent()) {
Path path = coverageSpec.getBuildTarget().getBasePath().resolve(coverageSpec.getPathName().get());
if (!pythonLibrary.getPythonPackageComponents(pythonPlatform, cxxPlatform).getModules().keySet().contains(path)) {
throw new HumanReadableException("%s: path %s specified in needed_coverage not found in target %s", params.getBuildTarget(), path, buildRule.getBuildTarget());
}
paths = ImmutableSortedSet.of(path);
} else {
paths = ImmutableSortedSet.copyOf(pythonLibrary.getPythonPackageComponents(pythonPlatform, cxxPlatform).getModules().keySet());
}
neededCoverageBuilder.add(new Pair<Float, ImmutableSet<Path>>(coverageSpec.getNeededCoverageRatio(), paths));
} else {
throw new HumanReadableException("%s: needed_coverage requires a python library dependency. Found %s instead", params.getBuildTarget(), buildRule);
}
}
Supplier<ImmutableMap<String, String>> testEnv = () -> ImmutableMap.copyOf(Maps.transformValues(args.env, MACRO_HANDLER.getExpander(params.getBuildTarget(), params.getCellRoots(), resolver)));
// Generate and return the python test rule, which depends on the python binary rule above.
return PythonTest.from(params, ruleFinder, testEnv, binary, args.labels, neededCoverageBuilder.build(), args.testRuleTimeoutMs.map(Optional::of).orElse(defaultTestRuleTimeoutMs), args.contacts);
}
use of java.util.Optional in project buck by facebook.
the class CachingBuildEngine method processBuildRule.
private ListenableFuture<BuildResult> processBuildRule(final BuildRule rule, final BuildEngineBuildContext buildContext, final ExecutionContext executionContext, final OnDiskBuildInfo onDiskBuildInfo, final BuildInfoRecorder buildInfoRecorder, final BuildableContext buildableContext, final ConcurrentLinkedQueue<ListenableFuture<Void>> asyncCallbacks) {
// If we've already seen a failure, exit early.
if (!buildContext.isKeepGoing() && firstFailure != null) {
return Futures.immediateFuture(BuildResult.canceled(rule, firstFailure));
}
final RuleKeyFactories ruleKeyFactory = ruleKeyFactories.apply(rule.getProjectFilesystem());
try (BuildRuleEvent.Scope scope = BuildRuleEvent.resumeSuspendScope(buildContext.getEventBus(), rule, buildRuleDurationTracker, ruleKeyFactory.getDefaultRuleKeyFactory())) {
// 1. Check if it's already built.
Optional<RuleKey> cachedRuleKey = onDiskBuildInfo.getRuleKey(BuildInfo.MetadataKey.RULE_KEY);
final RuleKey defaultRuleKey = ruleKeyFactory.getDefaultRuleKeyFactory().build(rule);
if (defaultRuleKey.equals(cachedRuleKey.orElse(null))) {
return Futures.transform(markRuleAsUsed(rule, buildContext.getEventBus()), Functions.constant(BuildResult.success(rule, BuildRuleSuccessType.MATCHING_RULE_KEY, CacheResult.localKeyUnchangedHit())));
}
// 2. Rule key cache lookup.
ListenableFuture<CacheResult> rulekeyCacheResult = cacheActivityService.submit(() -> {
CacheResult cacheResult = tryToFetchArtifactFromBuildCacheAndOverlayOnTopOfProjectFilesystem(rule, defaultRuleKey, buildContext.getArtifactCache(), // TODO(shs96c): This should be a shared between all tests, not one per cell
rule.getProjectFilesystem(), buildContext);
if (cacheResult.getType().isSuccess()) {
fillMissingBuildMetadataFromCache(cacheResult, buildInfoRecorder, BuildInfo.MetadataKey.INPUT_BASED_RULE_KEY, BuildInfo.MetadataKey.DEP_FILE_RULE_KEY, BuildInfo.MetadataKey.DEP_FILE);
}
return cacheResult;
}, CACHE_CHECK_RESOURCE_AMOUNTS);
return Futures.transformAsync(rulekeyCacheResult, ruleAsyncFunction(rule, buildContext.getEventBus(), (cacheResult) -> handleRuleKeyCacheResult(rule, buildContext, executionContext, onDiskBuildInfo, buildInfoRecorder, buildableContext, asyncCallbacks, ruleKeyFactory, cacheResult)), serviceByAdjustingDefaultWeightsTo(SCHEDULING_MORE_WORK_RESOURCE_AMOUNTS));
}
}
use of java.util.Optional in project buck by facebook.
the class PrebuiltOcamlLibraryDescription method createBuildRule.
@Override
public <A extends Arg> OcamlLibrary createBuildRule(TargetGraph targetGraph, final BuildRuleParams params, BuildRuleResolver resolver, final A args) {
final BuildTarget target = params.getBuildTarget();
final boolean bytecodeOnly = args.bytecodeOnly.orElse(false);
final String libDir = args.libDir.orElse("lib");
final String libName = args.libName.orElse(target.getShortName());
final String nativeLib = args.nativeLib.orElse(String.format("%s.cmxa", libName));
final String bytecodeLib = args.bytecodeLib.orElse(String.format("%s.cma", libName));
final ImmutableList<String> cLibs = args.cLibs;
final Path libPath = target.getBasePath().resolve(libDir);
final Path includeDir = libPath.resolve(args.includeDir.orElse(""));
final Optional<SourcePath> staticNativeLibraryPath = bytecodeOnly ? Optional.empty() : Optional.of(new PathSourcePath(params.getProjectFilesystem(), libPath.resolve(nativeLib)));
final SourcePath staticBytecodeLibraryPath = new PathSourcePath(params.getProjectFilesystem(), libPath.resolve(bytecodeLib));
final ImmutableList<SourcePath> staticCLibraryPaths = cLibs.stream().map(input -> new PathSourcePath(params.getProjectFilesystem(), libPath.resolve(input))).collect(MoreCollectors.toImmutableList());
final SourcePath bytecodeLibraryPath = new PathSourcePath(params.getProjectFilesystem(), libPath.resolve(bytecodeLib));
SourcePathRuleFinder ruleFinder = new SourcePathRuleFinder(resolver);
return new PrebuiltOcamlLibrary(params, ruleFinder, staticNativeLibraryPath, staticBytecodeLibraryPath, staticCLibraryPaths, bytecodeLibraryPath, libPath, includeDir);
}
use of java.util.Optional in project buck by facebook.
the class DaemonicCellState method invalidateIfBuckConfigHasChanged.
void invalidateIfBuckConfigHasChanged(Cell cell, Path buildFile) {
// TODO(mzlee): Check whether usedConfigs includes the buildFileName
ImmutableMap<String, ImmutableMap<String, Optional<String>>> usedConfigs;
try (AutoCloseableLock readLock = rawAndComputedNodesLock.readLock()) {
usedConfigs = buildFileConfigs.get(buildFile);
}
if (usedConfigs == null) {
// TODO(mzlee): Figure out when/how we can safely update this
this.cell.set(cell);
return;
}
for (Map.Entry<String, ImmutableMap<String, Optional<String>>> keyEnt : usedConfigs.entrySet()) {
for (Map.Entry<String, Optional<String>> valueEnt : keyEnt.getValue().entrySet()) {
Optional<String> value = cell.getBuckConfig().getValue(keyEnt.getKey(), valueEnt.getKey());
if (!value.equals(valueEnt.getValue())) {
invalidatePath(buildFile);
this.cell.set(cell);
return;
}
}
}
}
Aggregations