public Object getValue(String expression) {
            Object value = valueSource.getValue(expression);

            if (value != null && expression.startsWith(bannedPrefix)) {
                String msg = "The expression ${" + expression + "} is deprecated.";
                if (newPrefix != null && !newPrefix.isEmpty()) {
                    msg += " Please use ${" + newPrefix + expression.substring(bannedPrefix.length()) + "} instead.";

        List<Expression> expressions = documentation.getExpressions();

        Map<String, Expression> bySyntax = new HashMap<>();

        if (expressions != null && !expressions.isEmpty()) {
            for (Expression expression : expressions) {
                bySyntax.put(expression.getSyntax(), expression);
            }
        }

        return bySyntax;
    }

    /**
     * Interpolates all expressions in the src parameter.
     * <p>
     * The algorithm used for each expression is:
     * <ul>
     *   <li>If it starts with either "pom." or "project.", the expression is evaluated against the model.</li>
     *   <li>If the value is null, get the value from the context.</li>
     *   <li>If the value is null, but the context contains the expression, don't replace the expression string

            for (String expression : BASEDIR_EXPRESSIONS) {
                if (s.startsWith(expression)) {
                    basedirExpr = expression;
                    break;
                }
            }

            if (basedirExpr != null) {
                if (s.length() > basedirExpr.length()) {
                    // Take out basedir expression and the leading slash

import org.codehaus.plexus.component.configurator.expression.ExpressionEvaluationException;
import org.codehaus.plexus.component.configurator.expression.TypeAwareExpressionEvaluator;

/**
 * Evaluator for plugin parameters expressions. Content surrounded by <code>${</code> and <code>}</code> is evaluated.
 * Recognized values are:
 * <table border="1">
 * <caption>Expression matrix</caption>

 * An instance of this object is bound to the {@link org.apache.maven.api.di.MojoExecutionScoped}
 * and available as {@code mojoExecution} within {@link org.apache.maven.api.plugin.annotations.Parameter}
 * expressions.
 *
 * @since 4.0.0
 */
@Experimental
public interface MojoExecution {

    @Nonnull
    Plugin getPlugin();

    @Nonnull
    PluginExecution getModel();

    @Nonnull

 * appropriate primitive specialization such as {@code IntPredicate}) instead whenever possible.
 * Otherwise, at least reduce <i>explicit</i> dependencies on this type by using lambda expressions
 * or method references instead of classes, leaving your code easier to migrate in the future.
 *
 * <p>The {@link Predicates} class provides common predicates and related utilities.
 *

     * properties.
     * @return property name
     */
    @Nonnull
    String property() default "";

    /**
     * parameter default value, may contain <code>${...}</code> expressions which will be interpreted at
     * inject time: see
     * <a href="/ref/current/maven-core/apidocs/org/apache/maven/plugin/PluginParameterExpressionEvaluator.html">
     * PluginParameterExpressionEvaluator</a>.

 * appropriate primitive specialization such as {@code ToIntFunction}) instead whenever possible.
 * Otherwise, at least reduce <i>explicit</i> dependencies on this type by using lambda expressions
 * or method references instead of classes, leaving your code easier to migrate in the future.
 *
 * <p>To use an existing function (say, named {@code function}) in a context where the <i>other

 * resulting {@link HashCode} is dependent only on the bytes inserted, and the order in which they
 * were inserted, not how those bytes were chunked into discrete put() operations. For example, the
 * following three expressions all generate colliding hash codes:
 *
 * <pre>{@code
 * newHasher().putByte(b1).putByte(b2).putByte(b3).hash()
 * newHasher().putByte(b1).putBytes(new byte[] { b2, b3 }).hash()