// returning an error if the term set cannot be computed or is empty. In the
// latter case, the error will be ErrEmptyTypeSet.
//
// See the documentation of StructuralTerms for more information on
// normalization.
func InterfaceTermSet(iface *types.Interface) ([]*types.Term, error) {
	return computeTermSet(iface)
}

// UnionTermSet computes the normalized terms for a union, returning an error

    <section>
        <title>Input Normalization types</title>
        <para>Types used to configure input normalization</para>
        <table>
            <title>Input Normalization types</title>
            <tr>
                <td>org.gradle.normalization.InputNormalizationHandler</td>
            </tr>
            <tr>
                <td>org.gradle.normalization.InputNormalization</td>
            </tr>

 * 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 org.gradle.internal.normalization.java.impl;

import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.ModuleVisitor;

import org.gradle.language.base.internal.compile.Compiler;
import org.gradle.util.internal.CollectionUtils;

import java.io.File;
import java.util.List;

/**
 * A Scala {@link Compiler} which does some normalization of the compile configuration and behaviour before delegating to some other compiler.
 */
public class NormalizingScalaCompiler implements Compiler<ScalaJavaJointCompileSpec> {

The changes don't need to be completely independent, either; we'll take a look at the strategies to reuse results when dependencies are involved in the section about the <<build_cache_concepts.adoc#normalization,different forms of normalization>>.

== Combine remote results with local caching

You can utilize both a local and a remote cache for a compound effect.

	headerLenMask   = 0x3F // extract the length value from the header byte
	headerFlagsMask = 0xC0 // extract the qcInfo bits from the header byte
)

// Properties provides access to normalization properties of a rune.
type Properties struct {
	pos   uint8  // start position in reorderBuffer; used in composition.go
	size  uint8  // length of UTF-8 encoding of this rune

              <exclude>org.apache.maven.model.merge.MavenModelMerger</exclude>
              <exclude>org.apache.maven.model.normalization.DefaultModelNormalizer$DuplicateMerger#mergePlugin(org.apache.maven.model.Plugin,org.apache.maven.model.Plugin):METHOD_REMOVED</exclude>
              <exclude>org.apache.maven.model.normalization.DefaultModelNormalizer$DuplicateMerger:METHOD_REMOVED_IN_SUPERCLASS</exclude>

Class <org.gradle.nativeplatform.toolchain.internal.xcode.SwiftStdlibToolLocator> is not annotated with @ServiceScope in (SwiftStdlibToolLocator.java:0)
Class <org.gradle.normalization.InputNormalizationHandler> is not annotated with @ServiceScope in (InputNormalizationHandler.java:0)
Class <org.gradle.normalization.internal.InputNormalizationHandlerInternal> is not annotated with @ServiceScope in (InputNormalizationHandlerInternal.java:0)

// of hyphens ('-'), normalization, validity of runes, and the context rules.
// In particular, ValidateLabels also sets the CheckHyphens and CheckJoiners flags
// in UTS #46.
func ValidateLabels(enable bool) Option {
	return func(o *options) {
		// Don't override existing mappings, but set one that at least checks
		// normalization if it is not set.
		if o.mapping == nil && enable {

    implementation(project(":files"))
    implementation(project(":resources"))
    implementation(project(":tooling-api"))
    implementation(project(":execution"))
    implementation(project(":normalization-java"))

    implementation("org.gradle:kotlin-dsl-shared-runtime")

    implementation(libs.groovy)
    implementation(libs.groovyJson)
    implementation(libs.slf4jApi)
    implementation(libs.guava)