!is KaDeclarationSymbol -> {
                // File, package, etc.
                return false
            }

            is KaSamConstructorSymbol -> {
                // SAM constructors are always top-level
                return false
            }

            is KaScriptSymbol -> {
                // Scripts are always top-level
                return false
            }

      return method.isVarArgs();
    }
  }

  static class ConstructorInvokable<T> extends Invokable<T, T> {

    final Constructor<?> constructor;

    ConstructorInvokable(Constructor<?> constructor) {
      super(constructor);
      this.constructor = constructor;
    }

    @Override
    final Object invokeInternal(@CheckForNull Object receiver, @Nullable Object[] args)

    private final Collection<TypeConverterBinding> typeConverterBindings;

    // ----------------------------------------------------------------------
    // Constructors
    // ----------------------------------------------------------------------

    @Inject
    PlexusXmlBeanConverter(final Injector injector) {
        typeConverterBindings = injector.getTypeConverterBindings();

      return method.isVarArgs();
    }
  }

  static class ConstructorInvokable<T> extends Invokable<T, T> {

    final Constructor<?> constructor;

    ConstructorInvokable(Constructor<?> constructor) {
      super(constructor);
      this.constructor = constructor;
    }

    @Override
    final Object invokeInternal(@CheckForNull Object receiver, @Nullable Object[] args)

func BuildMultiClusterComponent[T ComponentConstraint](c ComponentBuilder, constructor func(cluster *Cluster) T) *Component[T] {
	comp := &Component[T]{
		constructor: constructor,
		clusters:    make(map[cluster.ID]T),
	}
	c.registerHandler(comp)
	return comp
}

func (c *Controller) registerHandler(h handler) {

                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()`

  private static Map<String, String> toHashMap(Entry<String, String>[] entries) {
    return populate(new HashMap<String, String>(), entries);
  }

  // TODO: call conversion constructors or factory methods instead of using
  // populate() on an empty map
  private static <T, M extends Map<T, String>> M populate(M map, Entry<T, String>[] entries) {
    for (Entry<T, String> entry : entries) {

| 1  | `@param`      | Methods and constructors only                                                  | Include this if applicable                                                                                                                                                                 ...

        then:
        failure.assertHasCause('Could not create an instance of type Thing.')
        failure.assertHasCause('The constructor for type Thing should be annotated with @Inject.')
    }

    def "object creation fails with ObjectInstantiationException when type has multiple constructors not annotated"() {
        given:
        buildFile """
        class Thing {
            Thing() {}

    @Override
    protected void realRun() {
      try {
        delay(LONG_DELAY_MS);
      } catch (InterruptedException ok) {
      }
    }
  }

  /** For use as ThreadFactory in constructors */
  public static class SimpleThreadFactory implements ThreadFactory {
    @Override
    public Thread newThread(Runnable r) {
      return new Thread(r);
    }
  }