Examples with NoSuchBuildTargetException com.facebook.buck.parser.NoSuchBuildTargetException used on opensource projects

Example 26 with NoSuchBuildTargetException

use of com.facebook.buck.parser.NoSuchBuildTargetException in project buck by facebook.

the class PrebuiltCxxLibraryDescription method createBuildRule.

@Override
public <A extends Arg> BuildRule createBuildRule(TargetGraph targetGraph, final BuildRuleParams params, final BuildRuleResolver ruleResolver, final A args) throws NoSuchBuildTargetException {
    // See if we're building a particular "type" of this library, and if so, extract
    // it as an enum.
    Optional<Map.Entry<Flavor, Type>> type = LIBRARY_TYPE.getFlavorAndValue(params.getBuildTarget());
    Optional<Map.Entry<Flavor, CxxPlatform>> platform = cxxPlatforms.getFlavorAndValue(params.getBuildTarget());
    Optional<ImmutableMap<BuildTarget, Version>> selectedVersions = targetGraph.get(params.getBuildTarget()).getSelectedVersions();
    final Optional<String> versionSubdir = selectedVersions.isPresent() && args.versionedSubDir.isPresent() ? Optional.of(args.versionedSubDir.get().getOnlyMatchingValue(selectedVersions.get())) : Optional.empty();
    // pre-existing static lib, which we do here.
    if (type.isPresent()) {
        Preconditions.checkState(platform.isPresent());
        BuildTarget baseTarget = params.getBuildTarget().withoutFlavors(type.get().getKey(), platform.get().getKey());
        if (type.get().getValue() == Type.EXPORTED_HEADERS) {
            return createExportedHeaderSymlinkTreeBuildRule(params, ruleResolver, platform.get().getValue(), args);
        } else if (type.get().getValue() == Type.SHARED) {
            return createSharedLibraryBuildRule(params, ruleResolver, platform.get().getValue(), selectedVersions, args);
        } else if (type.get().getValue() == Type.SHARED_INTERFACE) {
            return createSharedLibraryInterface(baseTarget, params, ruleResolver, platform.get().getValue(), versionSubdir, args);
        }
    }
    if (selectedVersions.isPresent() && args.versionedSubDir.isPresent()) {
        ImmutableList<String> versionSubDirs = args.versionedSubDir.orElse(VersionMatchedCollection.<String>of()).getMatchingValues(selectedVersions.get());
        if (versionSubDirs.size() != 1) {
            throw new HumanReadableException("%s: could not get a single version sub dir: %s, %s, %s", params.getBuildTarget(), args.versionedSubDir, versionSubDirs, selectedVersions);
        }
    }
    // Otherwise, we return the generic placeholder of this library, that dependents can use
    // get the real build rules via querying the action graph.
    final SourcePathResolver pathResolver = new SourcePathResolver(new SourcePathRuleFinder(ruleResolver));
    final boolean headerOnly = args.headerOnly.orElse(false);
    final boolean forceStatic = args.forceStatic.orElse(false);
    return new PrebuiltCxxLibrary(params) {

        private final Map<Pair<Flavor, Linker.LinkableDepType>, NativeLinkableInput> nativeLinkableCache = new HashMap<>();

        private final LoadingCache<CxxPreprocessables.CxxPreprocessorInputCacheKey, ImmutableMap<BuildTarget, CxxPreprocessorInput>> transitiveCxxPreprocessorInputCache = CxxPreprocessables.getTransitiveCxxPreprocessorInputCache(this);

        private boolean hasHeaders(CxxPlatform cxxPlatform) {
            if (!args.exportedHeaders.isEmpty()) {
                return true;
            }
            for (SourceList sourceList : args.exportedPlatformHeaders.getMatchingValues(cxxPlatform.getFlavor().toString())) {
                if (!sourceList.isEmpty()) {
                    return true;
                }
            }
            return false;
        }

        private ImmutableListMultimap<CxxSource.Type, String> getExportedPreprocessorFlags(CxxPlatform cxxPlatform) {
            return CxxFlags.getLanguageFlags(args.exportedPreprocessorFlags, args.exportedPlatformPreprocessorFlags, args.exportedLangPreprocessorFlags, cxxPlatform);
        }

        @Override
        public ImmutableList<String> getExportedLinkerFlags(CxxPlatform cxxPlatform) {
            return CxxFlags.getFlagsWithPlatformMacroExpansion(args.exportedLinkerFlags, args.exportedPlatformLinkerFlags, cxxPlatform);
        }

        private String getSoname(CxxPlatform cxxPlatform) {
            return PrebuiltCxxLibraryDescription.getSoname(getBuildTarget(), params.getCellRoots(), ruleResolver, cxxPlatform, args.soname, args.libName);
        }

        private boolean isPlatformSupported(CxxPlatform cxxPlatform) {
            return !args.supportedPlatformsRegex.isPresent() || args.supportedPlatformsRegex.get().matcher(cxxPlatform.getFlavor().toString()).find();
        }

        /**
       * Makes sure all build rules needed to produce the shared library are added to the action
       * graph.
       *
       * @return the {@link SourcePath} representing the actual shared library.
       */
        private SourcePath requireSharedLibrary(CxxPlatform cxxPlatform, boolean link) throws NoSuchBuildTargetException {
            if (link && args.supportsSharedLibraryInterface && cxxPlatform.getSharedLibraryInterfaceFactory().isPresent()) {
                BuildTarget target = params.getBuildTarget().withAppendedFlavors(cxxPlatform.getFlavor(), Type.SHARED_INTERFACE.getFlavor());
                BuildRule rule = ruleResolver.requireRule(target);
                return Preconditions.checkNotNull(rule.getSourcePathToOutput());
            }
            return PrebuiltCxxLibraryDescription.this.requireSharedLibrary(params.getBuildTarget(), ruleResolver, pathResolver, params.getCellRoots(), params.getProjectFilesystem(), cxxPlatform, versionSubdir, args);
        }

        /**
       * @return the {@link Optional} containing a {@link SourcePath} representing the actual
       * static PIC library.
       */
        private Optional<SourcePath> getStaticPicLibrary(CxxPlatform cxxPlatform) {
            SourcePath staticPicLibraryPath = PrebuiltCxxLibraryDescription.getStaticPicLibraryPath(getBuildTarget(), params.getCellRoots(), params.getProjectFilesystem(), ruleResolver, cxxPlatform, versionSubdir, args.libDir, args.libName);
            if (params.getProjectFilesystem().exists(pathResolver.getAbsolutePath(staticPicLibraryPath))) {
                return Optional.of(staticPicLibraryPath);
            }
            // If a specific static-pic variant isn't available, then just use the static variant.
            SourcePath staticLibraryPath = PrebuiltCxxLibraryDescription.getStaticLibraryPath(getBuildTarget(), params.getCellRoots(), getProjectFilesystem(), ruleResolver, cxxPlatform, versionSubdir, args.libDir, args.libName);
            if (params.getProjectFilesystem().exists(pathResolver.getAbsolutePath(staticLibraryPath))) {
                return Optional.of(staticLibraryPath);
            }
            return Optional.empty();
        }

        @Override
        public Iterable<? extends CxxPreprocessorDep> getCxxPreprocessorDeps(CxxPlatform cxxPlatform) {
            if (!isPlatformSupported(cxxPlatform)) {
                return ImmutableList.of();
            }
            return FluentIterable.from(getDeps()).filter(CxxPreprocessorDep.class);
        }

        @Override
        public CxxPreprocessorInput getCxxPreprocessorInput(final CxxPlatform cxxPlatform, HeaderVisibility headerVisibility) throws NoSuchBuildTargetException {
            CxxPreprocessorInput.Builder builder = CxxPreprocessorInput.builder();
            switch(headerVisibility) {
                case PUBLIC:
                    if (hasHeaders(cxxPlatform)) {
                        CxxPreprocessables.addHeaderSymlinkTree(builder, getBuildTarget(), ruleResolver, cxxPlatform, headerVisibility, CxxPreprocessables.IncludeType.SYSTEM);
                    }
                    builder.putAllPreprocessorFlags(Preconditions.checkNotNull(getExportedPreprocessorFlags(cxxPlatform)));
                    builder.addAllFrameworks(args.frameworks);
                    final Iterable<SourcePath> includePaths = args.includeDirs.stream().map(input -> PrebuiltCxxLibraryDescription.getApplicableSourcePath(params.getBuildTarget(), params.getCellRoots(), params.getProjectFilesystem(), ruleResolver, cxxPlatform, versionSubdir, input, Optional.empty())).collect(MoreCollectors.toImmutableList());
                    for (SourcePath includePath : includePaths) {
                        builder.addIncludes(CxxHeadersDir.of(CxxPreprocessables.IncludeType.SYSTEM, includePath));
                    }
                    return builder.build();
                case PRIVATE:
                    return builder.build();
            }
            // want the compiler to warn if someone modifies the HeaderVisibility enum.
            throw new RuntimeException("Invalid header visibility: " + headerVisibility);
        }

        @Override
        public Optional<HeaderSymlinkTree> getExportedHeaderSymlinkTree(CxxPlatform cxxPlatform) {
            if (hasHeaders(cxxPlatform)) {
                return Optional.of(CxxPreprocessables.requireHeaderSymlinkTreeForLibraryTarget(ruleResolver, getBuildTarget(), cxxPlatform.getFlavor()));
            } else {
                return Optional.empty();
            }
        }

        @Override
        public ImmutableMap<BuildTarget, CxxPreprocessorInput> getTransitiveCxxPreprocessorInput(CxxPlatform cxxPlatform, HeaderVisibility headerVisibility) throws NoSuchBuildTargetException {
            return transitiveCxxPreprocessorInputCache.getUnchecked(ImmutableCxxPreprocessorInputCacheKey.of(cxxPlatform, headerVisibility));
        }

        @Override
        public Iterable<NativeLinkable> getNativeLinkableDeps() {
            return getDeclaredDeps().stream().filter(r -> r instanceof NativeLinkable).map(r -> (NativeLinkable) r).collect(MoreCollectors.toImmutableList());
        }

        @Override
        public Iterable<NativeLinkable> getNativeLinkableDepsForPlatform(CxxPlatform cxxPlatform) {
            if (!isPlatformSupported(cxxPlatform)) {
                return ImmutableList.of();
            }
            return getNativeLinkableDeps();
        }

        @Override
        public Iterable<? extends NativeLinkable> getNativeLinkableExportedDeps() {
            return args.exportedDeps.stream().map(ruleResolver::getRule).filter(r -> r instanceof NativeLinkable).map(r -> (NativeLinkable) r).collect(MoreCollectors.toImmutableList());
        }

        @Override
        public Iterable<? extends NativeLinkable> getNativeLinkableExportedDepsForPlatform(CxxPlatform cxxPlatform) {
            if (!isPlatformSupported(cxxPlatform)) {
                return ImmutableList.of();
            }
            return getNativeLinkableExportedDeps();
        }

        private NativeLinkableInput getNativeLinkableInputUncached(CxxPlatform cxxPlatform, Linker.LinkableDepType type) throws NoSuchBuildTargetException {
            if (!isPlatformSupported(cxxPlatform)) {
                return NativeLinkableInput.of();
            }
            // Build the library path and linker arguments that we pass through the
            // {@link NativeLinkable} interface for linking.
            ImmutableList.Builder<com.facebook.buck.rules.args.Arg> linkerArgsBuilder = ImmutableList.builder();
            linkerArgsBuilder.addAll(StringArg.from(Preconditions.checkNotNull(getExportedLinkerFlags(cxxPlatform))));
            if (!headerOnly) {
                if (type == Linker.LinkableDepType.SHARED) {
                    Preconditions.checkState(getPreferredLinkage(cxxPlatform) != Linkage.STATIC);
                    final SourcePath sharedLibrary = requireSharedLibrary(cxxPlatform, true);
                    if (args.linkWithoutSoname) {
                        if (!(sharedLibrary instanceof PathSourcePath)) {
                            throw new HumanReadableException("%s: can only link prebuilt DSOs without sonames", getBuildTarget());
                        }
                        linkerArgsBuilder.add(new RelativeLinkArg((PathSourcePath) sharedLibrary));
                    } else {
                        linkerArgsBuilder.add(SourcePathArg.of(requireSharedLibrary(cxxPlatform, true)));
                    }
                } else {
                    Preconditions.checkState(getPreferredLinkage(cxxPlatform) != Linkage.SHARED);
                    SourcePath staticLibraryPath = type == Linker.LinkableDepType.STATIC_PIC ? getStaticPicLibrary(cxxPlatform).get() : PrebuiltCxxLibraryDescription.getStaticLibraryPath(getBuildTarget(), params.getCellRoots(), params.getProjectFilesystem(), ruleResolver, cxxPlatform, versionSubdir, args.libDir, args.libName);
                    SourcePathArg staticLibrary = SourcePathArg.of(staticLibraryPath);
                    if (args.linkWhole) {
                        Linker linker = cxxPlatform.getLd().resolve(ruleResolver);
                        linkerArgsBuilder.addAll(linker.linkWhole(staticLibrary));
                    } else {
                        linkerArgsBuilder.add(FileListableLinkerInputArg.withSourcePathArg(staticLibrary));
                    }
                }
            }
            final ImmutableList<com.facebook.buck.rules.args.Arg> linkerArgs = linkerArgsBuilder.build();
            return NativeLinkableInput.of(linkerArgs, args.frameworks, args.libraries);
        }

        @Override
        public NativeLinkableInput getNativeLinkableInput(CxxPlatform cxxPlatform, Linker.LinkableDepType type) throws NoSuchBuildTargetException {
            Pair<Flavor, Linker.LinkableDepType> key = new Pair<>(cxxPlatform.getFlavor(), type);
            NativeLinkableInput input = nativeLinkableCache.get(key);
            if (input == null) {
                input = getNativeLinkableInputUncached(cxxPlatform, type);
                nativeLinkableCache.put(key, input);
            }
            return input;
        }

        @Override
        public NativeLinkable.Linkage getPreferredLinkage(CxxPlatform cxxPlatform) {
            if (headerOnly) {
                return Linkage.ANY;
            }
            if (forceStatic) {
                return Linkage.STATIC;
            }
            if (args.provided || !getStaticPicLibrary(cxxPlatform).isPresent()) {
                return Linkage.SHARED;
            }
            return Linkage.ANY;
        }

        @Override
        public Iterable<AndroidPackageable> getRequiredPackageables() {
            return AndroidPackageableCollector.getPackageableRules(params.getDeps());
        }

        @Override
        public void addToCollector(AndroidPackageableCollector collector) {
            if (args.canBeAsset) {
                collector.addNativeLinkableAsset(this);
            } else {
                collector.addNativeLinkable(this);
            }
        }

        @Override
        public ImmutableMap<String, SourcePath> getSharedLibraries(CxxPlatform cxxPlatform) throws NoSuchBuildTargetException {
            if (!isPlatformSupported(cxxPlatform)) {
                return ImmutableMap.of();
            }
            String resolvedSoname = getSoname(cxxPlatform);
            ImmutableMap.Builder<String, SourcePath> solibs = ImmutableMap.builder();
            if (!headerOnly && !args.provided) {
                SourcePath sharedLibrary = requireSharedLibrary(cxxPlatform, false);
                solibs.put(resolvedSoname, sharedLibrary);
            }
            return solibs.build();
        }

        @Override
        public Optional<NativeLinkTarget> getNativeLinkTarget(CxxPlatform cxxPlatform) {
            if (getPreferredLinkage(cxxPlatform) == Linkage.SHARED) {
                return Optional.empty();
            }
            return Optional.of(new NativeLinkTarget() {

                @Override
                public BuildTarget getBuildTarget() {
                    return params.getBuildTarget();
                }

                @Override
                public NativeLinkTargetMode getNativeLinkTargetMode(CxxPlatform cxxPlatform) {
                    return NativeLinkTargetMode.library(getSoname(cxxPlatform));
                }

                @Override
                public Iterable<? extends NativeLinkable> getNativeLinkTargetDeps(CxxPlatform cxxPlatform) {
                    return Iterables.concat(getNativeLinkableDepsForPlatform(cxxPlatform), getNativeLinkableExportedDepsForPlatform(cxxPlatform));
                }

                @Override
                public NativeLinkableInput getNativeLinkTargetInput(CxxPlatform cxxPlatform) throws NoSuchBuildTargetException {
                    return NativeLinkableInput.builder().addAllArgs(StringArg.from(getExportedLinkerFlags(cxxPlatform))).addAllArgs(cxxPlatform.getLd().resolve(ruleResolver).linkWhole(SourcePathArg.of(getStaticPicLibrary(cxxPlatform).get()))).build();
                }

                @Override
                public Optional<Path> getNativeLinkTargetOutputPath(CxxPlatform cxxPlatform) {
                    return Optional.empty();
                }
            });
        }
    };
}

