@GwtCompatible
final class Partially {
  /**
   * The presence of this annotation on an API indicates that the method <i>may</i> be used with the
   * <a href="http://www.gwtproject.org/">Google Web Toolkit</a> (GWT) but that it has <i>some
   * restrictions</i>.
   */
  @Retention(RetentionPolicy.CLASS)
  @Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.FIELD})
  @Documented
  @interface GwtIncompatible {

For these language translation PRs, confirm that:

* The PR was automated (authored by @tiangolo), not made by another user.
* It has the labels `lang-all` and `lang-{lang code}`.

For PRs that update language-specific LLM prompts, confirm that:

* The PR has the labels `lang-all` and `lang-{lang code}`.
* It is approved by at least one native speaker.

        if (processOrdinary()) {
            return ttype;
        }
        ttype = peekc;
        return ttype;
    }

    /**
     * Returns the string that has already been read.
     *
     * @return The string that has already been read.
     */
    public String getReadString() {
        return str.substring(0, colno - 1);
    }

    private int read() {
        if (colno >= str.length()) {

public interface TransportProvider extends Service {
    /**
     * Provides new {@link Transport} instance for given {@link RemoteRepository}, if possible.
     *
     * @throws TransportProviderException if passed in remote repository has invalid remote URL or unsupported protocol.
     */
    @Nonnull
    Transport transport(@Nonnull Session session, @Nonnull RemoteRepository repository);

						{ForeignKey: "OwnerType", ForeignSchema: "Toy", PrimaryValue: "users"},
					},
				},
			},
		},
	})
}

func TestPolymorphic(t *testing.T) {
	t.Run("has one", func(t *testing.T) {
		type Toy struct {
			ID        int
			Name      string
			OwnerID   int
			OwnerType string
		}

		type Cat struct {
			ID   int
			Name string

Files in this directory are data for Go's API checker ("go tool api", in src/cmd/api).

Each file is a list of API features, one per line.

go1.txt (and similarly named files) are frozen once a version has been
shipped. Each file adds new lines but does not remove any.

except.txt lists features that may disappear without breaking true
compatibility.

Starting with go1.19.txt, each API feature line must end in "#nnnnn"

  private val postponedRoutes = mutableListOf<Route>()

  init {
    resetNextProxy(address.url, address.proxy)
  }

  /**
   * Returns true if there's another set of routes to attempt. Every address has at least one route.
   */
  operator fun hasNext(): Boolean = hasNextProxy() || postponedRoutes.isNotEmpty()

  @Throws(IOException::class)
  operator fun next(): Selection {

// errDiskNotFound - cannot find the underlying configured disk anymore.
var errDiskNotFound = StorageErr("drive not found")

// errDiskOngoingReq - indicates if the disk has an on-going request in progress.
var errDiskOngoingReq = StorageErr("drive still did not complete the request")

// errDriveIsRoot - cannot use the disk since its a root disk.

  // watched inputs.
  void Watch(const AbstractTensorHandle*);
  // Records an operation with given inputs and outputs
  // on the tape and marks all its outputs as watched if at
  // least one input of the op is watched and has a trainable dtype.
  // op_name is optional and is used for debugging only.
  void RecordOperation(absl::Span<AbstractTensorHandle* const> inputs,
                       absl::Span<AbstractTensorHandle* const> outputs,

import com.google.common.collect.ImmutableSet;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import org.jspecify.annotations.NullUnmarked;

/**
 * A byte sink for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class TestByteSink extends ByteSink implements TestStreamSupplier {

  private final ByteArrayOutputStream bytes = new ByteArrayOutputStream();