/*
    * Copyright (C) 2010, Christian Halstrick <christian.halstrick@sap.com>,
    * Copyright (C) 2010-2012, Matthias Sohn <matthias.sohn@sap.com>
    * Copyright (C) 2012, Research In Motion Limited
    * Copyright (C) 2017, Obeo (mathieu.cartaud@obeo.fr)
    * Copyright (C) 2018, Thomas Wolf <thomas.wolf@paranor.ch>
    * and other copyright owners as documented in the project's IP log.
    *
    * This program and the accompanying materials are made available
   * under the terms of the Eclipse Distribution License v1.0 which
   * accompanies this distribution, is reproduced below, and is
   * available at http://www.eclipse.org/org/documents/edl-v10.php
   *
   * All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or
   * without modification, are permitted provided that the following
   * conditions are met:
   *
   * - Redistributions of source code must retain the above copyright
   *   notice, this list of conditions and the following disclaimer.
   *
   * - Redistributions in binary form must reproduce the above
   *   copyright notice, this list of conditions and the following
   *   disclaimer in the documentation and/or other materials provided
   *   with the distribution.
   *
   * - Neither the name of the Eclipse Foundation, Inc. nor the
   *   names of its contributors may be used to endorse or promote
   *   products derived from this software without specific prior
   *   written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
   * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
   * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
   * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package org.eclipse.jgit.merge;
  
  import static java.nio.charset.StandardCharsets.UTF_8;
  import static java.time.Instant.EPOCH;
  import static org.eclipse.jgit.diff.DiffAlgorithm.SupportedAlgorithm.HISTOGRAM;
  import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_DIFF_SECTION;
  import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_ALGORITHM;
  import static org.eclipse.jgit.lib.Constants.OBJ_BLOB;
  
  import java.io.BufferedOutputStream;
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.time.Instant;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Map;
  
  import org.eclipse.jgit.attributes.Attributes;
  import org.eclipse.jgit.diff.DiffAlgorithm;
  import org.eclipse.jgit.diff.DiffAlgorithm.SupportedAlgorithm;
  import org.eclipse.jgit.diff.RawText;
  import org.eclipse.jgit.diff.RawTextComparator;
  import org.eclipse.jgit.diff.Sequence;
  import org.eclipse.jgit.dircache.DirCache;
  import org.eclipse.jgit.dircache.DirCacheBuildIterator;
  import org.eclipse.jgit.dircache.DirCacheBuilder;
  import org.eclipse.jgit.dircache.DirCacheCheckout;
  import org.eclipse.jgit.dircache.DirCacheCheckout.CheckoutMetadata;
  import org.eclipse.jgit.dircache.DirCacheEntry;
  import org.eclipse.jgit.errors.BinaryBlobException;
  import org.eclipse.jgit.errors.CorruptObjectException;
  import org.eclipse.jgit.errors.IncorrectObjectTypeException;
  import org.eclipse.jgit.errors.IndexWriteException;
  import org.eclipse.jgit.errors.MissingObjectException;
  import org.eclipse.jgit.errors.NoWorkTreeException;
  import org.eclipse.jgit.lib.Config;
  import org.eclipse.jgit.lib.ConfigConstants;
  import org.eclipse.jgit.lib.Constants;
  import org.eclipse.jgit.lib.CoreConfig.EolStreamType;
  import org.eclipse.jgit.lib.FileMode;
  import org.eclipse.jgit.lib.ObjectId;
  import org.eclipse.jgit.lib.ObjectInserter;
  import org.eclipse.jgit.lib.ObjectLoader;
  import org.eclipse.jgit.lib.Repository;
 import org.eclipse.jgit.revwalk.RevTree;
 import org.eclipse.jgit.storage.pack.PackConfig;
 import org.eclipse.jgit.submodule.SubmoduleConflict;
 import org.eclipse.jgit.treewalk.AbstractTreeIterator;
 import org.eclipse.jgit.treewalk.CanonicalTreeParser;
 import org.eclipse.jgit.treewalk.NameConflictTreeWalk;
 import org.eclipse.jgit.treewalk.TreeWalk;
 import org.eclipse.jgit.treewalk.TreeWalk.OperationType;
 import org.eclipse.jgit.treewalk.WorkingTreeIterator;
 import org.eclipse.jgit.treewalk.WorkingTreeOptions;
 import org.eclipse.jgit.treewalk.filter.TreeFilter;
 import org.eclipse.jgit.util.FS;
 import org.eclipse.jgit.util.LfsFactory;
 import org.eclipse.jgit.util.LfsFactory.LfsInputStream;
 import org.eclipse.jgit.util.TemporaryBuffer;
 import org.eclipse.jgit.util.io.EolStreamTypeUtil;
 
 /**
  * A three-way merger performing a content-merge if necessary
  */
 public class ResolveMerger extends ThreeWayMerger {
 	/**
 	 * If the merge fails (means: not stopped because of unresolved conflicts)
 	 * this enum is used to explain why it failed
 	 */
 	public enum MergeFailureReason {
 		/** the merge failed because of a dirty index */
 		DIRTY_INDEX,
 		/** the merge failed because of a dirty workingtree */
 		DIRTY_WORKTREE,
 		/** the merge failed because of a file could not be deleted */
 		COULD_NOT_DELETE
 	}
 
 	/**
 	 * The tree walk which we'll iterate over to merge entries.
 	 *
 	 * @since 3.4
 	 */
 	protected NameConflictTreeWalk tw;
 
 	/**
 	 * string versions of a list of commit SHA1s
 	 *
 	 * @since 3.0
 	 */
 	protected String commitNames[];
 
 	/**
 	 * Index of the base tree within the {@link #tw tree walk}.
 	 *
 	 * @since 3.4
 	 */
 	protected static final int T_BASE = 0;
 
 	/**
 	 * Index of our tree in withthe {@link #tw tree walk}.
 	 *
 	 * @since 3.4
 	 */
 	protected static final int T_OURS = 1;
 
 	/**
 	 * Index of their tree within the {@link #tw tree walk}.
 	 *
 	 * @since 3.4
 	 */
 	protected static final int T_THEIRS = 2;
 
 	/**
 	 * Index of the index tree within the {@link #tw tree walk}.
 	 *
 	 * @since 3.4
 	 */
 	protected static final int T_INDEX = 3;
 
 	/**
 	 * Index of the working directory tree within the {@link #tw tree walk}.
 	 *
 	 * @since 3.4
 	 */
 	protected static final int T_FILE = 4;
 
 	/**
 	 * Builder to update the cache during this merge.
 	 *
 	 * @since 3.4
 	 */
 	protected DirCacheBuilder builder;
 
 	/**
 	 * merge result as tree
 	 *
 	 * @since 3.0
 	 */
 	protected ObjectId resultTree;
 
 	/**
 	 * Paths that could not be merged by this merger because of an unsolvable
 	 * conflict.
 	 *
 	 * @since 3.4
 	 */
 	protected List<String> unmergedPaths = new ArrayList<>();
 
 	/**
 	 * Files modified during this merge operation.
 	 *
 	 * @since 3.4
 	 */
 	protected List<String> modifiedFiles = new LinkedList<>();
 
 	/**
 	 * If the merger has nothing to do for a file but check it out at the end of
 	 * the operation, it can be added here.
 	 *
 	 * @since 3.4
 	 */
 	protected Map<String, DirCacheEntry> toBeCheckedOut = new HashMap<>();
 
 	/**
 	 * Paths in this list will be deleted from the local copy at the end of the
 	 * operation.
 	 *
 	 * @since 3.4
 	 */
 	protected List<String> toBeDeleted = new ArrayList<>();
 
 	/**
 	 * Low-level textual merge results. Will be passed on to the callers in case
 	 * of conflicts.
 	 *
 	 * @since 3.4
 	 */
 	protected Map<String, MergeResult<? extends Sequence>> mergeResults = new HashMap<>();
 
 	/**
 	 * Paths for which the merge failed altogether.
 	 *
 	 * @since 3.4
 	 */
 	protected Map<String, MergeFailureReason> failingPaths = new HashMap<>();
 
 	/**
 	 * Updated as we merge entries of the tree walk. Tells us whether we should
 	 * recurse into the entry if it is a subtree.
 	 *
 	 * @since 3.4
 	 */
 	protected boolean enterSubtree;
 
 	/**
 	 * Set to true if this merge should work in-memory. The repos dircache and
 	 * workingtree are not touched by this method. Eventually needed files are
 	 * created as temporary files and a new empty, in-memory dircache will be
 	 * used instead the repo's one. Often used for bare repos where the repo
 	 * doesn't even have a workingtree and dircache.
 	 * @since 3.0
 	 */
 	protected boolean inCore;
 
 	/**
 	 * Set to true if this merger should use the default dircache of the
 	 * repository and should handle locking and unlocking of the dircache. If
 	 * this merger should work in-core or if an explicit dircache was specified
 	 * during construction then this field is set to false.
 	 * @since 3.0
 	 */
 	protected boolean implicitDirCache;
 
 	/**
 	 * Directory cache
 	 * @since 3.0
 	 */
 	protected DirCache dircache;
 
 	/**
 	 * The iterator to access the working tree. If set to <code>null</code> this
 	 * merger will not touch the working tree.
 	 * @since 3.0
 	 */
 	protected WorkingTreeIterator workingTreeIterator;
 
 	/**
 	 * our merge algorithm
 	 * @since 3.0
 	 */
 	protected MergeAlgorithm mergeAlgorithm;
 
 	/**
 	 * The {@link WorkingTreeOptions} are needed to determine line endings for
 	 * merged files.
 	 *
 	 * @since 4.11
 	 */
 	protected WorkingTreeOptions workingTreeOptions;
 
 	/**
 	 * The size limit (bytes) which controls a file to be stored in {@code Heap}
 	 * or {@code LocalFile} during the merge.
 	 */
 	private int inCoreLimit;
 
 	/**
 	 * Keeps {@link CheckoutMetadata} for {@link #checkout()} and
 	 * {@link #cleanUp()}.
 	 */
 	private Map<String, CheckoutMetadata> checkoutMetadata;
 
 	private static MergeAlgorithm getMergeAlgorithm(Config config) {
 		SupportedAlgorithm diffAlg = config.getEnum(
 				CONFIG_DIFF_SECTION, null, CONFIG_KEY_ALGORITHM,
 				HISTOGRAM);
 		return new MergeAlgorithm(DiffAlgorithm.getAlgorithm(diffAlg));
 	}
 
 	private static int getInCoreLimit(Config config) {
 		return config.getInt(
 				ConfigConstants.CONFIG_MERGE_SECTION, ConfigConstants.CONFIG_KEY_IN_CORE_LIMIT, 10 << 20);
 	}
 
 	private static String[] defaultCommitNames() {
 		return new String[] { "BASE", "OURS", "THEIRS" }; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
 	}
 
 	private static final Attributeshtml#Attributes">Attributes NO_ATTRIBUTES = new Attributes();
 
 	/**
 	 * Constructor for ResolveMerger.
 	 *
 	 * @param local
 	 *            the {@link org.eclipse.jgit.lib.Repository}.
 	 * @param inCore
 	 *            a boolean.
 	 */
 	protected ResolveMerger(Repository local, boolean inCore) {
 		super(local);
 		Config config = local.getConfig();
 		mergeAlgorithm = getMergeAlgorithm(config);
 		inCoreLimit = getInCoreLimit(config);
 		commitNames = defaultCommitNames();
 		this.inCore = inCore;
 
 		if (inCore) {
 			implicitDirCache = false;
 			dircache = DirCache.newInCore();
 		} else {
 			implicitDirCache = true;
 			workingTreeOptions = local.getConfig().get(WorkingTreeOptions.KEY);
 		}
 	}
 
 	/**
 	 * Constructor for ResolveMerger.
 	 *
 	 * @param local
 	 *            the {@link org.eclipse.jgit.lib.Repository}.
 	 */
 	protected ResolveMerger(Repository local) {
 		this(local, false);
 	}
 
 	/**
 	 * Constructor for ResolveMerger.
 	 *
 	 * @param inserter
 	 *            an {@link org.eclipse.jgit.lib.ObjectInserter} object.
 	 * @param config
 	 *            the repository configuration
 	 * @since 4.8
 	 */
 	protected ResolveMerger(ObjectInserter inserter, Config config) {
 		super(inserter);
 		mergeAlgorithm = getMergeAlgorithm(config);
 		commitNames = defaultCommitNames();
 		inCore = true;
 		implicitDirCache = false;
 		dircache = DirCache.newInCore();
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	protected boolean mergeImpl() throws IOException {
 		if (implicitDirCache) {
 			dircache = nonNullRepo().lockDirCache();
 		}
 		if (!inCore) {
 			checkoutMetadata = new HashMap<>();
 		}
 		try {
 			return mergeTrees(mergeBase(), sourceTrees[0], sourceTrees[1],
 					false);
 		} finally {
 			checkoutMetadata = null;
 			if (implicitDirCache) {
 				dircache.unlock();
 			}
 		}
 	}
 
 	private void checkout() throws NoWorkTreeException, IOException {
 		// Iterate in reverse so that "folder/file" is deleted before
 		// "folder". Otherwise this could result in a failing path because
 		// of a non-empty directory, for which delete() would fail.
 		for (int i = toBeDeleted.size() - 1; i >= 0; i--) {
 			String fileName = toBeDeleted.get(i);
 			File f = new File(nonNullRepo().getWorkTree(), fileName);
 			if (!f.delete())
 				if (!f.isDirectory())
 					failingPaths.put(fileName,
 							MergeFailureReason.COULD_NOT_DELETE);
 			modifiedFiles.add(fileName);
 		}
 		for (Map.Entry<String, DirCacheEntry> entry : toBeCheckedOut
 				.entrySet()) {
 			DirCacheEntry cacheEntry = entry.getValue();
 			if (cacheEntry.getFileMode() == FileMode.GITLINK) {
 				new File(nonNullRepo().getWorkTree(), entry.getKey()).mkdirs();
 			} else {
 				DirCacheCheckout.checkoutEntry(db, cacheEntry, reader, false,
 						checkoutMetadata.get(entry.getKey()));
 				modifiedFiles.add(entry.getKey());
 			}
 		}
 	}
 
 	/**
 	 * Reverts the worktree after an unsuccessful merge. We know that for all
 	 * modified files the old content was in the old index and the index
 	 * contained only stage 0. In case if inCore operation just clear the
 	 * history of modified files.
 	 *
 	 * @throws java.io.IOException
 	 * @throws org.eclipse.jgit.errors.CorruptObjectException
 	 * @throws org.eclipse.jgit.errors.NoWorkTreeException
 	 * @since 3.4
 	 */
 	protected void cleanUp() throws NoWorkTreeException,
 			CorruptObjectException,
 			IOException {
 		if (inCore) {
 			modifiedFiles.clear();
 			return;
 		}
 
 		DirCache dc = nonNullRepo().readDirCache();
 		Iterator<String> mpathsIt=modifiedFiles.iterator();
 		while(mpathsIt.hasNext()) {
 			String mpath = mpathsIt.next();
 			DirCacheEntry entry = dc.getEntry(mpath);
 			if (entry != null) {
 				DirCacheCheckout.checkoutEntry(db, entry, reader, false,
 						checkoutMetadata.get(mpath));
 			}
 			mpathsIt.remove();
 		}
 	}
 
 	/**
 	 * adds a new path with the specified stage to the index builder
 	 *
 	 * @param path
 	 * @param p
 	 * @param stage
 	 * @param lastMod
 	 * @param len
 	 * @return the entry which was added to the index
 	 */
 	private DirCacheEntry add(byte[] path, CanonicalTreeParser p, int stage,
 			Instant lastMod, long len) {
 		if (p != null && !p.getEntryFileMode().equals(FileMode.TREE)) {
 			DirCacheEntry e = new DirCacheEntry(path, stage);
 			e.setFileMode(p.getEntryFileMode());
 			e.setObjectId(p.getEntryObjectId());
 			e.setLastModified(lastMod);
 			e.setLength(len);
 			builder.add(e);
 			return e;
 		}
 		return null;
 	}
 
 	/**
 	 * adds a entry to the index builder which is a copy of the specified
 	 * DirCacheEntry
 	 *
 	 * @param e
 	 *            the entry which should be copied
 	 *
 	 * @return the entry which was added to the index
 	 */
 	private DirCacheEntry/../../../org/eclipse/jgit/dircache/DirCacheEntry.html#DirCacheEntry">DirCacheEntry keep(DirCacheEntry e) {
 		DirCacheEntry newEntry = new DirCacheEntry(e.getRawPath(),
 				e.getStage());
 		newEntry.setFileMode(e.getFileMode());
 		newEntry.setObjectId(e.getObjectId());
 		newEntry.setLastModified(e.getLastModifiedInstant());
 		newEntry.setLength(e.getLength());
 		builder.add(newEntry);
 		return newEntry;
 	}
 
 	/**
 	 * Remembers the {@link CheckoutMetadata} for the given path; it may be
 	 * needed in {@link #checkout()} or in {@link #cleanUp()}.
 	 *
 	 * @param path
 	 *            of the current node
 	 * @param attributes
 	 *            for the current node
 	 * @throws IOException
 	 *             if the smudge filter cannot be determined
 	 * @since 5.1
 	 */
 	protected void addCheckoutMetadata(String path, Attributes attributes)
 			throws IOException {
 		if (checkoutMetadata != null) {
 			EolStreamType eol = EolStreamTypeUtil.detectStreamType(
 					OperationType.CHECKOUT_OP, workingTreeOptions, attributes);
 			CheckoutMetadata data = new CheckoutMetadata(eol,
 					tw.getFilterCommand(Constants.ATTR_FILTER_TYPE_SMUDGE));
 			checkoutMetadata.put(path, data);
 		}
 	}
 
 	/**
 	 * Adds a {@link DirCacheEntry} for direct checkout and remembers its
 	 * {@link CheckoutMetadata}.
 	 *
 	 * @param path
 	 *            of the entry
 	 * @param entry
 	 *            to add
 	 * @param attributes
 	 *            for the current entry
 	 * @throws IOException
 	 *             if the {@link CheckoutMetadata} cannot be determined
 	 * @since 5.1
 	 */
 	protected void addToCheckout(String path, DirCacheEntry entry,
 			Attributes attributes) throws IOException {
 		toBeCheckedOut.put(path, entry);
 		addCheckoutMetadata(path, attributes);
 	}
 
 	/**
 	 * Remember a path for deletion, and remember its {@link CheckoutMetadata}
 	 * in case it has to be restored in {@link #cleanUp()}.
 	 *
 	 * @param path
 	 *            of the entry
 	 * @param isFile
 	 *            whether it is a file
 	 * @param attributes
 	 *            for the entry
 	 * @throws IOException
 	 *             if the {@link CheckoutMetadata} cannot be determined
 	 * @since 5.1
 	 */
 	protected void addDeletion(String path, boolean isFile,
 			Attributes attributes) throws IOException {
 		toBeDeleted.add(path);
 		if (isFile) {
 			addCheckoutMetadata(path, attributes);
 		}
 	}
 
 	/**
 	 * Processes one path and tries to merge taking git attributes in account.
 	 * This method will do all trivial (not content) merges and will also detect
 	 * if a merge will fail. The merge will fail when one of the following is
 	 * true
 	 * <ul>
 	 * <li>the index entry does not match the entry in ours. When merging one
 	 * branch into the current HEAD, ours will point to HEAD and theirs will
 	 * point to the other branch. It is assumed that the index matches the HEAD
 	 * because it will only not match HEAD if it was populated before the merge
 	 * operation. But the merge commit should not accidentally contain
 	 * modifications done before the merge. Check the <a href=
 	 * "http://www.kernel.org/pub/software/scm/git/docs/git-read-tree.html#_3_way_merge"
 	 * >git read-tree</a> documentation for further explanations.</li>
 	 * <li>A conflict was detected and the working-tree file is dirty. When a
 	 * conflict is detected the content-merge algorithm will try to write a
 	 * merged version into the working-tree. If the file is dirty we would
 	 * override unsaved data.</li>
 	 * </ul>
 	 *
 	 * @param base
 	 *            the common base for ours and theirs
 	 * @param ours
 	 *            the ours side of the merge. When merging a branch into the
 	 *            HEAD ours will point to HEAD
 	 * @param theirs
 	 *            the theirs side of the merge. When merging a branch into the
 	 *            current HEAD theirs will point to the branch which is merged
 	 *            into HEAD.
 	 * @param index
 	 *            the index entry
 	 * @param work
 	 *            the file in the working tree
 	 * @param ignoreConflicts
 	 *            see
 	 *            {@link org.eclipse.jgit.merge.ResolveMerger#mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)}
 	 * @param attributes
 	 *            the attributes defined for this entry
 	 * @return <code>false</code> if the merge will fail because the index entry
 	 *         didn't match ours or the working-dir file was dirty and a
 	 *         conflict occurred
 	 * @throws org.eclipse.jgit.errors.MissingObjectException
 	 * @throws org.eclipse.jgit.errors.IncorrectObjectTypeException
 	 * @throws org.eclipse.jgit.errors.CorruptObjectException
 	 * @throws java.io.IOException
 	 * @since 4.9
 	 */
 	protected boolean processEntry(CanonicalTreeParser base,
 			CanonicalTreeParser ours, CanonicalTreeParser theirs,
 			DirCacheBuildIterator index, WorkingTreeIterator work,
 			boolean ignoreConflicts, Attributes attributes)
 			throws MissingObjectException, IncorrectObjectTypeException,
 			CorruptObjectException, IOException {
 		enterSubtree = true;
 		final int modeO = tw.getRawMode(T_OURS);
 		final int modeT = tw.getRawMode(T_THEIRS);
 		final int modeB = tw.getRawMode(T_BASE);
 
 		if (modeO == 0 && modeT == 0 && modeB == 0)
 			// File is either untracked or new, staged but uncommitted
 			return true;
 
 		if (isIndexDirty())
 			return false;
 
 		DirCacheEntry ourDce = null;
 
 		if (index == null || index.getDirCacheEntry() == null) {
 			// create a fake DCE, but only if ours is valid. ours is kept only
 			// in case it is valid, so a null ourDce is ok in all other cases.
 			if (nonTree(modeO)) {
 				ourDce = new DirCacheEntry(tw.getRawPath());
 				ourDce.setObjectId(tw.getObjectId(T_OURS));
 				ourDce.setFileMode(tw.getFileMode(T_OURS));
 			}
 		} else {
 			ourDce = index.getDirCacheEntry();
 		}
 
 		if (nonTree(modeO) && nonTree(modeT) && tw.idEqual(T_OURS, T_THEIRS)) {
 			// OURS and THEIRS have equal content. Check the file mode
 			if (modeO == modeT) {
 				// content and mode of OURS and THEIRS are equal: it doesn't
 				// matter which one we choose. OURS is chosen. Since the index
 				// is clean (the index matches already OURS) we can keep the existing one
 				keep(ourDce);
 				// no checkout needed!
 				return true;
 			} else {
 				// same content but different mode on OURS and THEIRS.
 				// Try to merge the mode and report an error if this is
 				// not possible.
 				int newMode = mergeFileModes(modeB, modeO, modeT);
 				if (newMode != FileMode.MISSING.getBits()) {
 					if (newMode == modeO)
 						// ours version is preferred
 						keep(ourDce);
 					else {
 						// the preferred version THEIRS has a different mode
 						// than ours. Check it out!
 						if (isWorktreeDirty(work, ourDce))
 							return false;
 						// we know about length and lastMod only after we have written the new content.
 						// This will happen later. Set these values to 0 for know.
 						DirCacheEntry e = add(tw.getRawPath(), theirs,
 								DirCacheEntry.STAGE_0, EPOCH, 0);
 						addToCheckout(tw.getPathString(), e, attributes);
 					}
 					return true;
 				} else {
 					// FileModes are not mergeable. We found a conflict on modes.
 					// For conflicting entries we don't know lastModified and length.
 					add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
 					add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
 					add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, EPOCH,
 							0);
 					unmergedPaths.add(tw.getPathString());
 					mergeResults.put(
 							tw.getPathString(),
 							new MergeResult<>(Collections
 									.<RawText> emptyList()));
 				}
 				return true;
 			}
 		}
 
 		if (modeB == modeT && tw.idEqual(T_BASE, T_THEIRS)) {
 			// THEIRS was not changed compared to BASE. All changes must be in
 			// OURS. OURS is chosen. We can keep the existing entry.
 			if (ourDce != null)
 				keep(ourDce);
 			// no checkout needed!
 			return true;
 		}
 
 		if (modeB == modeO && tw.idEqual(T_BASE, T_OURS)) {
 			// OURS was not changed compared to BASE. All changes must be in
 			// THEIRS. THEIRS is chosen.
 
 			// Check worktree before checking out THEIRS
 			if (isWorktreeDirty(work, ourDce))
 				return false;
 			if (nonTree(modeT)) {
 				// we know about length and lastMod only after we have written
 				// the new content.
 				// This will happen later. Set these values to 0 for know.
 				DirCacheEntry e = add(tw.getRawPath(), theirs,
 						DirCacheEntry.STAGE_0, EPOCH, 0);
 				if (e != null) {
 					addToCheckout(tw.getPathString(), e, attributes);
 				}
 				return true;
 			} else {
 				// we want THEIRS ... but THEIRS contains a folder or the
 				// deletion of the path. Delete what's in the working tree,
 				// which we know to be clean.
 				if (tw.getTreeCount() > T_FILE && tw.getRawMode(T_FILE) == 0) {
 					// Not present in working tree, so nothing to delete
 					return true;
 				}
 				if (modeT != 0 && modeT == modeB) {
 					// Base, ours, and theirs all contain a folder: don't delete
 					return true;
 				}
 				addDeletion(tw.getPathString(), nonTree(modeO), attributes);
 				return true;
 			}
 		}
 
 		if (tw.isSubtree()) {
 			// file/folder conflicts: here I want to detect only file/folder
 			// conflict between ours and theirs. file/folder conflicts between
 			// base/index/workingTree and something else are not relevant or
 			// detected later
 			if (nonTree(modeO) && !nonTree(modeT)) {
 				if (nonTree(modeB))
 					add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
 				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
 				unmergedPaths.add(tw.getPathString());
 				enterSubtree = false;
 				return true;
 			}
 			if (nonTree(modeT) && !nonTree(modeO)) {
 				if (nonTree(modeB))
 					add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
 				add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, EPOCH, 0);
 				unmergedPaths.add(tw.getPathString());
 				enterSubtree = false;
 				return true;
 			}
 
 			// ours and theirs are both folders or both files (and treewalk
 			// tells us we are in a subtree because of index or working-dir).
 			// If they are both folders no content-merge is required - we can
 			// return here.
 			if (!nonTree(modeO))
 				return true;
 
 			// ours and theirs are both files, just fall out of the if block
 			// and do the content merge
 		}
 
 		if (nonTree(modeO) && nonTree(modeT)) {
 			// Check worktree before modifying files
 			boolean worktreeDirty = isWorktreeDirty(work, ourDce);
 			if (!attributes.canBeContentMerged() && worktreeDirty) {
 				return false;
 			}
 
 			boolean gitlinkConflict = isGitLink(modeO) || isGitLink(modeT);
 			// Don't attempt to resolve submodule link conflicts
 			if (gitlinkConflict || !attributes.canBeContentMerged()) {
 				add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
 				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
 				add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, EPOCH, 0);
 
 				if (gitlinkConflict) {
 					MergeResult<SubmoduleConflict> result = new MergeResult<>(
 							Arrays.asList(
 									new SubmoduleConflict(base == null ? null
 											: base.getEntryObjectId()),
 									new SubmoduleConflict(ours == null ? null
 											: ours.getEntryObjectId()),
 									new SubmoduleConflict(theirs == null ? null
 											: theirs.getEntryObjectId())));
 					result.setContainsConflicts(true);
 					mergeResults.put(tw.getPathString(), result);
 					if (!ignoreConflicts) {
 						unmergedPaths.add(tw.getPathString());
 					}
 				} else {
 					// attribute merge issues are conflicts but not failures
 					unmergedPaths.add(tw.getPathString());
 				}
 				return true;
 			}
 
 			// Check worktree before modifying files
 			if (worktreeDirty) {
 				return false;
 			}
 
 			MergeResult<RawText> result = contentMerge(base, ours, theirs,
 					attributes);
 			if (ignoreConflicts) {
 				result.setContainsConflicts(false);
 			}
 			updateIndex(base, ours, theirs, result, attributes);
 			String currentPath = tw.getPathString();
 			if (result.containsConflicts() && !ignoreConflicts) {
 				unmergedPaths.add(currentPath);
 			}
 			modifiedFiles.add(currentPath);
 			addCheckoutMetadata(currentPath, attributes);
 		} else if (modeO != modeT) {
 			// OURS or THEIRS has been deleted
 			if (((modeO != 0 && !tw.idEqual(T_BASE, T_OURS)) || (modeT != 0 && !tw
 					.idEqual(T_BASE, T_THEIRS)))) {
 				MergeResult<RawText> result = contentMerge(base, ours, theirs,
 						attributes);
 
 				add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
 				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
 				DirCacheEntry e = add(tw.getRawPath(), theirs,
 						DirCacheEntry.STAGE_3, EPOCH, 0);
 
 				// OURS was deleted checkout THEIRS
 				if (modeO == 0) {
 					// Check worktree before checking out THEIRS
 					if (isWorktreeDirty(work, ourDce))
 						return false;
 					if (nonTree(modeT)) {
 						if (e != null) {
 							addToCheckout(tw.getPathString(), e, attributes);
 						}
 					}
 				}
 
 				unmergedPaths.add(tw.getPathString());
 
 				// generate a MergeResult for the deleted file
 				mergeResults.put(tw.getPathString(), result);
 			}
 		}
 		return true;
 	}
 
 	/**
 	 * Does the content merge. The three texts base, ours and theirs are
 	 * specified with {@link CanonicalTreeParser}. If any of the parsers is
 	 * specified as <code>null</code> then an empty text will be used instead.
 	 *
 	 * @param base
 	 * @param ours
 	 * @param theirs
 	 * @param attributes
 	 *
 	 * @return the result of the content merge
 	 * @throws IOException
 	 */
 	private MergeResult<RawText> contentMerge(CanonicalTreeParser base,
 			CanonicalTreeParser ours, CanonicalTreeParser theirs,
 			Attributes attributes)
 			throws IOException {
 		RawText baseText;
 		RawText ourText;
 		RawText theirsText;
 
 		try {
 			baseText = base == null ? RawText.EMPTY_TEXT : getRawText(
 							base.getEntryObjectId(), attributes);
 			ourText = ours == null ? RawText.EMPTY_TEXT : getRawText(
 							ours.getEntryObjectId(), attributes);
 			theirsText = theirs == null ? RawText.EMPTY_TEXT : getRawText(
 							theirs.getEntryObjectId(), attributes);
 		} catch (BinaryBlobException e) {
 			MergeResult<RawText> r = new MergeResult<>(Collections.<RawText>emptyList());
 			r.setContainsConflicts(true);
 			return r;
 		}
 		return (mergeAlgorithm.merge(RawTextComparator.DEFAULT, baseText,
 				ourText, theirsText));
 	}
 
 	private boolean isIndexDirty() {
 		if (inCore)
 			return false;
 
 		final int modeI = tw.getRawMode(T_INDEX);
 		final int modeO = tw.getRawMode(T_OURS);
 
 		// Index entry has to match ours to be considered clean
 		final boolean isDirty = nonTree(modeI)
 				&& !(modeO == modeI && tw.idEqual(T_INDEX, T_OURS));
 		if (isDirty)
 			failingPaths
 					.put(tw.getPathString(), MergeFailureReason.DIRTY_INDEX);
 		return isDirty;
 	}
 
 	private boolean isWorktreeDirty(WorkingTreeIterator work,
 			DirCacheEntry ourDce) throws IOException {
 		if (work == null)
 			return false;
 
 		final int modeF = tw.getRawMode(T_FILE);
 		final int modeO = tw.getRawMode(T_OURS);
 
 		// Worktree entry has to match ours to be considered clean
 		boolean isDirty;
 		if (ourDce != null)
 			isDirty = work.isModified(ourDce, true, reader);
 		else {
 			isDirty = work.isModeDifferent(modeO);
 			if (!isDirty && nonTree(modeF))
 				isDirty = !tw.idEqual(T_FILE, T_OURS);
 		}
 
 		// Ignore existing empty directories
 		if (isDirty && modeF == FileMode.TYPE_TREE
 				&& modeO == FileMode.TYPE_MISSING)
 			isDirty = false;
 		if (isDirty)
 			failingPaths.put(tw.getPathString(),
 					MergeFailureReason.DIRTY_WORKTREE);
 		return isDirty;
 	}
 
 	/**
 	 * Updates the index after a content merge has happened. If no conflict has
 	 * occurred this includes persisting the merged content to the object
 	 * database. In case of conflicts this method takes care to write the
 	 * correct stages to the index.
 	 *
 	 * @param base
 	 * @param ours
 	 * @param theirs
 	 * @param result
 	 * @param attributes
 	 * @throws FileNotFoundException
 	 * @throws IOException
 	 */
 	private void updateIndex(CanonicalTreeParser base,
 			CanonicalTreeParser ours, CanonicalTreeParser theirs,
 			MergeResult<RawText> result, Attributes attributes)
 			throws FileNotFoundException,
 			IOException {
 		TemporaryBuffer rawMerged = null;
 		try {
 			rawMerged = doMerge(result);
 			File mergedFile = inCore ? null
 					: writeMergedFile(rawMerged, attributes);
 			if (result.containsConflicts()) {
 				// A conflict occurred, the file will contain conflict markers
 				// the index will be populated with the three stages and the
 				// workdir (if used) contains the halfway merged content.
 				add(tw.getRawPath(), base, DirCacheEntry.STAGE_1, EPOCH, 0);
 				add(tw.getRawPath(), ours, DirCacheEntry.STAGE_2, EPOCH, 0);
 				add(tw.getRawPath(), theirs, DirCacheEntry.STAGE_3, EPOCH, 0);
 				mergeResults.put(tw.getPathString(), result);
 				return;
 			}
 
 			// No conflict occurred, the file will contain fully merged content.
 			// The index will be populated with the new merged version.
 			DirCacheEntry dce = new DirCacheEntry(tw.getPathString());
 
 			// Set the mode for the new content. Fall back to REGULAR_FILE if
 			// we can't merge modes of OURS and THEIRS.
 			int newMode = mergeFileModes(tw.getRawMode(0), tw.getRawMode(1),
 					tw.getRawMode(2));
 			dce.setFileMode(newMode == FileMode.MISSING.getBits()
 					? FileMode.REGULAR_FILE : FileMode.fromBits(newMode));
 			if (mergedFile != null) {
 				dce.setLastModified(
 						nonNullRepo().getFS().lastModifiedInstant(mergedFile));
 				dce.setLength((int) mergedFile.length());
 			}
 			dce.setObjectId(insertMergeResult(rawMerged, attributes));
 			builder.add(dce);
 		} finally {
 			if (rawMerged != null) {
 				rawMerged.destroy();
 			}
 		}
 	}
 
 	/**
 	 * Writes merged file content to the working tree.
 	 *
 	 * @param rawMerged
 	 *            the raw merged content
 	 * @param attributes
 	 *            the files .gitattributes entries
 	 * @return the working tree file to which the merged content was written.
 	 * @throws FileNotFoundException
 	 * @throws IOException
 	 */
 	private File writeMergedFile(TemporaryBuffer rawMerged,
 			Attributes attributes)
 			throws FileNotFoundException, IOException {
 		File workTree = nonNullRepo().getWorkTree();
 		FS fs = nonNullRepo().getFS();
 		File of = new File(workTree, tw.getPathString());
 		File parentFolder = of.getParentFile();
 		if (!fs.exists(parentFolder)) {
 			parentFolder.mkdirs();
 		}
 		EolStreamType streamType = EolStreamTypeUtil.detectStreamType(
 				OperationType.CHECKOUT_OP, workingTreeOptions,
 				attributes);
 		try (OutputStream os = EolStreamTypeUtil.wrapOutputStream(
 				new BufferedOutputStream(new FileOutputStream(of)),
 				streamType)) {
 			rawMerged.writeTo(os, null);
 		}
 		return of;
 	}
 
 	private TemporaryBuffer doMerge(MergeResult<RawText> result)
 			throws IOException {
 		TemporaryBuffer.LocalFile buf = new TemporaryBuffer.LocalFile(
 				db != null ? nonNullRepo().getDirectory() : null, inCoreLimit);
 		boolean success = false;
 		try {
 			new MergeFormatter().formatMerge(buf, result,
 					Arrays.asList(commitNames), UTF_8);
 			buf.close();
 			success = true;
 		} finally {
 			if (!success) {
 				buf.destroy();
 			}
 		}
 		return buf;
 	}
 
 	private ObjectId insertMergeResult(TemporaryBuffer buf,
 			Attributes attributes) throws IOException {
 		InputStream in = buf.openInputStream();
 		try (LfsInputStream is = LfsFactory.getInstance().applyCleanFilter(
 				getRepository(), in,
 				buf.length(), attributes.get(Constants.ATTR_MERGE))) {
 			return getObjectInserter().insert(OBJ_BLOB, is.getLength(), is);
 		}
 	}
 
 	/**
 	 * Try to merge filemodes. If only ours or theirs have changed the mode
 	 * (compared to base) we choose that one. If ours and theirs have equal
 	 * modes return that one. If also that is not the case the modes are not
 	 * mergeable. Return {@link FileMode#MISSING} int that case.
 	 *
 	 * @param modeB
 	 *            filemode found in BASE
 	 * @param modeO
 	 *            filemode found in OURS
 	 * @param modeT
 	 *            filemode found in THEIRS
 	 *
 	 * @return the merged filemode or {@link FileMode#MISSING} in case of a
 	 *         conflict
 	 */
 	private int mergeFileModes(int modeB, int modeO, int modeT) {
 		if (modeO == modeT)
 			return modeO;
 		if (modeB == modeO)
 			// Base equal to Ours -> chooses Theirs if that is not missing
 			return (modeT == FileMode.MISSING.getBits()) ? modeO : modeT;
 		if (modeB == modeT)
 			// Base equal to Theirs -> chooses Ours if that is not missing
 			return (modeO == FileMode.MISSING.getBits()) ? modeT : modeO;
 		return FileMode.MISSING.getBits();
 	}
 
 	private RawText getRawText(ObjectId id,
 			Attributes attributes)
 			throws IOException, BinaryBlobException {
 		if (id.equals(ObjectId.zeroId()))
 			return new RawText(new byte[] {});
 
 		ObjectLoader loader = LfsFactory.getInstance().applySmudgeFilter(
 				getRepository(), reader.open(id, OBJ_BLOB),
 				attributes.get(Constants.ATTR_MERGE));
 		int threshold = PackConfig.DEFAULT_BIG_FILE_THRESHOLD;
 		return RawText.load(loader, threshold);
 	}
 
 	private static boolean nonTree(int mode) {
 		return mode != 0 && !FileMode.TREE.equals(mode);
 	}
 
 	private static boolean isGitLink(int mode) {
 		return FileMode.GITLINK.equals(mode);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public ObjectId getResultTreeId() {
 		return (resultTree == null) ? null : resultTree.toObjectId();
 	}
 
 	/**
 	 * Set the names of the commits as they would appear in conflict markers
 	 *
 	 * @param commitNames
 	 *            the names of the commits as they would appear in conflict
 	 *            markers
 	 */
 	public void setCommitNames(String[] commitNames) {
 		this.commitNames = commitNames;
 	}
 
 	/**
 	 * Get the names of the commits as they would appear in conflict markers.
 	 *
 	 * @return the names of the commits as they would appear in conflict
 	 *         markers.
 	 */
 	public String[] getCommitNames() {
 		return commitNames;
 	}
 
 	/**
 	 * Get the paths with conflicts. This is a subset of the files listed by
 	 * {@link #getModifiedFiles()}
 	 *
 	 * @return the paths with conflicts. This is a subset of the files listed by
 	 *         {@link #getModifiedFiles()}
 	 */
 	public List<String> getUnmergedPaths() {
 		return unmergedPaths;
 	}
 
 	/**
 	 * Get the paths of files which have been modified by this merge.
 	 *
 	 * @return the paths of files which have been modified by this merge. A file
 	 *         will be modified if a content-merge works on this path or if the
 	 *         merge algorithm decides to take the theirs-version. This is a
 	 *         superset of the files listed by {@link #getUnmergedPaths()}.
 	 */
 	public List<String> getModifiedFiles() {
 		return modifiedFiles;
 	}
 
 	/**
 	 * Get a map which maps the paths of files which have to be checked out
 	 * because the merge created new fully-merged content for this file into the
 	 * index.
 	 *
 	 * @return a map which maps the paths of files which have to be checked out
 	 *         because the merge created new fully-merged content for this file
 	 *         into the index. This means: the merge wrote a new stage 0 entry
 	 *         for this path.
 	 */
 	public Map<String, DirCacheEntry> getToBeCheckedOut() {
 		return toBeCheckedOut;
 	}
 
 	/**
 	 * Get the mergeResults
 	 *
 	 * @return the mergeResults
 	 */
 	public Map<String, MergeResult<? extends Sequence>> getMergeResults() {
 		return mergeResults;
 	}
 
 	/**
 	 * Get list of paths causing this merge to fail (not stopped because of a
 	 * conflict).
 	 *
 	 * @return lists paths causing this merge to fail (not stopped because of a
 	 *         conflict). <code>null</code> is returned if this merge didn't
 	 *         fail.
 	 */
 	public Map<String, MergeFailureReason> getFailingPaths() {
 		return failingPaths.isEmpty() ? null : failingPaths;
 	}
 
 	/**
 	 * Returns whether this merge failed (i.e. not stopped because of a
 	 * conflict)
 	 *
 	 * @return <code>true</code> if a failure occurred, <code>false</code>
 	 *         otherwise
 	 */
 	public boolean failed() {
 		return !failingPaths.isEmpty();
 	}
 
 	/**
 	 * Sets the DirCache which shall be used by this merger. If the DirCache is
 	 * not set explicitly and if this merger doesn't work in-core, this merger
 	 * will implicitly get and lock a default DirCache. If the DirCache is
 	 * explicitly set the caller is responsible to lock it in advance. Finally
 	 * the merger will call {@link org.eclipse.jgit.dircache.DirCache#commit()}
 	 * which requires that the DirCache is locked. If the {@link #mergeImpl()}
 	 * returns without throwing an exception the lock will be released. In case
 	 * of exceptions the caller is responsible to release the lock.
 	 *
 	 * @param dc
 	 *            the DirCache to set
 	 */
 	public void setDirCache(DirCache dc) {
 		this.dircache = dc;
 		implicitDirCache = false;
 	}
 
 	/**
 	 * Sets the WorkingTreeIterator to be used by this merger. If no
 	 * WorkingTreeIterator is set this merger will ignore the working tree and
 	 * fail if a content merge is necessary.
 	 * <p>
 	 * TODO: enhance WorkingTreeIterator to support write operations. Then this
 	 * merger will be able to merge with a different working tree abstraction.
 	 *
 	 * @param workingTreeIterator
 	 *            the workingTreeIt to set
 	 */
 	public void setWorkingTreeIterator(WorkingTreeIterator workingTreeIterator) {
 		this.workingTreeIterator = workingTreeIterator;
 	}
 
 
 	/**
 	 * The resolve conflict way of three way merging
 	 *
 	 * @param baseTree
 	 *            a {@link org.eclipse.jgit.treewalk.AbstractTreeIterator}
 	 *            object.
 	 * @param headTree
 	 *            a {@link org.eclipse.jgit.revwalk.RevTree} object.
 	 * @param mergeTree
 	 *            a {@link org.eclipse.jgit.revwalk.RevTree} object.
 	 * @param ignoreConflicts
 	 *            Controls what to do in case a content-merge is done and a
 	 *            conflict is detected. The default setting for this should be
 	 *            <code>false</code>. In this case the working tree file is
 	 *            filled with new content (containing conflict markers) and the
 	 *            index is filled with multiple stages containing BASE, OURS and
 	 *            THEIRS content. Having such non-0 stages is the sign to git
 	 *            tools that there are still conflicts for that path.
 	 *            <p>
 	 *            If <code>true</code> is specified the behavior is different.
 	 *            In case a conflict is detected the working tree file is again
 	 *            filled with new content (containing conflict markers). But
 	 *            also stage 0 of the index is filled with that content. No
 	 *            other stages are filled. Means: there is no conflict on that
 	 *            path but the new content (including conflict markers) is
 	 *            stored as successful merge result. This is needed in the
 	 *            context of {@link org.eclipse.jgit.merge.RecursiveMerger}
 	 *            where when determining merge bases we don't want to deal with
 	 *            content-merge conflicts.
 	 * @return whether the trees merged cleanly
 	 * @throws java.io.IOException
 	 * @since 3.5
 	 */
 	protected boolean mergeTrees(AbstractTreeIterator baseTree,
 			RevTree headTree, RevTree mergeTree, boolean ignoreConflicts)
 			throws IOException {
 
 		builder = dircache.builder();
 		DirCacheBuildIterator buildIt = new DirCacheBuildIterator(builder);
 
 		tw = new NameConflictTreeWalk(db, reader);
 		tw.addTree(baseTree);
 		tw.addTree(headTree);
 		tw.addTree(mergeTree);
 		int dciPos = tw.addTree(buildIt);
 		if (workingTreeIterator != null) {
 			tw.addTree(workingTreeIterator);
 			workingTreeIterator.setDirCacheIterator(tw, dciPos);
 		} else {
 			tw.setFilter(TreeFilter.ANY_DIFF);
 		}
 
 		if (!mergeTreeWalk(tw, ignoreConflicts)) {
 			return false;
 		}
 
 		if (!inCore) {
 			// No problem found. The only thing left to be done is to
 			// checkout all files from "theirs" which have been selected to
 			// go into the new index.
 			checkout();
 
 			// All content-merges are successfully done. If we can now write the
 			// new index we are on quite safe ground. Even if the checkout of
 			// files coming from "theirs" fails the user can work around such
 			// failures by checking out the index again.
 			if (!builder.commit()) {
 				cleanUp();
 				throw new IndexWriteException();
 			}
 			builder = null;
 
 		} else {
 			builder.finish();
 			builder = null;
 		}
 
 		if (getUnmergedPaths().isEmpty() && !failed()) {
 			resultTree = dircache.writeTree(getObjectInserter());
 			return true;
 		} else {
 			resultTree = null;
 			return false;
 		}
 	}
 
 	/**
 	 * Process the given TreeWalk's entries.
 	 *
 	 * @param treeWalk
 	 *            The walk to iterate over.
 	 * @param ignoreConflicts
 	 *            see
 	 *            {@link org.eclipse.jgit.merge.ResolveMerger#mergeTrees(AbstractTreeIterator, RevTree, RevTree, boolean)}
 	 * @return Whether the trees merged cleanly.
 	 * @throws java.io.IOException
 	 * @since 3.5
 	 */
 	protected boolean mergeTreeWalk(TreeWalk treeWalk, boolean ignoreConflicts)
 			throws IOException {
 		boolean hasWorkingTreeIterator = tw.getTreeCount() > T_FILE;
 		boolean hasAttributeNodeProvider = treeWalk
 				.getAttributesNodeProvider() != null;
 		while (treeWalk.next()) {
 			if (!processEntry(
 					treeWalk.getTree(T_BASE, CanonicalTreeParser.class),
 					treeWalk.getTree(T_OURS, CanonicalTreeParser.class),
 					treeWalk.getTree(T_THEIRS, CanonicalTreeParser.class),
 					treeWalk.getTree(T_INDEX, DirCacheBuildIterator.class),
 					hasWorkingTreeIterator ? treeWalk.getTree(T_FILE,
 							WorkingTreeIterator.class) : null,
 					ignoreConflicts, hasAttributeNodeProvider
 							? treeWalk.getAttributes()
 							: NO_ATTRIBUTES)) {
 				cleanUp();
 				return false;
 			}
 			if (treeWalk.isSubtree() && enterSubtree)
 				treeWalk.enterSubtree();
 		}
 		return true;
 	}
 }