Example 27 with NoSuchBuildTargetException

use of com.facebook.buck.parser.NoSuchBuildTargetException in project buck by facebook.

the class OcamlRuleBuilder method createFineGrainedBuildRule.

public static BuildRule createFineGrainedBuildRule(OcamlBuckConfig ocamlBuckConfig, final BuildRuleParams params, BuildRuleResolver resolver, ImmutableList<OcamlSource> srcs, boolean isLibrary, boolean bytecodeOnly, ImmutableList<Arg> argFlags, final ImmutableList<String> linkerFlags, boolean buildNativePlugin) throws NoSuchBuildTargetException {
    CxxPreprocessorInput cxxPreprocessorInputFromDeps = CxxPreprocessorInput.concat(CxxPreprocessables.getTransitiveCxxPreprocessorInput(ocamlBuckConfig.getCxxPlatform(), FluentIterable.from(params.getDeps()).filter(CxxPreprocessorDep.class::isInstance)));
    SourcePathRuleFinder ruleFinder = new SourcePathRuleFinder(resolver);
    SourcePathResolver pathResolver = new SourcePathResolver(ruleFinder);
    ImmutableList<String> nativeIncludes = FluentIterable.from(params.getDeps()).transformAndConcat(getLibInclude(false)).toList();
    ImmutableList<String> bytecodeIncludes = FluentIterable.from(params.getDeps()).transformAndConcat(getLibInclude(true)).toList();
    NativeLinkableInput nativeLinkableInput = getNativeLinkableInput(params.getDeps());
    NativeLinkableInput bytecodeLinkableInput = getBytecodeLinkableInput(params.getDeps());
    NativeLinkableInput cLinkableInput = getCLinkableInput(ocamlBuckConfig.getCxxPlatform(), params.getDeps());
    ImmutableList<OcamlLibrary> ocamlInput = OcamlUtil.getTransitiveOcamlInput(params.getDeps());
    BuildTarget buildTarget = isLibrary ? createStaticLibraryBuildTarget(params.getBuildTarget()) : createOcamlLinkTarget(params.getBuildTarget());
    final BuildRuleParams compileParams = params.withBuildTarget(buildTarget).copyReplacingDeclaredAndExtraDeps(Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>naturalOrder().addAll(ruleFinder.filterBuildRuleInputs(getInput(srcs))).addAll(Stream.of(nativeLinkableInput, bytecodeLinkableInput, cLinkableInput).flatMap(input -> input.getArgs().stream()).flatMap(arg -> arg.getDeps(ruleFinder).stream()).iterator()).addAll(argFlags.stream().flatMap(arg -> arg.getDeps(ruleFinder).stream()).iterator()).addAll(ruleFinder.filterBuildRuleInputs(ocamlBuckConfig.getCCompiler().resolve(resolver).getInputs())).addAll(ruleFinder.filterBuildRuleInputs(ocamlBuckConfig.getCxxCompiler().resolve(resolver).getInputs())).build()), Suppliers.ofInstance(ImmutableSortedSet.of()));
    ImmutableList.Builder<Arg> flagsBuilder = ImmutableList.builder();
    flagsBuilder.addAll(argFlags);
    ImmutableSortedSet.Builder<BuildRule> nativeCompileDepsBuilder = ImmutableSortedSet.naturalOrder();
    ImmutableSortedSet.Builder<BuildRule> bytecodeCompileDepsBuilder = ImmutableSortedSet.naturalOrder();
    ImmutableSortedSet.Builder<BuildRule> bytecodeLinkDepsBuilder = ImmutableSortedSet.naturalOrder();
    for (OcamlLibrary library : ocamlInput) {
        nativeCompileDepsBuilder.addAll(library.getNativeCompileDeps());
        bytecodeCompileDepsBuilder.addAll(library.getBytecodeCompileDeps());
        bytecodeLinkDepsBuilder.addAll(library.getBytecodeLinkDeps());
    }
    OcamlBuildContext ocamlContext = OcamlBuildContext.builder(ocamlBuckConfig).setProjectFilesystem(params.getProjectFilesystem()).setSourcePathResolver(pathResolver).setFlags(flagsBuilder.build()).setNativeIncludes(nativeIncludes).setBytecodeIncludes(bytecodeIncludes).setOcamlInput(ocamlInput).setNativeLinkableInput(nativeLinkableInput).setBytecodeLinkableInput(bytecodeLinkableInput).setCLinkableInput(cLinkableInput).setBuildTarget(buildTarget.getUnflavoredBuildTarget()).setLibrary(isLibrary).setCxxPreprocessorInput(cxxPreprocessorInputFromDeps).setInput(getInput(srcs)).setNativeCompileDeps(nativeCompileDepsBuilder.build()).setBytecodeCompileDeps(bytecodeCompileDepsBuilder.build()).setBytecodeLinkDeps(bytecodeLinkDepsBuilder.build()).setCPreprocessor(ocamlBuckConfig.getCPreprocessor().resolve(resolver)).build();
    Path baseDir = params.getProjectFilesystem().getRootPath().toAbsolutePath();
    ImmutableMap<Path, ImmutableList<Path>> mlInput = getMLInputWithDeps(baseDir, ocamlContext);
    ImmutableList<SourcePath> cInput = getCInput(pathResolver, getInput(srcs));
    OcamlBuildRulesGenerator generator = new OcamlBuildRulesGenerator(compileParams, pathResolver, ruleFinder, resolver, ocamlContext, mlInput, cInput, ocamlBuckConfig.getCCompiler().resolve(resolver), ocamlBuckConfig.getCxxCompiler().resolve(resolver), bytecodeOnly, buildNativePlugin);
    OcamlGeneratedBuildRules result = generator.generate();
    if (isLibrary) {
        return new OcamlStaticLibrary(params.copyReplacingDeclaredAndExtraDeps(Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>naturalOrder().addAll(params.getDeclaredDeps().get()).addAll(result.getRules()).build()), params.getExtraDeps()), compileParams, linkerFlags, result.getObjectFiles(), ocamlContext, result.getRules().get(0), result.getNativeCompileDeps(), result.getBytecodeCompileDeps(), ImmutableSortedSet.<BuildRule>naturalOrder().add(result.getBytecodeLink()).addAll(ruleFinder.filterBuildRuleInputs(result.getObjectFiles())).build());
    } else {
        return new OcamlBinary(params.copyReplacingDeclaredAndExtraDeps(Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>naturalOrder().addAll(params.getDeclaredDeps().get()).addAll(result.getRules()).build()), params.getExtraDeps()), result.getRules().get(0));
    }
}

