this.bound = true;
            return this;
        }

        public Builder suggestions(Collection<? extends String> suggestedPaths) {
            this.suggestedPaths.addAll(suggestedPaths);
            return this;
        }

        public Builder suggestions(String... suggestedPath) {
            return suggestions(Arrays.asList(suggestedPath));
        }

	// the linker) in the object file to signal the that it should not
	// try to link internally and should revert to external linking.
	// The token we pass is a suggestion, not a mandate; if a user is
	// explicitly asking for a specific linkmode via the "-linkmode"
	// flag, the token will be ignored. NB: in theory we could ditch

        then:
        suggestionsFor("foo") == ["fo", "foob", "for"]
        suggestionsFor("foor") == ["foob", "for", "bor", "fo"]
        suggestionsFor("foora") == ["foob", "for"]
    }

    def "suggestions are ordered by distance then alphabetical"() {
        when:
        availablePaths = ["tasks.foobar", "task.afoobar", "tasks.f", "tasks.boofar", "fooba", "tasks.foo"]

        then:

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.integtests.fixtures

/**
 * A collection of suggestions to be displayed to the user when a build fails.
 * These where repeated all over the test code, so they are now centralized here.
 */

class SuggestionsMessages {

import java.util.Optional;

/**
 * Describe a certain type of resolution failure, by providing concise and specific human-readable
 * information to the message of the resulting exception, and also adding resolution suggestions if possible.
 *
 * @param <FAILURE> the type of failure that this describer can describe
 */
public interface ResolutionFailureDescriber<FAILURE extends ResolutionFailure> {
    /**

     *
     * This method should only be called by the container when maybe-creating a configuration that already exists.
     *
     * This method will emit a detailed deprecation method with suggestions if the usage is inconsistent.  It will then attempt to mutate
     * the usage to match the expectation.  If the usage cannot be mutated, it will throw an exception.
     *

    subject:
      - foo.bar Object [*]

  foo.bla { ... } @ build.gradle line 8, column 17
    subject:
      - foo.bla Object [*]
"""
    }

    def "suggestions are provided for unbound by-path references"() {
        given:
        buildScript """
            class MyPlugin {
                static class Rules extends RuleSource {
                    @Mutate

                writer.println(input.getScope());
            }
            if (input.getSuggestedPaths().size() > 0) {
                writer.write(indent(4));
                writer.write("suggestions: ");
                writer.println(Joiner.on(", ").join(input.getSuggestedPaths()));
            }
        }
    }

    private void heading(String heading) {
        writer.print(indent(1));

            builder.bound();
            path = binding.getNode().getPath();
        } else {
            path = reference.getPath();
            if (path != null) {
                builder.suggestions(CollectionUtils.stringize(suggestionsProvider.transform(path)));
            }
            ModelPath scope = reference.getScope();
            if (scope != null && !scope.equals(ModelPath.ROOT)) {

     *
     * This method should only be called by the container when maybe-creating a configuration that already exists.
     *
     * This method will emit a detailed deprecation method with suggestions if the usage is inconsistent.  It will then attempt to mutate
     * the usage to match the expectation.  If the usage cannot be mutated, it will throw an exception.
     *