func (check *Checker) brokenAlias(alias *TypeName) {
	assert(!check.conf.EnableAlias)
	if check.brokenAliases == nil {
		check.brokenAliases = make(map[*TypeName]bool)
	}
	check.brokenAliases[alias] = true
	alias.typ = Typ[Invalid]
}

// validAlias records that alias has the valid type typ (possibly Typ[Invalid]).
func (check *Checker) validAlias(alias *TypeName, typ Type) {
	assert(!check.conf.EnableAlias)

        bean.uncheckedCast<IConventionAware>()
            .conventionMapping
            .getConventionValue<Any?>(fieldValue, field.name, false)

    private
    fun Field.debugFrameName() =
        "${declaringClass.typeName}.$name"

    private
    fun Any?.isAssignableTo(type: Class<*>) =
        (if (type.isPrimitive) wrap(type) else type)
            .isInstance(this)

func Unalias(t types.Type) types.Type { return types.Unalias(t) }

// newAlias is an internal alias around types.NewAlias.
// Direct usage is discouraged as the moment.
// Try to use NewAlias instead.
func newAlias(tname *types.TypeName, rhs types.Type) *Alias {
	a := types.NewAlias(tname, rhs)
	// TODO(go.dev/issue/65455): Remove kludgy workaround to set a.actual as a side-effect.
	Unalias(a)
	return a
}

            it.id("id", "label", GradleCoreProblemGroup.validation())
                .additionalData(TypeValidationDataSpec.class) {
                    it.propertyName("property")
                    it.typeName("type")
                    it.parentPropertyName("parent")
                    it.pluginId("id")
                }
        }

        when:
        def json = gson.toJson([problem])

enum QuantizationTrait { kFullQuantization, kDynamicRangeQuantization };

// Base struct for quantization.
template <QuantizationTrait quantization_trait, typename ConcreteT,
          typename RootOpT = DequantizeOp>
struct TFLQuantizationBase
    : public quant::QuantizationPattern<ConcreteT, QuantizeOp, DequantizeOp,
                                        NumericVerifyOp, RootOpT> {

            solutions == [
                'Assign a value to \'destFile\'',
                'Mark property \'destFile\' as optional',
            ]
            additionalData.asMap == [
                'typeName' : 'CustomTask',
                'propertyName' : 'destFile',
            ]
        }
        verifyAll(receivedProblem(1)) {
            fqid == 'validation:property-validation:value-not-set'

inline const char kMlirPh1BridgeCounterNonTpu[] = "cpu/gpu";
inline const char kXlaOutsideCompilation[] = "_xla_outside_compilation";

// Copies attributes that satisfy the given predicate from `from` to `to`.
template <typename Predicate>
void CopyAttributes(Operation *from, Operation *to, Predicate P) {
  for (const NamedAttribute &attr : from->getAttrs())
    if (P(attr)) to->setAttr(attr.getName(), attr.getValue());
}

		res := hf(ctx, i)
		if res == nil {
			return nil
		}
		return []O{*res}
	}
	o := buildCollectionOptions(opts...)
	if o.name == "" {
		o.name = fmt.Sprintf("Collection[%v,%v]", ptr.TypeName[I](), ptr.TypeName[O]())
	}
	return newManyCollection[I, O](c, hm, o)
}

// NewManyCollection transforms a Collection[I] to a Collection[O] by applying the provided transformation function.

namespace mlir {
namespace odml {

// Ensure an attribute named attr_name exists and it is of type AttrType.
// If so, sets the `out_attr` pointer to point to the casted attribute.
template <typename AttrType>
bool EnsureAttribute(const DictionaryAttr& composite_attributes,
                     const std::string& attr_name, AttrType* out_attr) {
  Attribute attr = composite_attributes.get(attr_name);

// ShapeContainerT is any type with the following methods:
//   bool hasRank()
//   ArrayRef<int64_t> getShape()
// This includes mlir::TF::ShapeAttr and mlir::ShapedType.
template <typename ShapeContainerT>
void SetTensorShapeProto(ShapeContainerT shape, TensorShapeProto* proto) {
  if (shape.hasRank()) {
    for (int64_t dim : shape.getShape()) {