Example 28 with NoSuchBuildTargetException

use of com.facebook.buck.parser.NoSuchBuildTargetException in project buck by facebook.

the class OcamlRuleBuilder method createBulkBuildRule.

public static BuildRule createBulkBuildRule(OcamlBuckConfig ocamlBuckConfig, final BuildRuleParams params, BuildRuleResolver resolver, ImmutableList<OcamlSource> srcs, boolean isLibrary, boolean bytecodeOnly, ImmutableList<Arg> argFlags, final ImmutableList<String> linkerFlags) throws NoSuchBuildTargetException {
    CxxPreprocessorInput cxxPreprocessorInputFromDeps = CxxPreprocessorInput.concat(CxxPreprocessables.getTransitiveCxxPreprocessorInput(ocamlBuckConfig.getCxxPlatform(), FluentIterable.from(params.getDeps()).filter(CxxPreprocessorDep.class::isInstance)));
    SourcePathRuleFinder ruleFinder = new SourcePathRuleFinder(resolver);
    SourcePathResolver pathResolver = new SourcePathResolver(ruleFinder);
    ImmutableList<String> nativeIncludes = FluentIterable.from(params.getDeps()).transformAndConcat(getLibInclude(false)).toList();
    ImmutableList<String> bytecodeIncludes = FluentIterable.from(params.getDeps()).transformAndConcat(getLibInclude(true)).toList();
    NativeLinkableInput nativeLinkableInput = getNativeLinkableInput(params.getDeps());
    NativeLinkableInput bytecodeLinkableInput = getBytecodeLinkableInput(params.getDeps());
    NativeLinkableInput cLinkableInput = getCLinkableInput(ocamlBuckConfig.getCxxPlatform(), params.getDeps());
    ImmutableList<OcamlLibrary> ocamlInput = OcamlUtil.getTransitiveOcamlInput(params.getDeps());
    ImmutableSortedSet.Builder<BuildRule> allDepsBuilder = ImmutableSortedSet.naturalOrder();
    allDepsBuilder.addAll(ruleFinder.filterBuildRuleInputs(getInput(srcs)));
    allDepsBuilder.addAll(Stream.of(nativeLinkableInput, bytecodeLinkableInput, cLinkableInput).flatMap(input -> input.getArgs().stream()).flatMap(arg -> arg.getDeps(ruleFinder).stream()).iterator());
    for (OcamlLibrary library : ocamlInput) {
        allDepsBuilder.addAll(library.getNativeCompileDeps());
        allDepsBuilder.addAll(library.getBytecodeCompileDeps());
    }
    allDepsBuilder.addAll(ruleFinder.filterBuildRuleInputs(ocamlBuckConfig.getCCompiler().resolve(resolver).getInputs()));
    allDepsBuilder.addAll(ruleFinder.filterBuildRuleInputs(ocamlBuckConfig.getCxxCompiler().resolve(resolver).getInputs()));
    allDepsBuilder.addAll(argFlags.stream().flatMap(arg -> arg.getDeps(ruleFinder).stream()).iterator());
    // The bulk rule will do preprocessing on sources, and so needs deps from the preprocessor
    // input object.
    allDepsBuilder.addAll(cxxPreprocessorInputFromDeps.getDeps(resolver, ruleFinder));
    ImmutableSortedSet<BuildRule> allDeps = allDepsBuilder.build();
    BuildTarget buildTarget = isLibrary ? createStaticLibraryBuildTarget(params.getBuildTarget()) : createOcamlLinkTarget(params.getBuildTarget());
    final BuildRuleParams compileParams = params.withBuildTarget(buildTarget).copyReplacingDeclaredAndExtraDeps(Suppliers.ofInstance(allDeps), Suppliers.ofInstance(ImmutableSortedSet.of()));
    ImmutableList.Builder<Arg> flagsBuilder = ImmutableList.builder();
    flagsBuilder.addAll(argFlags);
    ImmutableSortedSet.Builder<BuildRule> nativeCompileDepsBuilder = ImmutableSortedSet.naturalOrder();
    ImmutableSortedSet.Builder<BuildRule> bytecodeCompileDepsBuilder = ImmutableSortedSet.naturalOrder();
    ImmutableSortedSet.Builder<BuildRule> bytecodeLinkDepsBuilder = ImmutableSortedSet.naturalOrder();
    for (OcamlLibrary library : ocamlInput) {
        nativeCompileDepsBuilder.addAll(library.getNativeCompileDeps());
        bytecodeCompileDepsBuilder.addAll(library.getBytecodeCompileDeps());
        bytecodeLinkDepsBuilder.addAll(library.getBytecodeLinkDeps());
    }
    OcamlBuildContext ocamlContext = OcamlBuildContext.builder(ocamlBuckConfig).setProjectFilesystem(params.getProjectFilesystem()).setSourcePathResolver(pathResolver).setFlags(flagsBuilder.build()).setNativeIncludes(nativeIncludes).setBytecodeIncludes(bytecodeIncludes).setOcamlInput(ocamlInput).setNativeLinkableInput(nativeLinkableInput).setBytecodeLinkableInput(bytecodeLinkableInput).setCLinkableInput(cLinkableInput).setBuildTarget(buildTarget.getUnflavoredBuildTarget()).setLibrary(isLibrary).setCxxPreprocessorInput(cxxPreprocessorInputFromDeps).setInput(getInput(srcs)).setNativeCompileDeps(nativeCompileDepsBuilder.build()).setBytecodeCompileDeps(bytecodeCompileDepsBuilder.build()).setBytecodeLinkDeps(bytecodeLinkDepsBuilder.build()).setCPreprocessor(ocamlBuckConfig.getCPreprocessor().resolve(resolver)).build();
    final OcamlBuild ocamlLibraryBuild = new OcamlBuild(compileParams, ocamlContext, ocamlBuckConfig.getCCompiler().resolve(resolver), ocamlBuckConfig.getCxxCompiler().resolve(resolver), bytecodeOnly);
    resolver.addToIndex(ocamlLibraryBuild);
    if (isLibrary) {
        return new OcamlStaticLibrary(params.copyReplacingDeclaredAndExtraDeps(Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>naturalOrder().addAll(params.getDeclaredDeps().get()).add(ocamlLibraryBuild).build()), params.getExtraDeps()), compileParams, linkerFlags, FluentIterable.from(srcs).transform(OcamlSource::getSource).transform(pathResolver::getAbsolutePath).filter(OcamlUtil.ext(OcamlCompilables.OCAML_C)).transform(ocamlContext::getCOutput).transform(input -> new ExplicitBuildTargetSourcePath(compileParams.getBuildTarget(), input)).toList(), ocamlContext, ocamlLibraryBuild, ImmutableSortedSet.of(ocamlLibraryBuild), ImmutableSortedSet.of(ocamlLibraryBuild), ImmutableSortedSet.of(ocamlLibraryBuild));
    } else {
        return new OcamlBinary(params.copyReplacingDeclaredAndExtraDeps(Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>naturalOrder().addAll(params.getDeclaredDeps().get()).add(ocamlLibraryBuild).build()), params.getExtraDeps()), ocamlLibraryBuild);
    }
}

