}
        // mark all versions as unused
        versions.each { version ->
            markUnused(version)
        }
        // Remove VCS mappings
        settingsFile.text = ""
        cleanupNow()

        when:
        // Not resolving any configurations
        succeeds("tasks", "-PrepoVersion=dummy")
        then:
        // unused VCS working directories are still deleted

    assertEquals(Prepender.class, Prepender.constructor().getReturnType().getType());
  }

  private static class WithConstructorAndTypeParameter<T> {
    @SuppressWarnings("unused") // by reflection
    <X> WithConstructorAndTypeParameter() {}
  }

  public void testConstructor_returnType_hasTypeParameter() throws Exception {

    assertEquals(Prepender.class, Prepender.constructor().getReturnType().getType());
  }

  private static class WithConstructorAndTypeParameter<T> {
    @SuppressWarnings("unused") // by reflection
    <X> WithConstructorAndTypeParameter() {}
  }

  public void testConstructor_returnType_hasTypeParameter() throws Exception {

        @Configuring
        @Suppress("unused")
        abstract fun configureNestedReceiver(configure: Action<in NestedReceiver>)
    }

    private
    abstract class NestedReceiver {
        @get:Restricted
        @Suppress("unused")
        abstract val property: Property<Int>
    }

    private
    abstract class UtilsContainer {
        @Restricted
        @Suppress("unused")

  echo ""
  echo "${noncanonical}"
fi

unused=$(comm -23 \
  <(go mod edit -json | jq -r '.Replace[] | select(.New.Version != null) | .Old.Path' | sort) \
  <(go list -m -json all | jq -r .Path | sort))
if [[ -n "${unused}" ]]; then
  echo ""
  echo "Use the given commands to remove pinned module versions that aren't actually used:"
  echo "${unused}" | xargs -L 1 echo 'go mod edit -dropreplace'
fi

	"time"
)

const N = 250

type A struct {
	b *B
	n int
}

type B struct {
	n int
}

var i int
var nfinal int
var final [N]int

// the unused return is to test finalizers with return values
func finalA(a *A) (unused [N]int) {
	if final[a.n] != 0 {
		println("finalA", a.n, final[a.n])
		panic("fail")
	}
	final[a.n] = 1
	return
}

func finalB(b *B) {
	if final[b.n] != 1 {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package unusedresult defines an analyzer that checks for unused
// results of calls to certain pure functions.
//
// # Analyzer unusedresult
//
// unusedresult: check for unused results of calls to some functions
//
// Some functions like fmt.Errorf return a result and have no side

        currentModulesMetadataDir = currentModulesDir.file(CacheLayout.META_DATA.key).createDir()
        gcFile.createFile()
    }

    def "cleans up unused versions of caches when latest cache requires cleanup"() {
        given:
        gcFile.lastModified = daysAgo(2)

        when:
        succeeds("help")

        then:
        oldModulesDir.assertDoesNotExist()

import javax.annotation.Nullable;

/**
 * Describes a specific problem without context.
 * <p>
 * For example, in the domain of Java compilation problems, an unused variable warning could be described as such:
 * <ul>
 *     <li>category: compilation:java</li>
 *     <li>unused variable</li>
 *     <li>severity: WARNING</li>
 *     <li>...</li>
 * </ul>
 * <p>

	}
	return sync
}

// nolint: unused // (not true, its to implement an interface)
func (j *join[T]) augment(a any) any {
	// not supported in this collection type
	return a
}

// nolint: unused // (not true, its to implement an interface)
func (j *join[T]) name() string { return j.collectionName }

// nolint: unused // (not true, its to implement an interface)