tf_executor.fetch
  }
  func.return
}

// Match the name of the cloned function with functionalized control-flow at call site
// CHECK: func @main()
// CHECK: computation = @[[FUNCTIONALIZE_FUNC:[A-Za-z0-9_]*]]


// In the newly cloned function, check that we have a _tf.If operation and capture the then and else branch.
// CHECK: func private @[[FUNCTIONALIZE_FUNC]]

            }
        """

        when:
        succeeds('assemble')

        then:
        // Git repo is cloned
        def gitCheckout = checkoutDir(repo.name, commit.id.name, repo.id)
        gitCheckout.file('.git').assertExists()
        // Submodule is cloned
        gitCheckout.file('deeperDep/.git').assertExists()
        gitCheckout.file('deeperDep/foo').text == "bar"

                        Closure<?> cloned = closure.rehydrate(null, closure.getThisObject(), closure.getThisObject());
                        ((TransformedClosure) cloned).makeRule(new PotentialInputs(modelViews, inputValues), supportsNestedRules ? ClosureBackedRuleFactory.this : null);
                        ClosureBackedAction.execute(t, cloned);
                    }
                }));
            }
        };

	other, ok := dst.(*Record)
	if !ok {
		other = &Record{}
	}
	other.object = r.object
	return other
}

// CloneTo clones the record to a json Record.
// Values are only unmashaled on object level.
func (r *Record) CloneTo(dst *json.Record) (sql.Record, error) {
	if dst == nil {
		dst = &json.Record{SelectFormat: sql.SelectFmtJSON}
	}
	dst.Reset()
	elems, err := r.object.Parse(nil)

      StringAttr device_attr = user_op->getAttrOfType<StringAttr>(kDeviceAttr);
      if (!device_attr) {
        all_uses_replaced = false;
        continue;
      }
      // Cloned the ConstOp and set its device attribute to be the same as the
      // device of the user operation.
      if (cloned_op_by_device.find(device_attr.getValue()) ==
          cloned_op_by_device.end()) {

        return this.context;
    }


    @Override
    public NtlmPasswordAuthentication clone () {
        NtlmPasswordAuthentication cloned = new NtlmPasswordAuthentication();
        cloneInternal(cloned, this);
        return cloned;
    }


    /**
     * @param to
     * @param from
     */

	// thread IDs, it does this by unsharing state on that thread. This way, it
	// also detects whether new threads were cloned from the dead thread, and not
	// from a clean thread. Cloning from a locked thread is undesirable since
	// cloned threads will inherit potentially unwanted OS state.
	//
	// unshareFs, getcwd, and chdir("/tmp") are only guaranteed to work on

  // entity. The new FuncOp body is populated by cloning partitioned ops into
  // it. Cloning Operation(s) will create cloned Value(s) for the results of a
  // cloned op, but it needs a reference to the new operand Value(s) which are
  // the result of the cloned ops. The approach is to traverse the subgraph in
  // order, accumulating clones of defined Values into a `IRMapping`

  // equivalent in the cloned range.
  const auto source_to_target = [&](int i) {
    return i + (remat.insert - remat.begin);
  };

  // Helper struct: bundles first and last use of a tensor within
  // a contiguous range of operations.
  struct TensorUse {
    int first_use;
    int last_use;
  };

  // For all tensors in the operation range to be cloned, store their first and

        gitVcs.populate(target, repoHead, repoSpec)

        then:
        target.file( '.git').assertIsDir()
        target.file( 'submodule/foo.txt').text == "hello from submodule"
    }

    def 'reset a cloned repository with dirty working dir'() {
        given:
        def target = tmpDir.file('versionDir')
        gitVcs.populate(target, repoHead, repoSpec)

        def removed = target.file("source.txt")