return;
            }
            if (consumerValue.getName().equals(Usage.JAVA_API)) {
                if (COMPATIBLE_WITH_JAVA_API.contains(producerValue.getName())) {
                    details.compatible();
                }
                return;
            }
            if (consumerValue.getName().equals(Usage.JAVA_RUNTIME) && producerValue.getName().equals(DEPRECATED_JAVA_RUNTIME_JARS)) {

  auto name = namedAttr.getName().strref();
  return name.starts_with("tf_saved_model.");
}

void StripModule(Operation *module) {
  auto stripAttrs = llvm::to_vector<4>(llvm::make_filter_range(
      module->getAttrs(),
      [](NamedAttribute namedAttr) { return ShouldStripAttr(namedAttr); }));
  for (auto namedAttr : stripAttrs) {
    module->removeAttr(namedAttr.getName());
  }
}

      func.removeArgAttr(i, namedAttr.getName());
    }
  }

  for (int i = 0; i < func.getNumResults(); ++i) {
    auto stripAttrs = llvm::to_vector<4>(llvm::make_filter_range(
        func.getResultAttrs(i),
        [](NamedAttribute namedAttr) { return ShouldStripAttr(namedAttr); }));
    for (auto namedAttr : stripAttrs) {
      func.removeResultAttr(i, namedAttr.getName());
    }
  }
}

                String.format(
                    "publication objects must implement the '%s' interface, implementation '%s' does not",
                    IvyPublicationInternal.class.getName(),
                    publication.getClass().getName()
                )
            );
        }
    }

    /**
     * The repository to publish to.
     *
     * @return The repository to publish to
     */

                        final int i = getName().length();
                        setSerializableSupplier(() -> i);
                        setNonSerializableSupplier(() -> i);
                    }

                    public void setInstanceCapturingLambda() {
                        setSerializableSupplier(() -> getName().length());
                        setNonSerializableSupplier(() -> getName().length());
                    }

            String name = replaceArrow(dependency.getName());
            LinkedHashMap<String, Object> map = new LinkedHashMap<>(5);
            map.put("name", replaceArrow(dependency.getName()));
            map.put("description", dependency.getDescription());
            map.put("resolvable", dependency.getResolutionState());
            map.put("hasConflict", !name.equals(dependency.getName()));

        when:
        buildScript '''
            @Managed
            abstract class Person {
                abstract String getName()
                abstract void setName(String name)
            }

            class RulePlugin extends RuleSource {
                @Model
                void createPerson(Person person) {
                    person.name = "foo"

                Class<?> previousDeclaringClass = processedMethods.put(method.getName(), declaringClass);
                if (taskActionFactory instanceof IncrementalTaskActionFactory
                    && foundIncrementalTaskActionFactory != null
                    && method.getName().equals(foundIncrementalTaskActionFactory.getMethod().getName())
                ) {

  llvm::StringRef ref = GetUniqueName(GetName(op_or_val), hash_value);
  name = StringRefToView(ref);
  return ref;
}

absl::string_view OpOrArgNameMapper::GetUniqueNameView(OpOrVal op_or_val) {
  auto& name = op_or_val_to_name_[op_or_val];
  if (!name.empty()) return name;
  // Update the value in the map with unique name.
  name = StringRefToView(GetUniqueName(GetName(op_or_val)));
  return name;
}

            if (profileProp != null) {
                ActivationProperty prop = new ActivationProperty();

                prop.setName(profileProp.getName());
                prop.setValue(profileProp.getValue());

                activation.setProperty(prop);
            }

            ActivationOS profileOs = profileActivation.getOs();