| // 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.common.options; |
| |
| import static com.google.devtools.common.options.OptionPriority.PriorityCategory.INVOCATION_POLICY; |
| import static java.util.Comparator.comparing; |
| import static java.util.stream.Collectors.toCollection; |
| |
| import com.google.common.base.Joiner; |
| import com.google.common.base.Preconditions; |
| import com.google.common.base.Splitter; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableMap; |
| import com.google.common.collect.Iterators; |
| import com.google.devtools.common.options.OptionPriority.PriorityCategory; |
| import com.google.devtools.common.options.OptionValueDescription.ExpansionBundle; |
| import com.google.devtools.common.options.OptionsParser.OptionDescription; |
| import com.google.errorprone.annotations.CanIgnoreReturnValue; |
| import com.google.errorprone.annotations.Keep; |
| import java.lang.reflect.Constructor; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedHashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Objects; |
| import java.util.Set; |
| import java.util.function.Function; |
| import java.util.stream.Collectors; |
| import javax.annotation.Nullable; |
| |
| /** |
| * The implementation of the options parser. This is intentionally package private for full |
| * flexibility. Use {@link OptionsParser} or {@link Options} if you're a consumer. |
| */ |
| class OptionsParserImpl { |
| |
| /** Helper class to create a new instance of {@link OptionsParserImpl}. */ |
| static final class Builder { |
| private OptionsData optionsData; |
| private ArgsPreProcessor argsPreProcessor = args -> args; |
| private final ArrayList<String> skippedPrefixes = new ArrayList<>(); |
| private boolean ignoreInternalOptions = true; |
| @Nullable private String aliasFlag = null; |
| @Nullable private Object conversionContext = null; |
| private final Map<String, String> aliases = new HashMap<>(); |
| |
| /** Set the {@link OptionsData} to be used in this instance. */ |
| @CanIgnoreReturnValue |
| public Builder optionsData(OptionsData optionsData) { |
| this.optionsData = optionsData; |
| return this; |
| } |
| |
| /** Sets the {@link ArgsPreProcessor} to use during processing. */ |
| @CanIgnoreReturnValue |
| public Builder argsPreProcessor(ArgsPreProcessor preProcessor) { |
| this.argsPreProcessor = preProcessor; |
| return this; |
| } |
| |
| /** Any flags with this prefix will be skipped during processing. */ |
| @CanIgnoreReturnValue |
| public Builder skippedPrefix(String skippedPrefix) { |
| this.skippedPrefixes.add(skippedPrefix); |
| return this; |
| } |
| |
| /** Sets whether the parser should ignore internal-only options. */ |
| @CanIgnoreReturnValue |
| public Builder ignoreInternalOptions(boolean ignoreInternalOptions) { |
| this.ignoreInternalOptions = ignoreInternalOptions; |
| return this; |
| } |
| |
| /** |
| * Sets what flag the parser should use for flag aliasing. Defaults to null if not set, |
| * effectively disabling the aliasing functionality. |
| */ |
| @CanIgnoreReturnValue |
| public Builder withAliasFlag(@Nullable String aliasFlag) { |
| if (aliasFlag != null) { |
| this.aliasFlag = "--" + aliasFlag; |
| } |
| return this; |
| } |
| |
| public Builder withConversionContext(@Nullable Object conversionContext) { |
| this.conversionContext = conversionContext; |
| return this; |
| } |
| |
| /** |
| * Adds a map of flag aliases where the keys are the flags' alias names and the values are their |
| * actual names. |
| */ |
| @CanIgnoreReturnValue |
| public Builder withAliases(Map<String, String> aliases) { |
| this.aliases.putAll(aliases); |
| return this; |
| } |
| |
| /** Returns a newly-initialized {@link OptionsParserImpl}. */ |
| public OptionsParserImpl build() { |
| return new OptionsParserImpl( |
| this.optionsData, |
| this.argsPreProcessor, |
| this.skippedPrefixes, |
| this.ignoreInternalOptions, |
| this.aliasFlag, |
| this.conversionContext, |
| this.aliases); |
| } |
| } |
| |
| /** Returns a new {@link Builder} with correct defaults applied. */ |
| public static Builder builder() { |
| return new Builder(); |
| } |
| |
| private final OptionsData optionsData; |
| |
| /** |
| * We store the results of option parsing in here - since there can only be one value per option |
| * field, this is where the different instances of an option have been combined and the final |
| * value is tracked. It'll look like |
| * |
| * <pre> |
| * OptionDefinition("--host") -> "www.google.com" |
| * OptionDefinition("--port") -> 80 |
| * </pre> |
| * |
| * This map is modified by repeated calls to {@link #parse(OptionPriority.PriorityCategory, |
| * Function,List)}. |
| */ |
| private final Map<OptionDefinition, OptionValueDescription> optionValues = new HashMap<>(); |
| |
| /** |
| * Since parse() expects multiple calls to it with the same {@link PriorityCategory} to be treated |
| * as though the args in the later call have higher priority over the earlier calls, we need to |
| * track the high water mark of option priority at each category. Each call to parse will start at |
| * this level. |
| */ |
| private final Map<PriorityCategory, OptionPriority> nextPriorityPerPriorityCategory = |
| Arrays.stream(PriorityCategory.values()) |
| .collect(Collectors.toMap(p -> p, OptionPriority::lowestOptionPriorityAtCategory)); |
| |
| /** |
| * Explicit option tracking, tracking each option as it was provided, after they have been parsed. |
| * |
| * <p>The value is unconverted, still the string as it was read from the input, or partially |
| * altered in cases where the flag was set by non {@code --flag=value} forms; e.g. {@code --nofoo} |
| * becomes {@code --foo=0}. |
| */ |
| private final List<ParsedOptionDescription> parsedOptions = new ArrayList<>(); |
| |
| private final Map<String, String> flagAliasMappings; |
| // We want to keep the invariant that warnings are produced as they are encountered, but only |
| // show each one once. |
| private final Set<String> warnings = new LinkedHashSet<>(); |
| private final ArgsPreProcessor argsPreProcessor; |
| private final List<String> skippedPrefixes; |
| private final boolean ignoreInternalOptions; |
| @Nullable private final String aliasFlag; |
| @Nullable private final Object conversionContext; |
| |
| /** |
| * This option is used to collect skipped arguments while preserving the relative ordering between |
| * those given explicitly on the command line and those expanded by {@code ConfigExpander}. The |
| * field itself is not used for any purpose other than retrieving its {@link Option} annotation. |
| */ |
| @Keep |
| @Option( |
| name = "skipped args", |
| allowMultiple = true, |
| defaultValue = "null", |
| documentationCategory = OptionDocumentationCategory.UNDOCUMENTED, |
| effectTags = {OptionEffectTag.NO_OP}, |
| help = "Only used internally by OptionsParserImpl") |
| private final List<String> skippedArgs = new ArrayList<>(); |
| |
| private static final OptionDefinition skippedArgsDefinition; |
| |
| static { |
| try { |
| skippedArgsDefinition = |
| OptionDefinition.extractOptionDefinition( |
| OptionsParserImpl.class.getDeclaredField("skippedArgs")); |
| } catch (NoSuchFieldException e) { |
| throw new IllegalStateException(e); |
| } |
| } |
| |
| OptionsParserImpl( |
| OptionsData optionsData, |
| ArgsPreProcessor argsPreProcessor, |
| List<String> skippedPrefixes, |
| boolean ignoreInternalOptions, |
| @Nullable String aliasFlag, |
| @Nullable Object conversionContext, |
| Map<String, String> aliases) { |
| this.optionsData = optionsData; |
| this.argsPreProcessor = argsPreProcessor; |
| this.skippedPrefixes = skippedPrefixes; |
| this.ignoreInternalOptions = ignoreInternalOptions; |
| this.aliasFlag = aliasFlag; |
| this.conversionContext = conversionContext; |
| this.flagAliasMappings = aliases; |
| } |
| |
| /** Returns the {@link OptionsData} used in this instance. */ |
| OptionsData getOptionsData() { |
| return optionsData; |
| } |
| |
| @Nullable |
| public Object getConversionContext() { |
| return conversionContext; |
| } |
| |
| /** Returns a {@link Builder} that is configured the same as this parser. */ |
| Builder toBuilder() { |
| Builder builder = |
| builder() |
| .optionsData(optionsData) |
| .argsPreProcessor(argsPreProcessor) |
| .withAliasFlag(aliasFlag) |
| .withAliases(flagAliasMappings) |
| .withConversionContext(conversionContext) |
| .ignoreInternalOptions(ignoreInternalOptions); |
| for (String skippedPrefix : skippedPrefixes) { |
| builder.skippedPrefix(skippedPrefix); |
| } |
| return builder; |
| } |
| |
| /** Implements {@link OptionsParser#asCompleteListOfParsedOptions()}. */ |
| List<ParsedOptionDescription> asCompleteListOfParsedOptions() { |
| return parsedOptions.stream() |
| // It is vital that this sort is stable so that options on the same priority are not |
| // reordered. |
| .sorted(comparing(ParsedOptionDescription::getPriority)) |
| .collect(toCollection(ArrayList::new)); |
| } |
| |
| /** Implements {@link OptionsParser#asListOfExplicitOptions()}. */ |
| List<ParsedOptionDescription> asListOfExplicitOptions() { |
| return parsedOptions.stream() |
| .filter(ParsedOptionDescription::isExplicit) |
| // It is vital that this sort is stable so that options on the same priority are not |
| // reordered. |
| .sorted(comparing(ParsedOptionDescription::getPriority)) |
| .collect(toCollection(ArrayList::new)); |
| } |
| |
| /** Implements {@link OptionsParser#canonicalize}. */ |
| List<String> asCanonicalizedList() { |
| return asCanonicalizedListOfParsedOptions().stream() |
| .map(ParsedOptionDescription::getDeprecatedCanonicalForm) |
| .collect(ImmutableList.toImmutableList()); |
| } |
| |
| /** Implements {@link OptionsParser#canonicalize}. */ |
| List<ParsedOptionDescription> asCanonicalizedListOfParsedOptions() { |
| return optionValues.keySet().stream() |
| .filter(k -> !Objects.equals(k, skippedArgsDefinition)) |
| .map(optionDefinition -> optionValues.get(optionDefinition).getCanonicalInstances()) |
| .flatMap(Collection::stream) |
| // Return the effective (canonical) options in the order they were applied. |
| .sorted(comparing(ParsedOptionDescription::getPriority)) |
| .collect(ImmutableList.toImmutableList()); |
| } |
| |
| /** Implements {@link OptionsParser#asListOfOptionValues()}. */ |
| List<OptionValueDescription> asListOfEffectiveOptions() { |
| List<OptionValueDescription> result = new ArrayList<>(); |
| for (Map.Entry<String, OptionDefinition> mapEntry : optionsData.getAllOptionDefinitions()) { |
| OptionDefinition optionDefinition = mapEntry.getValue(); |
| OptionValueDescription optionValue = optionValues.get(optionDefinition); |
| if (optionValue == null) { |
| result.add( |
| OptionValueDescription.getDefaultOptionValue(optionDefinition, conversionContext)); |
| } else { |
| result.add(optionValue); |
| } |
| } |
| return result; |
| } |
| |
| private void maybeAddDeprecationWarning( |
| OptionDefinition optionDefinition, PriorityCategory priority) { |
| // Don't add a warning for deprecated flag set by the invocation policy. |
| if (priority.equals(INVOCATION_POLICY)) { |
| return; |
| } |
| // Continue to support the old behavior for @Deprecated options. |
| String warning = optionDefinition.getDeprecationWarning(); |
| if (!warning.isEmpty() || optionDefinition.getField().isAnnotationPresent(Deprecated.class)) { |
| addDeprecationWarning(optionDefinition.getOptionName(), warning); |
| } |
| } |
| |
| private void maybeAddOldNameWarning(ParsedOptionDescription parsedOption) { |
| // Don't add a warning for old name options set by the invocation policy. |
| if (parsedOption.getPriority().getPriorityCategory().equals(INVOCATION_POLICY)) { |
| return; |
| } |
| String commandLineForm = parsedOption.getCommandLineForm(); |
| String oldOptionName = parsedOption.getOptionDefinition().getOldOptionName(); |
| String optionName = parsedOption.getOptionDefinition().getOptionName(); |
| if (commandLineForm.startsWith(String.format("--%s=", oldOptionName))) { |
| addDeprecationWarning(oldOptionName, String.format("Use --%s instead", optionName)); |
| } |
| } |
| |
| private void addDeprecationWarning(String optionName, String warning) { |
| warnings.add( |
| String.format( |
| "Option '%s' is deprecated%s", optionName, (warning.isEmpty() ? "" : ": " + warning))); |
| } |
| |
| OptionValueDescription clearValue(OptionDefinition optionDefinition) |
| throws OptionsParsingException { |
| return optionValues.remove(optionDefinition); |
| } |
| |
| OptionValueDescription getOptionValueDescription(String name) { |
| OptionDefinition optionDefinition = optionsData.getOptionDefinitionFromName(name); |
| if (optionDefinition == null) { |
| throw new IllegalArgumentException("No such option '" + name + "'"); |
| } |
| return optionValues.get(optionDefinition); |
| } |
| |
| @Nullable |
| OptionDescription getOptionDescription(String name) throws OptionsParsingException { |
| OptionDefinition optionDefinition = optionsData.getOptionDefinitionFromName(name); |
| if (optionDefinition == null) { |
| return null; |
| } |
| return new OptionDescription(optionDefinition, optionsData); |
| } |
| |
| /** |
| * Implementation of {@link OptionsParser#getExpansionValueDescriptions(OptionDefinition, |
| * OptionInstanceOrigin)} |
| */ |
| ImmutableList<ParsedOptionDescription> getExpansionValueDescriptions( |
| OptionDefinition expansionFlagDef, OptionInstanceOrigin originOfExpansionFlag) |
| throws OptionsParsingException { |
| ImmutableList.Builder<ParsedOptionDescription> builder = ImmutableList.builder(); |
| |
| // Values needed to correctly track the origin of the expanded options. |
| OptionPriority nextOptionPriority = |
| OptionPriority.getChildPriority(originOfExpansionFlag.getPriority()); |
| String source; |
| ParsedOptionDescription implicitDependent = null; |
| ParsedOptionDescription expandedFrom = null; |
| |
| ImmutableList<String> options; |
| ParsedOptionDescription expansionFlagParsedDummy = |
| ParsedOptionDescription.newDummyInstance( |
| expansionFlagDef, originOfExpansionFlag, conversionContext); |
| if (expansionFlagDef.hasImplicitRequirements()) { |
| options = ImmutableList.copyOf(expansionFlagDef.getImplicitRequirements()); |
| source = |
| String.format( |
| "implicitly required by %s (source: %s)", |
| expansionFlagDef, originOfExpansionFlag.getSource()); |
| implicitDependent = expansionFlagParsedDummy; |
| } else if (expansionFlagDef.isExpansionOption()) { |
| options = optionsData.getEvaluatedExpansion(expansionFlagDef); |
| source = |
| String.format( |
| "expanded by %s (source: %s)", expansionFlagDef, originOfExpansionFlag.getSource()); |
| expandedFrom = expansionFlagParsedDummy; |
| } else { |
| return ImmutableList.of(); |
| } |
| |
| Iterator<String> optionsIterator = options.iterator(); |
| while (optionsIterator.hasNext()) { |
| String unparsedFlagExpression = optionsIterator.next(); |
| ParsedOptionDescription parsedOption = |
| identifyOptionAndPossibleArgument( |
| unparsedFlagExpression, |
| optionsIterator, |
| nextOptionPriority, |
| o -> source, |
| implicitDependent, |
| expandedFrom); |
| builder.add(parsedOption); |
| nextOptionPriority = OptionPriority.nextOptionPriority(nextOptionPriority); |
| } |
| return builder.build(); |
| } |
| |
| boolean containsExplicitOption(String name) { |
| OptionDefinition optionDefinition = optionsData.getOptionDefinitionFromName(name); |
| if (optionDefinition == null) { |
| throw new IllegalArgumentException("No such option '" + name + "'"); |
| } |
| return optionValues.get(optionDefinition) != null; |
| } |
| |
| @SuppressWarnings("unchecked") |
| List<String> getSkippedArgs() { |
| OptionValueDescription value = optionValues.get(skippedArgsDefinition); |
| if (value == null) { |
| return ImmutableList.of(); |
| } |
| return (List<String>) value.getValue(); |
| } |
| |
| /** |
| * Parses the args, and returns what it doesn't parse. May be called multiple times, and may be |
| * called recursively. The option's definition dictates how it reacts to multiple settings. By |
| * default, the arg seen last at the highest priority takes precedence, overriding the early |
| * values. Options that accumulate multiple values will track them in priority and appearance |
| * order. |
| */ |
| OptionsParserImplResult parse( |
| PriorityCategory priorityCat, |
| Function<OptionDefinition, String> sourceFunction, |
| List<String> args) |
| throws OptionsParsingException { |
| OptionsParserImplResult optionsParserImplResult = |
| parse(nextPriorityPerPriorityCategory.get(priorityCat), sourceFunction, null, null, args); |
| nextPriorityPerPriorityCategory.put(priorityCat, optionsParserImplResult.nextPriority); |
| return optionsParserImplResult; |
| } |
| |
| /** |
| * Parses the args, and returns what it doesn't parse. May be called multiple times, and may be |
| * called recursively. Calls may contain intersecting sets of options; in that case, the arg seen |
| * last takes precedence. |
| * |
| * <p>The method treats options that have neither an implicitDependent nor an expandedFrom value |
| * as explicitly set. |
| */ |
| private OptionsParserImplResult parse( |
| OptionPriority priority, |
| Function<OptionDefinition, String> sourceFunction, |
| ParsedOptionDescription implicitDependent, |
| ParsedOptionDescription expandedFrom, |
| List<String> args) |
| throws OptionsParsingException { |
| List<String> unparsedArgs = new ArrayList<>(); |
| List<String> unparsedPostDoubleDashArgs = new ArrayList<>(); |
| |
| Iterator<String> argsIterator = argsPreProcessor.preProcess(args).iterator(); |
| while (argsIterator.hasNext()) { |
| String arg = argsIterator.next(); |
| |
| if (!arg.startsWith("-")) { |
| unparsedArgs.add(arg); |
| continue; // not an option arg |
| } |
| |
| arg = swapShorthandAlias(arg); |
| |
| if (arg.equals("--")) { // "--" means all remaining args aren't options |
| Iterators.addAll(unparsedPostDoubleDashArgs, argsIterator); |
| break; |
| } |
| |
| ParsedOptionDescription parsedOption; |
| if (containsSkippedPrefix(arg)) { |
| // Parse the skipped arg into a synthetic allowMultiple option to preserve its order |
| // relative to skipped args coming from expansions. Simply adding it to the residue would |
| // end up placing expanded skipped args after all explicitly given skipped args, which isn't |
| // correct. |
| parsedOption = |
| ParsedOptionDescription.newParsedOptionDescription( |
| skippedArgsDefinition, |
| arg, |
| arg, |
| new OptionInstanceOrigin( |
| priority, |
| sourceFunction.apply(skippedArgsDefinition), |
| implicitDependent, |
| expandedFrom), |
| conversionContext); |
| } else { |
| parsedOption = |
| identifyOptionAndPossibleArgument( |
| arg, argsIterator, priority, sourceFunction, implicitDependent, expandedFrom); |
| } |
| handleNewParsedOption(parsedOption); |
| priority = OptionPriority.nextOptionPriority(priority); |
| } |
| |
| // Go through the final values and make sure they are valid values for their option. Unlike any |
| // checks that happened above, this also checks that flags that were not set have a valid |
| // default value. getValue() will throw if the value is invalid. |
| for (OptionValueDescription valueDescription : asListOfEffectiveOptions()) { |
| valueDescription.getValue(); |
| } |
| |
| return new OptionsParserImplResult( |
| unparsedArgs, unparsedPostDoubleDashArgs, priority, flagAliasMappings); |
| } |
| |
| /** A class that stores residue and priority information. */ |
| static final class OptionsParserImplResult { |
| final List<String> postDoubleDashResidue; |
| final List<String> preDoubleDashResidue; |
| final OptionPriority nextPriority; |
| final ImmutableMap<String, String> aliases; |
| |
| OptionsParserImplResult( |
| List<String> preDashResidue, |
| List<String> postDashResidue, |
| OptionPriority nextPriority, |
| Map<String, String> aliases) { |
| this.preDoubleDashResidue = preDashResidue; |
| this.postDoubleDashResidue = postDashResidue; |
| this.nextPriority = nextPriority; |
| this.aliases = ImmutableMap.copyOf(aliases); |
| } |
| |
| public List<String> getResidue() { |
| List<String> toReturn = |
| new ArrayList<>(preDoubleDashResidue.size() + postDoubleDashResidue.size()); |
| toReturn.addAll(preDoubleDashResidue); |
| toReturn.addAll(postDoubleDashResidue); |
| return toReturn; |
| } |
| } |
| |
| /** Implements {@link OptionsParser#parseArgsAsExpansionOfOption} */ |
| OptionsParserImplResult parseArgsAsExpansionOfOption( |
| ParsedOptionDescription optionToExpand, |
| Function<OptionDefinition, String> sourceFunction, |
| List<String> args) |
| throws OptionsParsingException { |
| return parse( |
| OptionPriority.getChildPriority(optionToExpand.getPriority()), |
| sourceFunction, |
| null, |
| optionToExpand, |
| args); |
| } |
| |
| /** |
| * Implementation of {@link |
| * OptionsParser#setOptionValueAtSpecificPriorityWithoutExpansion(OptionInstanceOrigin, |
| * OptionDefinition, String)} |
| */ |
| void setOptionValueAtSpecificPriorityWithoutExpansion( |
| OptionInstanceOrigin origin, OptionDefinition option, String unconvertedValue) |
| throws OptionsParsingException { |
| Preconditions.checkNotNull(option); |
| Preconditions.checkNotNull( |
| unconvertedValue, |
| "Cannot set %s to a null value. Pass \"\" if an empty value is required.", |
| option); |
| Preconditions.checkNotNull( |
| origin, |
| "Cannot assign value '%s' to %s without a clear origin for this value.", |
| unconvertedValue, |
| option); |
| PriorityCategory priorityCategory = origin.getPriority().getPriorityCategory(); |
| boolean isNotDefault = priorityCategory != OptionPriority.PriorityCategory.DEFAULT; |
| Preconditions.checkArgument( |
| isNotDefault, |
| "Attempt to assign value '%s' to %s at priority %s failed. Cannot set options at " |
| + "default priority - by definition, that means the option is unset.", |
| unconvertedValue, |
| option, |
| priorityCategory); |
| |
| setOptionValue( |
| ParsedOptionDescription.newParsedOptionDescription( |
| option, |
| String.format("--%s=%s", option.getOptionName(), unconvertedValue), |
| unconvertedValue, |
| origin, |
| conversionContext)); |
| } |
| |
| /** Takes care of tracking the parsed option's value in relation to other options. */ |
| private void handleNewParsedOption(ParsedOptionDescription parsedOption) |
| throws OptionsParsingException { |
| OptionDefinition optionDefinition = parsedOption.getOptionDefinition(); |
| ExpansionBundle expansionBundle = setOptionValue(parsedOption); |
| @Nullable String unconvertedValue = parsedOption.getUnconvertedValue(); |
| |
| if (expansionBundle != null) { |
| OptionsParserImplResult optionsParserImplResult = |
| parse( |
| OptionPriority.getChildPriority(parsedOption.getPriority()), |
| o -> expansionBundle.sourceOfExpansionArgs, |
| optionDefinition.hasImplicitRequirements() ? parsedOption : null, |
| optionDefinition.isExpansionOption() ? parsedOption : null, |
| expansionBundle.expansionArgs); |
| if (!optionsParserImplResult.getResidue().isEmpty()) { |
| |
| // Throw an assertion here, because this indicates an error in the definition of this |
| // option's expansion or requirements, not with the input as provided by the user. |
| throw new AssertionError( |
| "Unparsed options remain after processing " |
| + unconvertedValue |
| + ": " |
| + Joiner.on(' ').join(optionsParserImplResult.getResidue())); |
| } |
| } |
| } |
| |
| private ExpansionBundle setOptionValue(ParsedOptionDescription parsedOption) |
| throws OptionsParsingException { |
| OptionDefinition optionDefinition = parsedOption.getOptionDefinition(); |
| // All options can be deprecated; check and warn before doing any option-type specific work. |
| maybeAddDeprecationWarning(optionDefinition, parsedOption.getPriority().getPriorityCategory()); |
| // Check if the old option name is used and add a warning |
| maybeAddOldNameWarning(parsedOption); |
| // Track the value, before any remaining option-type specific work that is done outside of |
| // the OptionValueDescription. |
| OptionValueDescription entry = |
| optionValues.computeIfAbsent( |
| optionDefinition, |
| def -> |
| OptionValueDescription.createOptionValueDescription( |
| def, optionsData, conversionContext)); |
| ExpansionBundle expansionBundle = entry.addOptionInstance(parsedOption, warnings); |
| |
| // There are 3 types of flags that expand to other flag values. Expansion flags are the |
| // accepted way to do this, but implicit requirements also do this. We rely on the |
| // OptionProcessor compile-time check's guarantee that no option sets |
| // both expansion behaviors. (In Bazel, --config is another such flag, but that expansion |
| // is not controlled within the options parser, so we ignore it here) |
| |
| // As much as possible, we want the behaviors of these different types of flags to be |
| // identical, as this minimizes the number of edge cases, but we do not yet track these values |
| // in the same way. |
| |
| // Do not list the internal "skipped args" option that is only used to accumulate skipped |
| // arguments. |
| if (parsedOption.getImplicitDependent() == null |
| && !Objects.equals(parsedOption.getOptionDefinition(), skippedArgsDefinition)) { |
| // Log explicit options and expanded options in the order they are parsed (can be sorted |
| // later). This information is needed to correctly canonicalize flags. |
| parsedOptions.add(parsedOption); |
| |
| if (aliasFlag != null && parsedOption.getCommandLineForm().startsWith(aliasFlag)) { |
| List<String> alias = |
| Splitter.on('=').limit(2).splitToList(parsedOption.getUnconvertedValue()); |
| |
| flagAliasMappings.put(alias.get(0), alias.get(1)); |
| } |
| } |
| |
| return expansionBundle; |
| } |
| |
| private ParsedOptionDescription identifyOptionAndPossibleArgument( |
| String arg, |
| Iterator<String> nextArgs, |
| OptionPriority priority, |
| Function<OptionDefinition, String> sourceFunction, |
| ParsedOptionDescription implicitDependent, |
| ParsedOptionDescription expandedFrom) |
| throws OptionsParsingException { |
| |
| // Store the way this option was parsed on the command line. |
| StringBuilder commandLineForm = new StringBuilder(); |
| commandLineForm.append(arg); |
| String unconvertedValue = null; |
| OptionDefinition optionDefinition; |
| boolean booleanValue = true; |
| |
| if (arg.length() == 2) { // -l (may be nullary or unary) |
| optionDefinition = optionsData.getFieldForAbbrev(arg.charAt(1)); |
| booleanValue = true; |
| |
| } else if (arg.length() == 3 && arg.charAt(2) == '-') { // -l- (boolean) |
| optionDefinition = optionsData.getFieldForAbbrev(arg.charAt(1)); |
| booleanValue = false; |
| |
| } else if (arg.startsWith("--")) { // --long_option |
| |
| int equalsAt = arg.indexOf('='); |
| int nameStartsAt = 2; |
| String name = |
| equalsAt == -1 ? arg.substring(nameStartsAt) : arg.substring(nameStartsAt, equalsAt); |
| if (name.trim().isEmpty()) { |
| throw new OptionsParsingException("Invalid options syntax: " + arg, arg); |
| } |
| unconvertedValue = equalsAt == -1 ? null : arg.substring(equalsAt + 1); |
| optionDefinition = optionsData.getOptionDefinitionFromName(name); |
| |
| // Look for a "no"-prefixed option name: "no<optionName>". |
| if (optionDefinition == null && name.startsWith("no")) { |
| name = name.substring(2); |
| optionDefinition = optionsData.getOptionDefinitionFromName(name); |
| booleanValue = false; |
| if (optionDefinition != null) { |
| // TODO(bazel-team): Add tests for these cases. |
| if (!optionDefinition.usesBooleanValueSyntax()) { |
| throw new OptionsParsingException( |
| "Illegal use of 'no' prefix on non-boolean option: " + arg, arg); |
| } |
| if (unconvertedValue != null) { |
| throw new OptionsParsingException("Unexpected value after boolean option: " + arg, arg); |
| } |
| // "no<optionname>" signifies a boolean option w/ false value |
| unconvertedValue = "0"; |
| } |
| } |
| } else { |
| throw new OptionsParsingException("Invalid options syntax: " + arg, arg); |
| } |
| |
| if (optionDefinition == null || shouldIgnoreOption(optionDefinition)) { |
| // Do not recognize internal options, which are treated as if they did not exist. |
| throw new OptionsParsingException("Unrecognized option: " + arg, arg); |
| } |
| |
| if (unconvertedValue == null) { |
| // Special-case boolean to supply value based on presence of "no" prefix. |
| if (optionDefinition.usesBooleanValueSyntax()) { |
| unconvertedValue = booleanValue ? "1" : "0"; |
| } else if (optionDefinition.getType().equals(Void.class)) { |
| // This is expected, Void type options have no args. |
| } else if (nextArgs.hasNext()) { |
| // "--flag value" form |
| unconvertedValue = nextArgs.next(); |
| commandLineForm.append(" ").append(unconvertedValue); |
| } else { |
| throw new OptionsParsingException("Expected value after " + arg); |
| } |
| } |
| |
| return ParsedOptionDescription.newParsedOptionDescription( |
| optionDefinition, |
| commandLineForm.toString(), |
| unconvertedValue, |
| new OptionInstanceOrigin( |
| priority, sourceFunction.apply(optionDefinition), implicitDependent, expandedFrom), |
| conversionContext); |
| } |
| |
| private boolean shouldIgnoreOption(OptionDefinition optionDefinition) { |
| return ignoreInternalOptions |
| && ImmutableList.copyOf(optionDefinition.getOptionMetadataTags()) |
| .contains(OptionMetadataTag.INTERNAL); |
| } |
| |
| /** Gets the result of parsing the options. */ |
| <O extends OptionsBase> O getParsedOptions(Class<O> optionsClass) { |
| // Create the instance: |
| O optionsInstance; |
| try { |
| Constructor<O> constructor = optionsData.getConstructor(optionsClass); |
| if (constructor == null) { |
| return null; |
| } |
| optionsInstance = constructor.newInstance(); |
| } catch (ReflectiveOperationException e) { |
| throw new IllegalStateException("Error while instantiating options class", e); |
| } |
| |
| // Set the fields |
| for (OptionDefinition optionDefinition : |
| OptionsData.getAllOptionDefinitionsForClass(optionsClass)) { |
| Object value; |
| OptionValueDescription optionValue = optionValues.get(optionDefinition); |
| if (optionValue == null) { |
| value = optionDefinition.getDefaultValue(conversionContext); |
| } else { |
| value = optionValue.getValue(); |
| } |
| try { |
| optionDefinition.getField().set(optionsInstance, value); |
| } catch (IllegalArgumentException e) { |
| // May happen when a boolean option got a string value. Just ignore this error without |
| // updating the field. Fixes https://github.com/bazelbuild/bazel/issues/7847 |
| } catch (IllegalAccessException e) { |
| throw new IllegalStateException( |
| "Could not set the field due to access issues. This is impossible, as the " |
| + "OptionProcessor checks that all options are non-final public fields.", |
| e); |
| } |
| } |
| return optionsInstance; |
| } |
| |
| ImmutableList<String> getWarnings() { |
| return ImmutableList.copyOf(warnings); |
| } |
| |
| /** |
| * Takes a string with a leading "-" and swaps it with the matching alias mapping. Example case |
| * with --flag_alias=foo=bar mapped: |
| * |
| * <pre> |
| * swapShorthandAlias("-c") returns "-c" |
| * swapShorthandAlias("--foo") returns "--bar" |
| * swapShorthandAlias("--baz") returns "--baz" |
| * </pre> |
| * |
| * This method returns immediately when aliasFlag is not set via the builder, which is an implicit |
| * disabling of the aliasing functionality. |
| */ |
| private String swapShorthandAlias(String arg) { |
| if (aliasFlag == null || !arg.startsWith("--")) { |
| return arg; |
| } |
| |
| int equalSign = arg.indexOf("="); |
| |
| // Extracts the <arg> from '--<arg>=<value>' and '--<arg> <value>' formats on the command line |
| String actualArg = (equalSign != -1) ? arg.substring(2, equalSign) : arg.substring(2); |
| |
| if (!flagAliasMappings.containsKey(actualArg)) { |
| return arg; |
| } |
| |
| String alias = flagAliasMappings.get(actualArg); |
| actualArg = alias; |
| |
| // Converts the arg back into a command line option, accounting for both '--<arg>=<value>' and |
| // '--<arg> <value>' formats |
| actualArg = (equalSign != -1) ? "--" + actualArg + arg.substring(equalSign) : "--" + actualArg; |
| |
| return actualArg; |
| } |
| |
| private boolean containsSkippedPrefix(String arg) { |
| return skippedPrefixes.stream().anyMatch(arg::startsWith); |
| } |
| } |
