DocLink documentationUrl = featureUsage.getDocumentationUrl();
        return documentationUrl == null ? null : documentationUrl.getUrl();
    }

    @Override
    public String getType() {
        return featureUsage.getType().name();
    }

    @Override
    public List<StackTraceElement> getStackTrace() {
        return diagnostics.getStack();
    }

    @Override

        FileMetadata fileMetadata = stat.stat(root);
        if (fileMetadata.getType() == FileType.RegularFile) {
            visitJarContents(root, visitor);
        } else if (fileMetadata.getType() == FileType.Directory) {
            visitDirectoryContents(root, visitor);
        }
    }

        @Override
        public FileType getType() {
            return FileType.Directory;
        }

        @Override
        public FileSystemNode asFileSystemNode() {
            return PartialDirectoryNode.withoutKnownChildren();
        }
    };

    /**
     * The type of the file.
     */
    FileType getType();

    FileSystemNode asFileSystemNode();

  CPred<"quant::ReshapableTo1DTensor($0.getType().cast<ShapedType>())">,
  "Checks if the value dims are all ones except the right most dim">;

def ReshapeTo1DTensor : NativeCodeCall<
  "quant::ReshapeTo1DTensor($_builder, $_loc, $0)">;

def HasEqualShape : Constraint<CPred<
  "$0.getType().cast<ShapedType>().hasRank() && "
  "$1.getType().cast<ShapedType>().hasRank() && "

      }
    }

    // Input rhs must be a constant with rank 2.
    if (constant.getType().getRank() != 2) return failure();

    // Create a tfl.transpose op that performs ZX transpose on `input`.
    auto create_z_x_transpose_op = [&](Value input) -> Value {
      RankedTensorType input_type =
          mlir::cast<RankedTensorType>(input.getType());
      const int input_rank = input_type.getRank();

            Collection<File> directoriesToCheck = vfsRoot.rootSnapshots()
                .filter(snapshot -> snapshot.getType() != FileType.Missing)
                .filter(watchableHierarchies::shouldWatch)
                .map(snapshot -> {
                    switch (snapshot.getType()) {
                        case RegularFile:
                            return new File(snapshot.getAbsolutePath()).getParentFile();

                FileSystemLocationFingerprint fingerprint;
                if (relativePath.isRoot()) {
                    if (snapshot.getType() == FileType.RegularFile) {
                        fingerprint = fingerprint(snapshot.getName(), snapshot.getType(), snapshot);
                    } else {
                        return SnapshotVisitResult.CONTINUE;
                    }
                } else {

public class DefaultDeprecationData implements DeprecationData {

    private final Type type;

    public DefaultDeprecationData(Type type) {
        this.type = type;
    }

    @Override
    public Type getType() {
        return type;
    }

    public static AdditionalDataBuilder<DeprecationData> builder() {
        return new DefaultDeprecationDataBuilder();
    }

        artifact.setVersion(version);
    }

    /** {@inheritDoc} */
    public String getScope() {
        return artifact.getScope();
    }

    /** {@inheritDoc} */
    public String getType() {
        return artifact.getType();
    }

    /** {@inheritDoc} */
    public String getClassifier() {
        return artifact.getClassifier();
    }

    /** {@inheritDoc} */
    public boolean hasClassifier() {

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val actual = analyseForTest(mainFile) {
            val type = getType(analysisSession, mainFile, mainModule, testServices)

            buildString {
                appendLine(DebugSymbolRenderer(renderTypeByProperties = true).renderType(analysisSession, type))

                appendLine()