get() = contents.text

    fun map(transform: (ProgramText) -> ProgramText) =
        ProgramSource(path, transform(contents))
}


/**
 * Normalised program text guaranteed to use `\n` as the only line terminator character.
 */
data class ProgramText private constructor(val text: String) {

    companion object {

        internal
        fun from(string: String) =
            ProgramText(string.replace("\r\n", "\n"))

	// recorded elsewhere (e.g., via PAX record) contains no trailing slash.
	if len(s) > len(b) && b[len(b)-1] == '/' {
		n := len(strings.TrimRight(s[:len(b)-1], "/"))
		b[n] = 0 // Replace trailing slash with NUL terminator
	}
}

// fitsInBase256 reports whether x can be encoded into n bytes using base-256
// encoding. Unlike octal encoding, base-256 encoding does not require that the

	for i, c := range data {
		if err := b.WriteByte(c); err != nil {
			return i, err
		}
	}
	return len(data), nil
}

func (b blockWriter) close() {
	// Write the block terminator (0x00), either by itself, or along with a
	// pending sub-block.
	if b.e.buf[0] == 0 {
		b.e.writeByte(0)
	} else {
		n := uint(b.e.buf[0])
		b.e.buf[n+1] = 0
		b.e.write(b.e.buf[:n+2])
	}

	if atEOF && len(data) == 0 {
		return 0, nil, nil
	}
	sep := len([]byte(yamlSeparator))
	if i := bytes.Index(data, []byte(yamlSeparator)); i >= 0 {
		// We have a potential document terminator
		i += sep
		after := data[i:]
		if len(after) == 0 {
			// we can't read any more characters
			if atEOF {
				return len(data), data[:len(data)-sep], nil
			}
			return 0, nil, nil
		}

env GO111MODULE=on

[short] skip

# Arguments after the flag terminator should be ignored.
# If we pass '-- -test.v', we should not get verbose output
# *and* output from the test should not be echoed.
go test ./x -- -test.v
stdout '\Aok\s+example.com/x\s+[0-9.s]+\n\z'
! stderr .

# For backward-compatibility with previous releases of the 'go' command,
# arguments that appear after unrecognized flags should not be treated

            remaining_incoming_ctrl_edges[user] == 0) {
          ready.push_back(user);
        }
      }
    }

    // Find the "best" operation to emit. We
    // (a) emit the terminator last.
    // (b) honor the priority function (as far as possible).
    // (c) preserve order within the ops of one dialect.
    auto better = [&](Operation* a, Operation* b) {

// and some are for both.

// ErrFlagTerminator indicates the distinguished token "--", which causes the
// flag package to treat all subsequent arguments as non-flags.
var ErrFlagTerminator = errors.New("flag terminator")

// A FlagNotDefinedError indicates a flag-like argument that does not correspond
// to any registered flag in a FlagSet.
type FlagNotDefinedError struct {

		prefix = []uint16{'\\', '\\', '?', '\\'}
	}

	p, err := syscall.UTF16FromString(path)
	if err != nil {
		return path
	}
	// Estimate the required buffer size using the path length plus the null terminator.
	// pathLength includes the working directory. This should be accurate unless
	// the working directory has changed without using os.Chdir.
	n := uint32(pathLength) + 1
	var buf []uint16
	for {

  let hasVerifier = 1;
  let hasCustomAssemblyFormat = 1;
}

def TFR_TFRReturnOp : TFR_Op<"return", [HasParent<"TFRFuncOp">, Pure,
                                        ReturnLike, Terminator]> {
  let description = [{
    A terminator operation for regions that appear in the body of  `tfr.func`
    functions. The operands to the `tfr.return` are the result values returned
    by an invocation of the `tfr.func`.

      $_state.addTypes(result_types);
      $_state.addRegion();
    }]>
  ];

  let hasCanonicalizer = 1;
}

def TfDevice_ReturnOp : TfDevice_Op<"return", [Pure, ReturnLike, Terminator]> {
  let summary = [{
The `tf_device.return` operation terminates and returns values from a
`tf_device` dialect operation.
  }];

  let arguments = (ins
    Variadic<AnyType>:$results
  );