docs: private void matchDestination(TypeInfo<?> destinationTypeInfo) {
      destinationTypes.add(destinationTypeInfo.getType());
  
      for (Map.Entry<String, Mutator> entry : destinationTypeInfo.getMutators().entrySet()) {
        propertyNameInfo.pushDestination(entry.getKey(), entry.getValue());
        String destPath = Strings.join(propertyNameInfo.getDestinationProperties());
        Mutator mutator = entry.getValue();
  
        // Skip explicit mappings
        Mapping existingMapping = typeMap.mappingFor(destPath);
        if (existingMapping == null) {
          matchSource(sourceTypeInfo, mutator, false);
          propertyNameInfo.clearSource();
          sourceTypes.clear();
        }
  
        // Use partially matched mappings only if there is no fully matched mapping
        if (mappings.isEmpty())
          mappings.addAll(partiallyMatchedMappings);
  
        if (!mappings.isEmpty()) {
          PropertyMappingImpl mapping;
          if (mappings.size() == 1) {
            mapping = mappings.get(0);
          } else {
            mapping = disambiguateMappings();
            if (mapping == null && !configuration.isAmbiguityIgnored())
              errors.ambiguousDestination(mappings);
          }
  
          if (mapping != null) {
            typeMap.addMappingIfAbsent(mapping);
  
            // If the mapping is potentially circular, add intermediate mappings
            if (Iterables.isIterable(mapping.getLastDestinationProperty().getType())) {
              for (PropertyInfo sourceAccessor : mapping.getSourceProperties()) {
                PropertyMappingImpl intermediateMapping = intermediateMappings.get(sourceAccessor);
                if (intermediateMapping != null
                    && !intermediateMapping.getPath().equals(mapping.getPath()))
                  typeMap.addMappingIfAbsent(intermediateMapping);
              }
            }
          }
  
          mappings.clear();
          partiallyMatchedMappings.clear();
          intermediateMappings.clear();
        } else if (!mergedMappings.isEmpty()) {
          for (InternalMapping mapping : mergedMappings)
            typeMap.addMappingIfAbsent(mapping);
          mergedMappings.clear();
        } else if (!destinationTypes.contains(mutator.getType())
            && !typeMap.isSkipped(destPath)
            && Types.mightContainsProperties(mutator.getType())
            && !isConvertable(existingMapping)) {
          matchDestination(mutator.getTypeInfo(configuration));
        }
  
        propertyNameInfo.popDestination();
      }
  
      destinationTypes.remove(destinationTypeInfo.getType());
      errors.throwConfigurationExceptionIfErrorsExist();
    }