builder.addAll(derivedVariants);
        Map<String, ModuleConfigurationMetadata> variantsByName = derivedVariants.stream().collect(Collectors.toMap(ConfigurationMetadata::getName, Function.identity()));
        for (AdditionalVariant additionalVariant : additionalVariants) {
            String name = additionalVariant.getName();

}

// mapRType asserts that typ is a map type, and returns an expression
// that yields the *runtime._type value representing typ.
func mapRType(pos src.XPos, typ *types.Type) ir.Node {
	return kindRType(pos, typ, types.TMAP)
}

// chanRType asserts that typ is a map type, and returns an expression
// that yields the *runtime._type value representing typ.
func chanRType(pos src.XPos, typ *types.Type) ir.Node {

                    final int y = DfTypeUtil.toInteger(v[1].trim());
                    return new Pair<>(x, y);
                }
                return null;
            }).filter(v -> v != null).collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
            propMap.put(SMB_AVAILABLE_SID_TYPES, params);
        }
        return params.get(sidType);
    }

    String getSupportedLanguages();

                    "but type '${this.renderForDebugging()}' has ${argumentTypes.size} type arguments."
        }

        val substitutor = substitutorByMap(typeParameterSymbols.zip(argumentTypes).toMap(), session)
        return superTypes.asSequence().map {
            val type = substitutor.substituteOrSelf(it)
            if (shouldApproximate) {
                session.typeApproximator.approximateToSuperType(

		as := ir.NewAssignStmt(base.Pos, hu, ir.NewBinaryExpr(base.Pos, ir.OADD, huVal, ir.NewInt(base.Pos, elem.Size())))
		nfor.Post = ir.NewBlockStmt(base.Pos, []ir.Node{nfor.Post, as})

	case k == types.TMAP:
		// order.stmt allocated the iterator for us.
		// we only use a once, so no copy needed.
		ha := a

		hit := nrange.Prealloc
		th := hit.Type()
		// depends on layout of iterator struct.

                                || b.getOriginalKey().getQualifier() == null
                                || b.getOriginalKey().getQualifier() instanceof String)
                        .collect(Collectors.toMap(
                                b -> (String)
                                        (b.getOriginalKey() != null
                                                ? b.getOriginalKey().getQualifier()

        }
      #elseif( $field.type == "java.util.Properties" )
        Map<String, String> map = ${field.name}.entrySet().stream()
                .collect(Collectors.toMap(e -> e.getKey().toString(), e -> e.getValue().toString()));
        if (!Objects.equals(map, getDelegate().get${cap}())) {
            update(getDelegate().with${cap}(map));
        }

                counter++;
                final Map<String, Object> localDataMap =
                        dataMap.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
                String processingUrl = urlQueue.poll();
                processedUrls.add(processingUrl);
                if (deleteUrlList.contains(processingUrl)) {

                    if (fields != null) {
                        docMap.putAll(fields.entrySet().stream()
                                .collect(Collectors.toMap(Entry::getKey, e -> (Object) e.getValue().getValues())));
                    }

                    final ViewHelper viewHelper = ComponentUtil.getViewHelper();

            .collect(
                Collectors.toMap(
                    InterceptGroovyCallsGenerator::propertyReceiverType,
                    InterceptGroovyCallsGenerator::propertyValueType,
                    (a, b) -> {
                        if (!a.equals(b)) {