@Nonnull
        public Builder location(Object key, InputLocation location) {
            if (location != null) {
                if (!(this.locations instanceof HashMap)) {
                    this.locations = this.locations != null ? new HashMap<>(this.locations) : new HashMap<>();
                }
                this.locations.put(key, location);
            }
            return this;
        }

    private static List<ProblemLocation> fromList(List<Object> locations) {
        List<ProblemLocation> result = []
        locations.each { location ->
            if (location['pluginId'] != null) {
                result += new ReceivedPluginIdLocation(location as Map<String, Object>)
            } else if (location['line'] != null) {
                result += new ReceivedLineInFileLocation(location as Map<String, Object>)

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

        ProblemDiagnostics problemDiagnostics = problemStream.forCurrentCaller(exceptionForProblemInstantiation);
        Location loc = problemDiagnostics.getLocation();
        if (loc != null) {
            locations.add(getFileLocation(loc));
        }

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
    }