// Collect new return values for variable writes and either (a) output-only
  // resource attributes (if the resource is not promoted to an argument) or (b)
  // mapping from resource input index to output alias (if the resource has been
  // promoted to an argument). Resource arguments that were originally
  // `tf.VarHandleOp` but not read are collected and then removed.
  OpBuilder builder(return_op);

package b

import "./a"

var Here = a.New()
var Dir = Here.Dir

type T = struct {
	a.Here
	a.I
}

var X T

// Test exporting the type of method values for anonymous structs with
// promoted methods.
var A = a.A
var B = a.B
var C = a.C
var D = a.D
var E = a.E
var F = a.F
var G = (*a.T).Dir
var H = a.T.Dir
var I = a.X.Dir
var J = (*a.T).M
var K = a.T.M
var L = a.X.M

// run -goexperiment fieldtrack

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test that generics, promoted methods, and //go:nointerface
// interoperate as expected.

package main

import (
	"reflect"
)

func TypeString[T any]() string {
	return reflect.TypeOf(new(T)).Elem().String()
}

    %4 = "tf.Pack"(%0, %3) : (tensor<f32>, tensor<f32>) -> tensor<2xf32>
    func.return %4 : tensor<2xf32>
  }

  // One resource, one read. _is_initialized is true, should be promoted.
  // CHECK-LABEL: func @read(%arg0: tensor<f32> {tf.resource_name = "x"}) -> tensor<f32>
  func.func @read() -> tensor<f32> {
    // CHECK-NOT: "tf.VarHandleOp"
    // CHECK-NOT: "tf.ReadVariableOp"

    def fixture = new TestDeploymentFixture()

    def setup() {
        fixture.writeToProject(testDirectory)
        buildTimeout = 30
    }

    @ToBeFixedForConfigurationCache
    def "deployment promoted to continuous build reports accurate build time" () {
        when:
        withoutContinuousBuild()
        succeeds("runDeployment")

        then:
        def key = fixture.keyFile.text

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

package main

import (
	"fmt"
	"os"
	"reflect"
)

// Test that the struct field in anonunion.go was promoted.
var v1 T
var v2 = v1.L

// Test that P, Q, and R all point to byte.
var v3 = Issue8478{P: (*byte)(nil), Q: (**byte)(nil), R: (***byte)(nil)}

// Test that N, A and B are fully defined
var v4 = N{}

                " snapshot: ${snapshot.get()})"
        )
        if (BuildEnvironment.isCiServer) {
            lifecycle(
                "##teamcity[buildStatus text='{build.status.text}, Promoted version ${version.get()}']"
            )
        }
    }

import jetbrains.buildServer.configs.kotlin.FailureAction
import jetbrains.buildServer.configs.kotlin.RelativeId
import vcsroots.gradlePromotionMaster

abstract class BasePublishGradleDistribution(
    // The branch to be promoted
    val promotedBranch: String,
    val prepTask: String?,
    val triggerName: String,
    val gitUserName: String = "bot-teamcity",
    val gitUserEmail: String = "******@****.***",

                    ?.takeIf { conventionValue ->
                        // Prevent convention value to be assigned to a field of incompatible type
                        // A common cause is a regular field type being promoted to a Property/Provider type.
                        conventionValue.isAssignableTo(field.type)
                    } ?: fieldValue
            }
        }

    private

//
// Specifically, it combines the following concerns, each of which would be
// independent variables in a more generic setup:
//   - numBits and isSigned imply storage data type (uint8, int8, int16)
//   - numBits < 8 is promoted to uint8 or int8
//   - "narrow_range" narrows the lower bound of the storage type's range by
//     1
//   - the specified min/max values are "nudged" so that the result has a zero
//     that can be exactly expressed