Map<Object, InputLocation> locations;
        Map<Object, InputLocation> sourceLocations = source.locations;
        Map<Object, InputLocation> targetLocations = target.locations;
        if (sourceLocations == null) {
            locations = targetLocations;
        } else if (targetLocations == null) {
            locations = sourceLocations;
        } else {
            locations = new LinkedHashMap<>();

        Map<Object, InputLocation> locations;
        Map<Object, InputLocation> sourceLocations = source.locations;
        Map<Object, InputLocation> targetLocations = target.locations;
        if (sourceLocations == null) {
            locations = targetLocations;
        } else if (targetLocations == null) {
            locations = sourceLocations;
        } else {
            locations = new LinkedHashMap<>();

        if (name_loc.getName().strref().ends_with(":")) {
          if (locations.size() == 2)
            return locations[1];
          else if (locations.size() > 2)
            return mlir::FusedLoc::get(
                fused_loc.getContext(),
                {locations.begin() + 1, locations.end()});
        }
      }
    }
  }
  return loc;
}

        def supplier = createSupplier()

        when:
        def locations = supplier.get()

        then:
        locations*.location.path.containsAll("c:\\jdk8", "d:\\jdk9", "c:\\jdk17", "d:\\jdk11", "c:\\jdk15", "d:\\jdk16")
        locations*.source == ["Windows Registry"] * 6
    }

    def "handles absent adoptopenjdk keys"() {
        given:

    def "prefers location specified in user settings file over that in global settings file"() {
        writeSettingsFile(locations.userSettingsFile, repo1)
        writeSettingsFile(locations.globalSettingsFile, repo2)

        expect:
        locator.localMavenRepository == repo1
    }

    def "ignores changes to maven settings file after initial load"() {
        when:
        writeSettingsFile(locations.userSettingsFile, repo1)

                  return LocationExtractor(locations[1]).Extract(error_data);
                } else if (num_locs > 2) {
                  locations = {locations.begin() + 1, locations.end()};
                }
              }
            }
          }

          mutable_location->set_type(ConverterErrorData::FUSEDLOC);
          llvm::interleave(
              locations,

    private final String message;
    private final Collection<String> locations;

    public ComponentNotFound(String message) {
        this.message = message;
        this.locations = Collections.emptyList();
    }

    public ComponentNotFound(String message, Collection<String> locations) {
        this.message = message;
        this.locations = locations;
    }

    @Override
    public T getComponent() {

        this.contextualLabel = contextualLabel;
        this.details = details;
        this.locations = locations;
        this.solutions = solutions;
        this.additionalData = additionalData;
        this.failure = failure;
    }

    @Override
    public ProblemDefinition getDefinition() {
        return problemDefinition;
    }

    @Override
    public ContextualLabel getContextualLabel() {

import java.util.concurrent.atomic.AtomicReference;

/**
 * Keeps track of how locations should be watched:
 *
 * - Immutable locations are managed by Gradle, i.e. file system changes should never be external,
 *   and therefore these locations should not be watched to cut down on the number of watchers needed.
 *
 * - Locations known to be modified during a build might receive late file events that would invalidate VFS state we just

  StringRef op_type_with_suffix =
      mlir::cast<NameLoc>(locations.front()).getName().strref();
  if (!op_type_with_suffix.ends_with(":")) return false;

  return absl::c_all_of(locations, [](Location loc) {
    return isa<NameLoc>(loc) ||
           (isa<CallSiteLoc>(loc) &&
            isa<NameLoc>(mlir::cast<CallSiteLoc>(loc).getCallee()));
  });
}