return null;
        }
        NodeInitializer nodeInitializer = getNodeInitializer(Cast.<ModelSchema<? extends T>>uncheckedCast(schema));
        if (nodeInitializer == null) {

        ClassWriter visitor = classGenerator.getVisitor();

        Type generatedType = classGenerator.getGeneratedType();

        Type superclassType = Type.getType(implClass);
        Type publicType = Type.getType(publicContractType);

        generateClass(visitor, generatedType, superclassType, publicType);
        generateConstructors(visitor, implClass, superclassType);
        visitor.visitEnd();

        int type = be.getOperation().getType();
        if ((type == Types.ASSIGNMENT_OPERATOR || type == Types.EQUAL)
            && left instanceof ClassExpression) {
            ClassExpression ce = (ClassExpression) left;
            String error = "you tried to assign a value to the class '" + ce.getType().getName() + "'";
            if (ce.getType().isScript()) {

bool HasEqualElementSize(Value val1, Value val2, ArrayRef<int> val1_indices,
                         ArrayRef<int> val2_indices) {
  ShapedType val1_shape = mlir::cast<ShapedType>(val1.getType());
  ShapedType val2_shape = mlir::cast<ShapedType>(val2.getType());
  if (!val1_shape.hasRank() || !val2_shape.hasRank()) return false;

  int val1_result = 1;
  int val2_result = 1;
  for (auto idx : val1_indices) {

      // Because of the property of graph region, the control operands may
      // not have been converted to tf_executor::ControlType.
      if (mlir::isa<tfg::ControlType>(value.getType()) ||
          mlir::isa<tf_executor::ControlType>(value.getType())) {
        if (!mlir::isa<BlockArgument>(value))
          island_control_operands.push_back(value);
      } else {
        inner_op_operands.push_back(value);
      }
    }

        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

    auto input_type = mlir::dyn_cast_or_null<RankedTensorType>(input.getType());
    if (!input_type) return failure();
    auto fft_len = rfft_op.getFftLength();
    auto fft_len_type = mlir::dyn_cast_or_null<ShapedType>(fft_len.getType());
    if (!fft_len_type) return failure();

    auto output_type =
        mlir::dyn_cast_or_null<RankedTensorType>(rfft_op.getResult().getType());
    if (!output_type) return failure();

        return find(ModelPath.path(path), type);
    }

    @Override
    public <T> T find(ModelPath path, ModelType<T> type) {
        return toType(type, get(path), "find(ModelPath, ModelType)");
    }

    private <T> T toType(ModelType<T> type, ModelNodeInternal node, String msg) {
        if (node == null) {
            return null;
        } else {

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

func setDefaultSockopts(s syscall.Handle, family, sotype int, ipv6only bool) error {
	if family == syscall.AF_INET6 && sotype != syscall.SOCK_RAW {
		// Allow both IP versions even if the OS default
		// is otherwise. Note that some operating systems
		// never admit this option.
		syscall.SetsockoptInt(s, syscall.IPPROTO_IPV6, syscall.IPV6_V6ONLY, boolint(ipv6only))
	}