* will default to {@link #COMPILE}.
     */
    UNDEFINED("", false),

    /**
     * Compile only.
     */
    COMPILE_ONLY("compile-only", false),

    /**
     * Compile, runtime and test.
     */
    COMPILE("compile", true),

    /**
     * Runtime and test.
     */
    RUNTIME("runtime", true),

    /**

      <version>1.0-SNAPSHOT</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>snapshot-test</groupId>
      <artifactId>maven-snapshot-b</artifactId>
      <version>1.0-SNAPSHOT</version>
      <type>jar</type>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>snapshot-test</groupId>

		return err
	}

	cmd = exec.Command(goTool, "list", "-f", "{{.Target}}", "cmd/compile")
	cmd.Stderr = os.Stderr
	out, err = cmd.Output()
	if err != nil {
		return fmt.Errorf("%v: %w", cmd, err)
	}
	platformToolDir := filepath.Dir(string(bytes.TrimSpace(out)))
	if platformToolDir == "." {
		return errors.New("failed to locate cmd/compile for target platform")
	}

     * This cache improves performance by avoiding repeated parsing of client configuration rules.
     * The key is the rule string, and the value is a pair containing the client name and compiled pattern.
     */
    protected ConcurrentHashMap<String, Pair<String, Pattern>> clientRuleCache = new ConcurrentHashMap<>();

    /**

    PathScope MAIN_COMPILE = pathScope(
            "main-compile",
            ProjectScope.MAIN,
            DependencyScope.COMPILE_ONLY,
            DependencyScope.COMPILE,
            DependencyScope.PROVIDED);

    PathScope MAIN_RUNTIME =
            pathScope("main-runtime", ProjectScope.MAIN, DependencyScope.COMPILE, DependencyScope.RUNTIME);

    PathScope TEST_COMPILE = pathScope(

          <type>String</type>
          <description>
            Flags this Mojo as requiring the dependencies in the specified class path to be resolved before it can
            execute: {@code compile}, {@code runtime}, {@code test},
            {@code compile+runtime} (since Maven 3.0) or {@code runtime+system} (since Maven 3.0)
          </description>
        </field>
        <field>
          <name>dependencyResolution</name>

        mockIncludePatterns.add(Pattern.compile("https://example.com/.*"));
        mockIncludePatterns.add(Pattern.compile("https://test.com/.*"));
        mockIncludePatterns.add(Pattern.compile("https://sample.org/.*"));

        List<Pattern> mockExcludePatterns = new ArrayList<>();
        mockExcludePatterns.add(Pattern.compile("https://example.com/admin/.*"));

  interface Y {}

  static class A implements X, Y {}

  static class B implements X, Y {}

  /**
   * This test passes if the {@code concat(…).filter(…).filter(…)} statement at the end compiles.
   * That statement compiles only if {@link FluentIterable#concat concat(aIterable, bIterable)}
   * returns a {@link FluentIterable} of elements of an anonymous type whose supertypes are the <a

      <version>1.0</version>
      <scope>runtime</scope>
    </dependency>

    <dependency>
      <groupId>maven-test</groupId>
      <artifactId>scope-compile</artifactId>
      <version>1.0</version>
      <scope>compile</scope>
    </dependency>

    <dependency>
      <groupId>maven-test</groupId>
      <artifactId>scope-provided</artifactId>
      <version>1.0</version>

                            ]
                        },
                        {
                            "type": "org.gradle.api.tasks.compile.JavaCompile",
                            "member": "Method org.gradle.api.tasks.compile.JavaCompile.getSources()",
                            "acceptation": "Deprecated method removed",
                            "changes": [