// Date in a Lifecycle Expiration Policy.
				events = append(events, Event{
					Action: DeleteVersionAction,
					RuleID: rule.ID,
					Due:    now,
				})
				// No other conflicting actions apply to an expired object delete marker
				break
			}

			if !rule.Expiration.IsDaysNull() {
				// Specifying the Days tag will automatically perform ExpiredObjectDeleteMarker cleanup

The highest version that matches all conditions is selected.
If no such version is found, Gradle fails with an error showing the conflicting declarations.
If this happens you can adjust your dependencies or dependency constraints declarations, or make other adjustments to the transitive dependencies if needed.

                                .setMessage("Ignored POM import for: " + toString(dependency) + " as already imported "
                                        + toString(present) + ". Add the conflicting managed dependency directly "
                                        + "to the dependencyManagement section of the POM."));
                    }
                }
            }

        return WalkResult::advance();
      } else if (device_str_attr.getValue() != launch.getDevice()) {
        return launch.emitOpError()
               << "inner op has conflicting 'device' attribute, "
                  "got '"
               << device_str_attr.getValue() << "' but expected '"
               << launch.getDevice() << "'";
      }
    } else {
      return launch.emitOpError()

            return ResolvedCoordinates.create(resolved);
        }

        if (mappings.incompatibleModules.contains(key)) {
            // TODO: We should enhance this warning to list the conflicting dependencies.
            warnings.addIncompatible(String.format(
                "Cannot determine variant coordinates for dependency '%s' since " +

                return null;
            }

            return buildFailure(configuration, withTaskAdvice, collisions);
        }

        /**
         * Throw an exception if any variants have conflicting identities.
         */
        public void assertNoConflicts() {
            for (VariantIdentity identity : byIdentity.keySet()) {
                List<ConfigurationInternal> collisions = byIdentity.get(identity);

				Plural: "alfa",
			},
			expectedNameConflictCondition: acceptedCondition,
			expectedEstablishedCondition:  installingCondition,
		},
		{
			name: "conflicting, installing before with true condition",
			in: newCRD("alfa.bravo.com").SpecNames("alfa", "delta-singular", "echo-kind", "foxtrot-listkind", "golf-shortname-1", "hotel-shortname-2").
				Condition(acceptedCondition).

  std::optional<jit::DeviceId> maybe_unknown_device;

  bool multiple_cpu_devices = false;
  bool multiple_gpu_devices = false;
  bool multiple_unknown_devices = false;

  // Returns 'true' if d0 and d1 are conflicting devices. If they are
  // compatible, update d1 with a more specific one.
  // TODO(sanjoy): Cache DeviceNameUtils::ParsedName inside device_info_cache.
  const auto is_multiple_devices =

	p.error(pos, fmt.Sprintf(format, args...))
}

func (p *pkgBuilder) declare(scope, altScope *Scope, obj *Object) {
	alt := scope.Insert(obj)
	if alt == nil && altScope != nil {
		// see if there is a conflicting declaration in altScope
		alt = altScope.Lookup(obj.Name)
	}
	if alt != nil {
		prevDecl := ""
		if pos := alt.Pos(); pos.IsValid() {
			prevDecl = fmt.Sprintf("\n\tprevious declaration at %s", p.fset.Position(pos))

	if len(s.params) > 0 {
		// Make a copy of params.
		mergedParams = make(map[string]any, len(params)+len(s.params))
		for k, v := range params {
			mergedParams[k] = v
		}

		// Copy non-conflicting values from this Source.
		for k, v := range s.params {
			if _, ok := mergedParams[k]; !ok {
				mergedParams[k] = v
			}
		}
	}

	return sourceImpl{
		read:   s.read,
		params: mergedParams,