if (!matcher.matches()) {
            return null;
        }

        String className = null;
        if (matcher.group(1).length() > 0) {
            className = typeNameResolver.resolve(matcher.group(1), classMetaData);
            if (className == null) {
                return null;
            }
        }
        if (matcher.group(2) == null) {

     *
     * @param activeProfileIds The identifiers of those profiles to activate, may be {@code null}.
     * @return This context, never {@code null}.
     */
    public DefaultProfileActivationContext setActiveProfileIds(List<String> activeProfileIds) {
        if (activeProfileIds != null) {
            this.activeProfileIds = Collections.unmodifiableList(activeProfileIds);
        } else {

        if (cacheRecord != null && cacheRecord.getException() != null) {
            throw cacheRecord.getException();
        }

        return cacheRecord;
    }

    @Override
    public CacheRecord put(Key key, List<Artifact> pluginArtifacts) {
        Objects.requireNonNull(pluginArtifacts, "pluginArtifacts cannot be null");

        assertUniqueKey(key);

     *            information along, may be <code>null</code>.
     */
    public void merge(Model target, Model source, boolean sourceDominant, Map<?, ?> hints) {
        Objects.requireNonNull(target, "target cannot be null");

        if (source == null) {
            return;
        }

        Map<Object, Object> context = new HashMap<>();
        if (hints != null) {
            context.putAll(hints);
        }

    if (delegate != null) {
      metadata =
          Ints.constrainToRange(size(), CompactHashing.DEFAULT_SIZE, CompactHashing.MAX_SIZE);
      delegate.clear(); // invalidate any iterators left over!
      table = null;
      size = 0;
    } else {
      Arrays.fill(requireKeys(), 0, size, null);
      Arrays.fill(requireValues(), 0, size, null);
      CompactHashing.tableClear(requireTable());

        if (settings.isUsePluginRegistry()) {
            addViolation(problems, Severity.WARNING, "usePluginRegistry", null, "is deprecated and has no effect.");
        }

        List<String> pluginGroups = settings.getPluginGroups();

        if (pluginGroups != null) {
            for (int i = 0; i < pluginGroups.size(); i++) {
                String pluginGroup = pluginGroups.get(i).trim();

                Prerequisites prerequisites =
                        mavenProject.getModel().getDelegate().getPrerequisites();
                if (prerequisites != null && prerequisites.getMaven() != null) {
                    logger.warn(
                            "The project {} uses prerequisites"
                                    + " which is only intended for maven-plugin projects "

  * When annotating existing internal code, use `org.jetbrains.annotations.Contract`, e.g. `@Contract(null -> null; !null -> !null)`.
      When doing so, still annotate nullable parameters and the return type as `@Nullable`.
  * Do not use `@Contract` for public APIs.
  * For polynull public APIs, the solution has to be decided on a case-by-case basis.

Do not remove `null` checks on public API boundaries, even if the annotations (or rather lack of them) suggest this.

      int size = (keyList == null) ? 0 : keyList.count;
      checkPositionIndex(index, size);
      if (index >= (size / 2)) {
        previous = (keyList == null) ? null : keyList.tail;
        nextIndex = size;
        while (index++ < size) {
          previous();
        }
      } else {
        next = (keyList == null) ? null : keyList.head;
        while (index-- > 0) {
          next();

            throw new XmlPullParserException(e.getMessage(), null, e);
        }
    }

    public Settings read(InputStream in, boolean strict) throws IOException, XmlPullParserException {
        try {
            return new Settings(delegate.read(in, strict, null));
        } catch (XMLStreamException e) {
            throw new XmlPullParserException(e.getMessage(), null, e);
        }
    }