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:

                  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,

        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() {

  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()));
  });
}

TEST(ErrorUtilTest, StatusScopedDiagnosticHandlerWithFilter) {
  // Filtering logic is based on tensorflow::IsInternalFrameForFilename()
  // Note we are surfacing the locations that are NOT internal frames
  // so locations that fail IsInternalFrameForFilename() evaluation pass the
  // filter.

  // These locations will fail the IsInternalFrameForFilename() check so will
  // pass the filter.
  MLIRContext context;
  auto id =

    public DefaultProblemsOperationContext(
        @Nullable Details details,
        List<Location> locations,
        List<Solution> solutions,
        AdditionalData additionalData,
        @Nullable FailureContainer failure
    ) {
        this.details = details;
        this.locations = locations;
        this.solutions = solutions;
        this.additionalData = additionalData;
        this.failure = failure;

    /**
     * Invalidate the given locations as they are about to be updated.
     */
    void invalidate(Iterable<String> locations);

    /**
     * Runs an action which potentially writes to the given locations.
     */
    void write(Iterable<String> locations, IoRunnable action) throws IOException;

    /**
     * Updates the cached state at the location with the snapshot.

        deserialized[0].definition.id.name == "type"
        deserialized[0].definition.id.displayName == "label"
        deserialized[0].locations[0].path == "location"
        deserialized[0].locations[0].line == 1
        deserialized[0].locations[0].column == 2
        deserialized[0].locations[0].length == 3
        deserialized[0].definition.documentationLink == null
    }