}
            configurations.add(configurations.conf.copy())

            task('assertDeps') {
                def conf = configurations.conf
                def confCopy = configurations.confCopy
                def notCopy = configurations.notCopy
                doLast {
                    assert conf*.name == ['api-1.1.jar']
                    assert confCopy*.name == ['api-1.1.jar']

                '1.1'()
                '1.2'()
                '2.0'()
            }
        }

        buildFile << """
            dependencies {
                conf 'org:bar:1'
                conf 'org:baz:1'
                conf 'org:foo:[1.0,2.0)'
            }
        """

        when:
        repositoryInteractions {
            'org:bar:1' {
                expectResolve()
            }

            }

            dependencies {
               conf "cglib:cglib-nodep:3.2.4"
               conf "cglib:cglib:3.2.5"

               components {
                  withModule('cglib:cglib-nodep', CapabilityRule)
                  withModule('cglib:cglib', CapabilityRule)
               }
            }

            configurations.conf.resolutionStrategy.capabilitiesResolution {
                $rule

    String ext
    List<String> conf
    Map<String, String> mavenAttributes

    void hasAttributes(def ext, def type, def conf, def classifier = null) {
        assert this.ext == ext
        assert this.type == type
        assert this.conf == conf
        assert this.classifier == classifier
    }

    IvyDescriptorArtifact hasConf(def conf) {
        assert this.conf == conf
        return this
    }

        given:
        tmpDir.file(LockFileReaderWriter.UNIQUE_LOCKFILE_NAME) << "empty=conf"
        startParameter.isWriteDependencyLocks() >> true
        provider = newProvider()
        def modules = [module('org', 'foo', '1.0'), module('org','bar','1.3')] as Set
        provider.loadLockState('conf', owner)
        provider.persistResolvedDependencies('conf', owner, modules, emptySet())

        when:
        provider.buildFinished()

                    configurations.conf.extendsFrom(configurations.fooConf)
                    assert configurations.conf.allDependencies*.name == ['foo']

                    //replace:
                    configurations.conf.extendsFrom = [configurations.barConf] as Set
                    assert configurations.conf.allDependencies*.name == ['bar']
                }
            }
        """

        when:
        run "check"

		module="projectA"
		revision="1.2"
	/>
	<configurations>
		<conf name="runtime" visibility="public"/>
		<conf name="default" visibility="public" extends="runtime"/>
	</configurations>
	<publications>
		<artifact name="projectA" type="jar" ext="jar" conf="*"/>
	</publications>
    <dependencies>
        <dependency org="test" name="projectB" rev="latest.release" conf="runtime->default"/>
    </dependencies>

	}
}

func TestIssue16902(t *testing.T) {
	const src = `
package a

import "unsafe"

const _ = unsafe.Offsetof(struct{ x int64 }{}.x)
`
	info := types.Info{Types: make(map[ast.Expr]types.TypeAndValue)}
	conf := types.Config{
		Importer: importer.Default(),
		Sizes:    &types.StdSizes{WordSize: 8, MaxAlign: 8},
	}
	mustTypecheck(src, &conf, &info)
	for _, tv := range info.Types {

// the opPlusUconst operator is expected by the type parser.
const (
	opAddr       = 0x03 /* 1 op, const addr */
	opDeref      = 0x06
	opConst1u    = 0x08 /* 1 op, 1 byte const */
	opConst1s    = 0x09 /*	" signed */
	opConst2u    = 0x0A /* 1 op, 2 byte const  */
	opConst2s    = 0x0B /*	" signed */
	opConst4u    = 0x0C /* 1 op, 4 byte const */
	opConst4s    = 0x0D /*	" signed */

Laura Kassovic <******@****.***> 1701107622 -0800