Position(if (line == 0) 0 else line - 1, column)


class KotlinBuildScriptDependenciesResolver internal constructor(

    private
    val logger: ResolverEventLogger

) : ScriptDependenciesResolver {

    @Suppress("unused")
    constructor() : this(DefaultResolverEventLogger)

    override fun resolve(
        script: ScriptContents,
        environment: Map<String, Any?>?,

     * It may however contain more than one entry if module hierarchy was detected,
     * in which case there is one key per sub-directory.
     *
     * <p>This map may contain null values if the constructor was invoked with {@code resolve}
     * parameter set to false. This is more efficient when only the module existence needs to
     * be tested, and module descriptors are not needed.</p>
     *
     * @see #getModuleNames()

  @RetainedWith
  transient AbstractBiMap<V, K> inverse;

  /** Package-private constructor for creating a map-backed bimap. */
  AbstractBiMap(Map<K, V> forward, Map<V, K> backward) {
    setDelegates(forward, backward);
  }

  /** Private constructor for inverse bimap. */
  private AbstractBiMap(Map<K, V> backward, AbstractBiMap<V, K> forward) {
    delegate = backward;

    // requireNonNull is safe because we use indexes that were populated by the constructor.
    V value = requireNonNull(values[rowIndex][columnIndex]);
    return cellOf(rowKey, columnKey, value);
  }

  @Override
  V getValue(int index) {
    // requireNonNull is safe because we use indexes that were populated by the constructor.
    return requireNonNull(values[cellRowIndices[index]][cellColumnIndices[index]]);
  }

                isolationMode = $isolationMode
            }
        """

        expect:
        fails("runInWorker")

        and:
        failure.assertHasCause("Unable to determine constructor argument #1: missing parameter of type FileOperations, or no service of type FileOperations")

        where:
        isolationMode << ISOLATION_MODES
    }

{return Object.prototype.hasOwnProperty.call(t,e)},r.p="",r(r.s=0)}([function(t,e,n){"use strict";var r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},i=function(){function o(t,e){for(var n=0;n<e.length;n++){var o=e[n];o.enumerable=o.enumerable||!1,o.configurable=!0,"value"in o&&(o.writable=!0),Object.defineProperty(t,o.key,o)}}return function(t,e,n){return...

    internal var receivedResponseAtMillis: Long = 0
    internal var exchange: Exchange? = null
    internal var trailersFn: (() -> Headers) = { Headers.headersOf() }

    constructor() {
      headers = Headers.Builder()
    }

    internal constructor(response: Response) {
      this.request = response.request
      this.protocol = response.protocol
      this.code = response.code
      this.message = response.message

- Must be defined as an interface or an abstract class.
- Cannot be a parameterized type.
- Constructor DefaultStructBindingsStoreTest.MultipleProblems(java.lang.String) is not valid: Custom constructors are not supported.
- Field field2 is not valid: Fields must be static final.
- Constructor DefaultStructBindingsStoreTest.MultipleProblemsSuper(java.lang.String) is not valid: Custom constructors are not supported.

                ?.isDocumentedAsSince(version) == true
        }

    private
    fun KtFile.isDocumentedAsSince(version: String, declaringClass: CtClass, constructor: CtConstructor): Boolean {
        val classFqName = declaringClass.name
        val ctorParamTypes = constructor.parameterTypes.map { it.name }
        return collectDescendantsOfType<KtConstructor<*>>()
            .firstOrNull { ktCtor ->

                false

            // - The `this` in `constructor(x: Int) : this(x)`
            is KtConstructorDelegationReferenceExpression ->
                false

            // - Administrative node for EnumEntries. Never used as expression.
            is KtEnumEntrySuperclassReferenceExpression ->
                false

            // - The "reference" in a constructor call. E.g. `C` in `C()`