switch {
			case typVal.IsType():
				// Type conversion, which is safe.
			case typVal.IsBuiltin():
				// Builtin func, conservatively assumed to not
				// be safe for now.
				safe = false
				return false
			default:
				// A non-builtin func or method call.
				// Conservatively assume that all of them have
				// side effects for now.
				safe = false
				return false
			}
		case *ast.UnaryExpr:

    const llvm::SmallDenseSet<int64_t>& resource_ids,
    bool previous_unknown_resource_access) {
  // If we had any unknown resource access before, then we conservatively assume
  // that `resource` has been accessed before.
  // If `resource` is an unknown resource, then we conservatively assume that
  // the same resource has been accessed before.
  if (previous_unknown_resource_access ||
      resource_analysis_info.IsUnknownResource(resource))

			// registers for the asynchronously stopped
			// parent frame. Scan the parent
			// conservatively.
			state.conservative = true
		} else {
			// We only wanted to scan those two frames
			// conservatively. Clear the flag for future
			// frames.
			state.conservative = false
		}
		return
	}

	locals, args, objs := frame.getStackMap(false)

  // Converts from read/write state that relates ops with the same parallel id
  // to a set of last accesses for use with other parallel ids. Reads/writes
  // between parallel ids are conservatively approximated as writes.
  absl::flat_hash_set<Operation*> GetLastWrites(ResourceId resource_id);

  // Sets the read/write state for ops within the same parallel id.
  void SetLastWrites(ResourceId resource_id,

// RUN: tf-opt %s -tf-device-mark-input-output-aliases | FileCheck %s

// The following tests check if the aliasing pairs are conservatively marked
// correctly. In the following tests tf_device.cluster_func has inputs
// coming from ReadVariableOp and outputs written to a resource using
// AssignVariableOp. If a pair of input-output (say input at index `a` and
// output at index `b`) read and write to the same resource, then those
// input-output pairs alias each other.

      // only self-dependent conservatively, i.e., we do add dependencies
      // to/from unknown resource types. Currently, we don't have such cases and
      // there is no indication that we will need to support them in the future.
      LOG(WARNING) << "Self-dependent-only resource types are treated "
                      "conservatively for value-based side effects.";
    }

}

//go:generate go run mkpreempt.go

// asyncPreempt saves all user registers and calls asyncPreempt2.
//
// When stack scanning encounters an asyncPreempt frame, it scans that
// frame and its parent frame conservatively.
//
// asyncPreempt is implemented in assembly.
func asyncPreempt()

//go:nosplit
func asyncPreempt2() {
	gp := getg()
	gp.asyncSafePoint = true
	if gp.preemptStop {
		mcall(preemptPark)

If your project files include symlinks, symlinked files do not benefit from file system-watching optimizations.
--

== Unsupported File Systems

When enabled by default, file system watching acts conservatively when it encounters content on unsupported file systems.
This can happen if you mount a project directory or subdirectory from a network drive.

				return []string{"invalid date"}
			}
			return nil
		},
		// Estimated regex size for RFC3339FullDate which is
		// a date format. Assume a date-time pattern is longer
		// so use that to conservatively estimate this
		MaxRegexSize: len(strfmt.DateTimePattern),
	},
	"datetime": {
		Name: "datetime",
		ValidateFunc: func(s string) []string {
			if !strfmt.Default.Validates("datetime", s) {

    // TFLite flatbuffer schema doesn't distinguish scalar tensor shapes
    // and unranked tensor shapes (i.e. they are both represented as an empty
    // INT32 list), see b/138865275. MLIR importer conservatively treats them as
    // unranked tensor types. Here we set them to scalar tensor types when it is
    // safe.
    if (auto tensor_array_v3_op = dyn_cast<TF::TensorArrayV3Op>(tf_op)) {