}

// This corresponds to tensorflow::Tensor.
def TFTensorType : DialectType<Fallback_Dialect,
    CPred<"$_self.isa<::tfrt::fallback::TFTensorType>()">, "!tfrt_fallback.tf_tensor type">,
    BuildableType<"$_builder.getType<::tfrt::fallback::TFTensorType>()"> {
  let description = [{
    `!tfrt_fallback.tf_tensor type` represents a tensorflow::Tensor.
  }];
}

// This corresponds to tensorflow::Allocator.

            op->getLoc(),
            CloneTypeWithNewElementType(input.getType(), rewriter.getF32Type()),
            input);
        op->setOperand(i, f32_cast);
      }
    }

    // Casts BF16 outputs of the operation.
    for (Value value : op->getResults()) {
      if (getElementTypeOrSelf(value).isBF16()) {
        value.setType(CloneTypeWithNewElementType(value.getType(),

    }

    private static PropertySetter mutateUsingGetter(final Field field) {
        if (HasMultipleValues.class.isAssignableFrom(field.getType())) {
            return new MultipleValuePropertyFieldSetter(getGetter(field), field);
        }
        if (FileSystemLocationProperty.class.isAssignableFrom(field.getType())) {
            return new FileSystemLocationPropertyFieldSetter(getGetter(field), field);
        }

        boolean annotated = extractionContext.getType().isAnnotationPresent(UnmanagedStruct.class);
        return new UnmanagedImplStructSchema<R>(extractionContext.getType(), properties, nonPropertyMethods, aspects, annotated);
    }

                final MediaType mediaTypeFromFilename = mimeTypes.detect(null, metadata);
                return mediaTypeFromFilename.getType() + "/" + mediaTypeFromFilename.getSubtype();
            }
            return mediaType.getType() + "/" + mediaType.getSubtype();
        } catch (final IOException e) {
            throw new MimeTypeException("Could not detect a content type.", e);
        }
    }

            propertyMetaData.setType(new TypeMetaData(type.getName()));

            Element para = doc.createElement("para");
            para.appendChild(doc.createTextNode("The "));
            para.appendChild(linkRenderer.link(propertyMetaData.getType(), listener));

            .thenReturn(extensionContainer)
        whenever(extensionContainer.getByType(eq(extensionType)))
            .thenReturn(extension)

        gradle.the<MyExtension>()
        gradle.configure<MyExtension> {}

        inOrder(extensionContainer) {
            verify(extensionContainer).getByType(eq(extensionType))
            verify(extensionContainer).configure(eq(extensionType), any<Action<MyExtension>>())

}

// This corresponds to tensorflow::Tensor.
def TFTensorType : DialectType<TensorflowMlrt_Dialect,
    CPred<"$_self.isa<::tensorflow::tf_mlrt::TFTensorType>()">, "!tf_mlrt.tensor type">,
    BuildableType<"$_builder.getType<::tensorflow::tf_mlrt::TFTensorType>()"> {
  let description = [{
    `!tf_mlrt.tensor type` represents a tensorflow::Tensor.
  }];
}

// This corresponds to tensorflow::Device* .

                return cache.get(dependency.getType()) == null;
            }
        }));
    }

    private <T> void validate(DefaultModelSchemaExtractionContext<T> extractionContext, ModelSchemaCache cache) {
        extractionContext.validate(cache.get(extractionContext.getType()));
    }

        if (!(schema instanceof ManagedImplStructSchema)) {
            return null;
        }
        if (!isTarget(schema.getType())) {
            return null;
        }

        StructBindings<T> bindings = bindingsStore.getBindings(schema.getType());
        return new StructNodeInitializer<T>(bindings);
    }

    @Override
    public Iterable<ModelType<?>> supportedTypes() {