Example 29 with NoSuchBuildTargetException

use of com.facebook.buck.parser.NoSuchBuildTargetException in project buck by facebook.

the class AbstractNodeBuilder method build.

public TargetNode<TArg, TDescription> build() {
    try {
        HashCode hash = rawHashCode == null ? Hashing.sha1().hashString(target.getFullyQualifiedName(), UTF_8) : rawHashCode;
        TargetNodeFactory factory = new TargetNodeFactory(TYPE_COERCER_FACTORY);
        TargetNode<TArg, TDescription> node = factory.create(// This hash will do in a pinch.
        hash, description, arg, filesystem, target, getDepsFromArg(), ImmutableSet.of(VISIBILITY_PATTERN_PARSER.parse(null, VisibilityPatternParser.VISIBILITY_PUBLIC)), cellRoots);
        if (selectedVersions.isPresent()) {
            node = node.withTargetConstructorArgDepsAndSelectedVerisons(node.getBuildTarget(), node.getConstructorArg(), node.getDeclaredDeps(), node.getExtraDeps(), selectedVersions);
        }
        return node;
    } catch (NoSuchBuildTargetException e) {
        throw new RuntimeException(e);
    }
}

Example 30 with NoSuchBuildTargetException

use of com.facebook.buck.parser.NoSuchBuildTargetException in project buck by facebook.

