pkg go/types, method (*Info) ObjectOf(*ast.Ident) Object
pkg go/types, method (*Info) TypeOf(ast.Expr) Type
pkg go/types, method (*Initializer) String() string
pkg go/types, method (*Interface) Complete() *Interface
pkg go/types, method (*Interface) Embedded(int) *Named
pkg go/types, method (*Interface) Empty() bool
pkg go/types, method (*Interface) ExplicitMethod(int) *Func

            }
        } finally {
            waitingThreadNames.remove(threadName);
        }
        return true;
    }

    /**
     * Waits for all waiting threads to complete.
     */
    public void waitForNoWaitingThreads() {
        int count = waitingThreadNames.size();
        while (count > 0) {
            if (logger.isInfoEnabled()) {

	extraLen := int(b.uint16())
	return int64(fileHeaderLen + filenameLen + extraLen), nil
}

// readDirectoryHeader attempts to read a directory header from r.
// It returns io.ErrUnexpectedEOF if it cannot read a complete header,
// and ErrFormat if it doesn't find a valid header signature.
func readDirectoryHeader(f *File, r io.Reader) error {
	var buf [directoryHeaderLen]byte
	if _, err := io.ReadFull(r, buf[:]); err != nil {

		}

		parts = append(parts, CompletePart{
			PartNumber: partNumber,
			ETag:       canonicalizeETag(resp.ETag),
		})
	}

	var completeBytes []byte
	// Complete multipart upload parts.
	completeUploads := &CompleteMultipartUpload{
		Parts: parts,
	}
	completeBytes, err = xml.Marshal(completeUploads)
	if err != nil {

import java.util.concurrent.atomic.AtomicReference;
import org.jspecify.annotations.Nullable;

/**
 * A step in a pipeline of an asynchronous computation. When the last step in the computation is
 * complete, some objects captured during the computation are closed.
 *
 * <p>A pipeline of {@code ClosingFuture}s is a tree of steps. Each step represents either an

    return asImmutableList(elements, elements.length);
  }

  /**
   * Views the array as an immutable list. Copies if the specified range does not cover the complete
   * array. Does not check for nulls.
   */
  static <E> ImmutableList<E> asImmutableList(@Nullable Object[] elements, int length) {
    switch (length) {
      case 0:
        return of();
      case 1:

// collectFragments reads until the first occurrence of delim in the input. It
// returns (slice of full buffers, remaining bytes before delim, total number
// of bytes in the combined first two elements, error).
// The complete result is equal to
// `bytes.Join(append(fullBuffers, finalFragment), nil)`, which has a
// length of `totalLen`. The result is structured in this way to allow callers
// to minimize allocations and copies.

            throw new SmbException(ioe.getMessage(), ioe);
        }
        final SmbNegotiationResponse r = this.negotiated;
        if (r == null) {
            throw new SmbException("Connection did not complete, failed to get negotiation response");
        }
        return r;
    }

    /**
     * @return whether this is SMB2 transport
     * @throws SmbException
     */
    @Override

common:rbe_linux_cpu_clang_local --repo_env=CC="/usr/lib/llvm-18/bin/clang"
common:rbe_linux_cpu_clang_local --repo_env=TF_SYSROOT="/dt9"

# TODO(kanglan): Remove it after toolchain update is complete.
common:rbe_linux_cpu_old --config=rbe_linux
common:rbe_linux_cpu_old --host_crosstool_top="@ubuntu20.04-gcc9_manylinux2014-cuda11.2-cudnn8.1-tensorrt7.2_config_cuda//crosstool:toolchain"

        // Create a completely isolated context to avoid handle reuse issues on Linux Docker
        try {
            // Create a new context with fresh configuration each time
            // This ensures complete isolation between operations
            Properties props = new Properties();
            props.setProperty("jcifs.smb.client.minVersion", "SMB202");
            props.setProperty("jcifs.smb.client.maxVersion", "SMB311");