Class<?> clazz = classNameTransformer.transform(type);
            if (clazz != null && causes.size() <= 1) {
                Constructor<?> constructor = clazz.getConstructor(String.class);
                Throwable reconstructed = (Throwable) constructor.newInstance(message);
                if (!causes.isEmpty()) {
                    reconstructed.initCause(causes.get(0));
                }

            }
        }

        Constructor<?>[] constructors = source.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors) {
            if (constructor.getParameterTypes().length > 0) {
                problems.add("Cannot declare a constructor that takes arguments");
                break;
            }
        }

    private fun <T> visitValueParameterReference(
        valueParameterReference: ConeValueParameterReference,
        constructor: (KaParameterSymbol) -> T
    ): T = constructor(
        if (valueParameterReference.parameterIndex == -1) firFunctionSymbol.receiverParameter
            ?: errorWithAttachment("${firFunctionSymbol::class} should contain a receiver") {

 */

package org.jetbrains.kotlin.analysis.api

@Target(
    AnnotationTarget.CLASS,
    AnnotationTarget.PROPERTY,
    AnnotationTarget.CONSTRUCTOR,
    AnnotationTarget.FUNCTION,
    AnnotationTarget.TYPEALIAS
)

      $this: VALUE_PARAMETER INSTANCE_RECEIVER name:<this> type:<root>.CodeFragment
      CONSTRUCTOR visibility:public <> () returnType:<root>.CodeFragment [primary]
        BLOCK_BODY
          DELEGATING_CONSTRUCTOR_CALL 'public constructor <init> () [primary] declared in kotlin.Any'
      FUN name:run visibility:public modality:FINAL <> () returnType:kotlin.Unit
        EXPRESSION_BODY

        return isAnnotatedWithIncubating(field) || isAnnotatedWithIncubating(field.jApiClass)
    }

    private static boolean isIncubatingConstructor(JApiConstructor constructor) {
        return isAnnotatedWithIncubating(constructor) || isAnnotatedWithIncubating(constructor.jApiClass)
    }

    protected boolean isOverride(JApiMethod method) {
        // No point in parsing the source file if the method is not there any more.

import org.jetbrains.kotlin.psi.KtCodeFragment
import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.psi.KtPsiFactory
import org.jetbrains.kotlin.test.Constructor
import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
import org.jetbrains.kotlin.test.directives.ConfigurationDirectives
import org.jetbrains.kotlin.test.directives.JvmEnvironmentConfigurationDirectives

type Comparator struct {
	envoy, istiod *configdump.Wrapper
	w             io.Writer
	context       int
	location      string
}

// NewComparator is a comparator constructor
func NewComparator(w io.Writer, istiodResponses map[string][]byte, envoyResponse []byte) (*Comparator, error) {
	c := &Comparator{}
	for _, resp := range istiodResponses {
		istiodDump := &configdump.Wrapper{}

 */
@Deprecated
public class MetadataXpp3Reader {

    private final MetadataStaxReader delegate;

    /**
     * Default constructor
     */
    public MetadataXpp3Reader() {
        delegate = new MetadataStaxReader();
    }

    /**
     * Constructor with ContentTransformer
     *
     * @param contentTransformer a transformer
     */

        // If we are at a super-type constructor call, adjust the resolution expression so that we
        // get the constructor instead of the class.
        //
        // For the example:
        //
        // class A {
        //   constructor()
        // }
        // class B: <caret>A()
        //
        // We want to resolve to the secondary constructor in A. Therefore, we check that the caret is at a supertype