the class RustLibraryDescription method createBuildRule.

@Override
public <A extends Arg> BuildRule createBuildRule(TargetGraph targetGraph, BuildRuleParams params, BuildRuleResolver resolver, A args) throws NoSuchBuildTargetException {
    final BuildTarget buildTarget = params.getBuildTarget();
    SourcePathRuleFinder ruleFinder = new SourcePathRuleFinder(resolver);
    SourcePathResolver pathResolver = new SourcePathResolver(ruleFinder);
    ImmutableList.Builder<String> rustcArgs = ImmutableList.builder();
    RustCompileUtils.addFeatures(buildTarget, args.features, rustcArgs);
    rustcArgs.addAll(args.rustcFlags);
    rustcArgs.addAll(rustBuckConfig.getRustLibraryFlags());
    String crate = args.crate.orElse(ruleToCrateName(params.getBuildTarget().getShortName()));
    // See if we're building a particular "type" and "platform" of this library, and if so, extract
    // them from the flavors attached to the build target.
    Optional<Map.Entry<Flavor, RustDescriptionEnhancer.Type>> type = LIBRARY_TYPE.getFlavorAndValue(buildTarget);
    Optional<CxxPlatform> cxxPlatform = cxxPlatforms.getValue(buildTarget);
    if (type.isPresent()) {
        // Uncommon case - someone explicitly invoked buck to build a specific flavor as the
        // direct target.
        CrateType crateType = type.get().getValue().getCrateType();
        Linker.LinkableDepType depType;
        if (crateType.isDynamic()) {
            depType = Linker.LinkableDepType.SHARED;
        } else {
            if (crateType.isPic()) {
                depType = Linker.LinkableDepType.STATIC_PIC;
            } else {
                depType = Linker.LinkableDepType.STATIC;
            }
        }
        return requireBuild(params, resolver, pathResolver, ruleFinder, cxxPlatform.orElse(defaultCxxPlatform), rustBuckConfig, rustcArgs.build(), /* linkerArgs */
        ImmutableList.of(), /* linkerInputs */
        ImmutableList.of(), crate, crateType, depType, args);
    }
    // Common case - we're being invoked to satisfy some other rule's dependency.
    return new RustLibrary(params) {

        // RustLinkable
        @Override
        public com.facebook.buck.rules.args.Arg getLinkerArg(boolean direct, CxxPlatform cxxPlatform, Linker.LinkableDepType depType) {
            BuildRule rule;
            CrateType crateType;
            // the use of -rpath will break with flavored paths containing ','.
            switch(args.preferredLinkage) {
                case ANY:
                default:
                    switch(depType) {
                        case SHARED:
                            crateType = CrateType.DYLIB;
                            break;
                        case STATIC_PIC:
                            crateType = CrateType.RLIB_PIC;
                            break;
                        case STATIC:
                        default:
                            crateType = CrateType.RLIB;
                            break;
                    }
                    break;
                case SHARED:
                    crateType = CrateType.DYLIB;
                    break;
                case STATIC:
                    if (depType == Linker.LinkableDepType.STATIC) {
                        crateType = CrateType.RLIB;
                    } else {
                        crateType = CrateType.RLIB_PIC;
                    }
                    break;
            }
            try {
                rule = requireBuild(params, resolver, pathResolver, ruleFinder, cxxPlatform, rustBuckConfig, rustcArgs.build(), /* linkerArgs */
                ImmutableList.of(), /* linkerInputs */
                ImmutableList.of(), crate, crateType, depType, args);
            } catch (NoSuchBuildTargetException e) {
                throw new RuntimeException(e);
            }
            SourcePath rlib = rule.getSourcePathToOutput();
            return new RustLibraryArg(pathResolver, crate, rlib, direct, params.getDeps());
        }

        @Override
        public Linkage getPreferredLinkage() {
            return args.preferredLinkage;
        }

        @Override
        public ImmutableMap<String, SourcePath> getRustSharedLibraries(CxxPlatform cxxPlatform) throws NoSuchBuildTargetException {
            ImmutableMap.Builder<String, SourcePath> libs = ImmutableMap.builder();
            String sharedLibrarySoname = CrateType.DYLIB.filenameFor(crate, cxxPlatform);
            BuildRule sharedLibraryBuildRule = requireBuild(params, resolver, pathResolver, ruleFinder, cxxPlatform, rustBuckConfig, rustcArgs.build(), /* linkerArgs */
            ImmutableList.of(), /* linkerInputs */
            ImmutableList.of(), crate, CrateType.DYLIB, Linker.LinkableDepType.SHARED, args);
            libs.put(sharedLibrarySoname, sharedLibraryBuildRule.getSourcePathToOutput());
            return libs.build();
        }

        // NativeLinkable
        @Override
        public Iterable<? extends NativeLinkable> getNativeLinkableDeps() {
            return ImmutableList.of();
        }

        @Override
        public Iterable<? extends NativeLinkable> getNativeLinkableExportedDeps() {
            return FluentIterable.from(getDeps()).filter(NativeLinkable.class);
        }

        @Override
        public NativeLinkableInput getNativeLinkableInput(CxxPlatform cxxPlatform, Linker.LinkableDepType depType) throws NoSuchBuildTargetException {
            CrateType crateType;
            switch(depType) {
                case SHARED:
                    crateType = CrateType.CDYLIB;
                    break;
                case STATIC_PIC:
                    crateType = CrateType.STATIC_PIC;
                    break;
                case STATIC:
                default:
                    crateType = CrateType.STATIC;
                    break;
            }
            BuildRule rule = requireBuild(params, resolver, pathResolver, ruleFinder, cxxPlatform, rustBuckConfig, rustcArgs.build(), /* linkerArgs */
            ImmutableList.of(), /* linkerInputs */
            ImmutableList.of(), crate, crateType, depType, args);
            SourcePath lib = rule.getSourcePathToOutput();
            SourcePathArg arg = SourcePathArg.of(lib);
            return NativeLinkableInput.builder().addArgs(arg).build();
        }

        @Override
        public Linkage getPreferredLinkage(CxxPlatform cxxPlatform) {
            return args.preferredLinkage;
        }

        @Override
        public ImmutableMap<String, SourcePath> getSharedLibraries(CxxPlatform cxxPlatform) throws NoSuchBuildTargetException {
            ImmutableMap.Builder<String, SourcePath> libs = ImmutableMap.builder();
            String sharedLibrarySoname = CxxDescriptionEnhancer.getSharedLibrarySoname(Optional.empty(), getBuildTarget(), cxxPlatform);
            BuildRule sharedLibraryBuildRule = requireBuild(params, resolver, pathResolver, ruleFinder, cxxPlatform, rustBuckConfig, rustcArgs.build(), /* linkerArgs */
            ImmutableList.of(), /* linkerInputs */
            ImmutableList.of(), crate, CrateType.CDYLIB, Linker.LinkableDepType.SHARED, args);
            libs.put(sharedLibrarySoname, sharedLibraryBuildRule.getSourcePathToOutput());
            return libs.build();
        }
    };
}