}
            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));
        writer.println(heading);
    }

	}

	for _, join := range from.Joins {
		builder.WriteByte(' ')
		join.Build(builder)
	}
}

// MergeClause merge from clause
func (from From) MergeClause(clause *Clause) {
	clause.Expression = from

            toPath.removeFirst();
        }
        for (String ignored : fromPath) {
            relativePath.add("..");
        }
        relativePath.addAll(toPath);
        return Joiner.on(File.separatorChar).join(relativePath);
    }

    private LinkedList<String> splitPath(String path) {
        File pathFile = new File(path);
        LinkedList<String> split = new LinkedList<String>();

        }

        toolExec.args(invocation.getArgs());

        if (!invocation.getPath().isEmpty()) {
            String pathVar = OperatingSystem.current().getPathVar();
            String toolPath = Joiner.on(File.pathSeparator).join(invocation.getPath());
            toolPath = toolPath + File.pathSeparator + System.getenv(pathVar);
            toolExec.environment(pathVar, toolPath);

        ClassLoaderScopeIdentifier nextParent = parent;
        while (nextParent != null) {
            names.addFirst(nextParent.name);
            nextParent = nextParent.parent;
        }
        return Joiner.on(":").join(names);
    }

    @Override
    public String toString() {
        return "ClassLoaderScopeIdentifier{" + getPath() + "}";
    }

    private static class Id implements ClassLoaderId {

        }
        if (processorIndex == compilerArgs.size() - 1) {
            throw new InvalidUserDataException("No processor specified for compiler argument -processor in requested compiler args: " + Joiner.on(" ").join(compilerArgs));
        }
        Collection<String> explicitProcessors = Splitter.on(',').splitToList(compilerArgs.get(processorIndex + 1));

        for (Class<?> clazz : factories.keySet()) {
            names.add(clazz.getSimpleName());
        }
        Collections.sort(names);
        return names.isEmpty() ? "(None)" : Joiner.on(", ").join(names);
    }

    @Override
    public <U extends T> void registerFactory(Class<U> type, NamedDomainObjectFactory<? extends U> factory) {
        if (!baseType.isAssignableFrom(type)) {

        return "project " + dependency.getName();
    }

    private static String moduleDependencyLabel(Dependency dependency) {
        return Joiner.on(":").join(
            Stream.of(dependency.getGroup(), dependency.getName(), dependency.getVersion())
                .filter(Objects::nonNull)
                .collect(Collectors.toList())
        );
    }

     * should be kept after compilation has completed. Useful for joint compilation debugging purposes.
     * Defaults to {@code false}.
     */
    @Input
    public boolean isKeepStubs() {
        return keepStubs;
    }

    /**
     * Sets whether Java stubs for Groovy classes generated during Java/Groovy joint compilation

    assertEquals(expected, factory.getSinkContents());
  }

  private void assertContainsExpectedLines(String separator) throws IOException {
    String expected = expectedLines.isEmpty() ? "" : Joiner.on(separator).join(expectedLines);
    if (!lines.isEmpty()) {
      // if we wrote any lines in writeLines(), there will be a trailing newline
      expected += separator;
    }