Use AutoClosable to close resources in bundle org.eclipse.jgit

- use try-with-resource where possible
- replace use of deprecated release() by close()

Change-Id: I0f139c3535679087b7fa09649166bca514750b81
Signed-off-by: Matthias Sohn <matthias.sohn@sap.com>

org.eclipse.jgit/src/org/eclipse/jgit/api/CreateBranchCommand.java

@@ -124,8 +124,7 @@ public class CreateBranchCommand extends GitCommand<Ref> {
 			RefNotFoundException, InvalidRefNameException {
 		checkCallable();
 		processOptions();
-		RevWalk revWalk = new RevWalk(repo);
+		try (RevWalk revWalk = new RevWalk(repo)) {
-		try {
 			Ref refToCheck = repo.getRef(name);
 			boolean exists = refToCheck != null
 					&& refToCheck.getName().startsWith(Constants.R_HEADS);
@@ -270,8 +269,6 @@ public class CreateBranchCommand extends GitCommand<Ref> {
 			return result;
 		} catch (IOException ioe) {
 			throw new JGitInternalException(ioe.getMessage(), ioe);
-		} finally {
-			revWalk.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/api/DeleteBranchCommand.java

@@ -108,8 +108,9 @@ public class DeleteBranchCommand extends GitCommand<List<String>> {
 			if (!force) {
 				// check if the branches to be deleted
 				// are all merged into the current branch
-				RevWalk walk = new RevWalk(repo);
+				try (RevWalk walk = new RevWalk(repo)) {
-				RevCommit tip = walk.parseCommit(repo.resolve(Constants.HEAD));
+					RevCommit tip = walk
+							.parseCommit(repo.resolve(Constants.HEAD));
 					for (String branchName : branchNames) {
 						if (branchName == null)
 							continue;
@@ -117,12 +118,14 @@ public class DeleteBranchCommand extends GitCommand<List<String>> {
 						if (currentRef == null)
 							continue;
 
-					RevCommit base = walk.parseCommit(repo.resolve(branchName));
+						RevCommit base = walk
+								.parseCommit(repo.resolve(branchName));
 						if (!walk.isMergedInto(base, tip)) {
 							throw new NotMergedException();
 						}
 					}
 				}
+			}
 			setCallable(false);
 			for (String branchName : branchNames) {
 				if (branchName == null)

org.eclipse.jgit/src/org/eclipse/jgit/api/ListBranchCommand.java

@@ -139,8 +139,7 @@ public class ListBranchCommand extends GitCommand<List<Ref>> {
 		if (containsCommitish == null)
 			return refs;
 
-		RevWalk walk = new RevWalk(repo);
+		try (RevWalk walk = new RevWalk(repo)) {
-		try {
 			ObjectId resolved = repo.resolve(containsCommitish);
 			if (resolved == null)
 				throw new RefNotFoundException(MessageFormat.format(
@@ -149,8 +148,6 @@ public class ListBranchCommand extends GitCommand<List<Ref>> {
 			RevCommit containsCommit = walk.parseCommit(resolved);
 			return RevWalkUtils.findBranchesReachableFrom(containsCommit, walk,
 					refs);
-		} finally {
-			walk.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/api/ListNotesCommand.java

@@ -80,9 +80,8 @@ public class ListNotesCommand extends GitCommand<List<Note>> {
 	public List<Note> call() throws GitAPIException {
 		checkCallable();
 		List<Note> notes = new ArrayList<Note>();
-		RevWalk walk = new RevWalk(repo);
 		NoteMap map = NoteMap.newEmptyMap();
-		try {
+		try (RevWalk walk = new RevWalk(repo)) {
 			Ref ref = repo.getRef(notesRef);
 			// if we have a notes ref, use it
 			if (ref != null) {
@@ -95,8 +94,6 @@ public class ListNotesCommand extends GitCommand<List<Note>> {
 				notes.add(i.next());
 		} catch (IOException e) {
 			throw new JGitInternalException(e.getMessage(), e);
-		} finally {
-			walk.release();
 		}
 
 		return notes;

org.eclipse.jgit/src/org/eclipse/jgit/api/ListTagCommand.java

@@ -78,16 +78,13 @@ public class ListTagCommand extends GitCommand<List<Ref>> {
 		checkCallable();
 		Map<String, Ref> refList;
 		List<Ref> tags = new ArrayList<Ref>();
-		RevWalk revWalk = new RevWalk(repo);
+		try (RevWalk revWalk = new RevWalk(repo)) {
-		try {
 			refList = repo.getRefDatabase().getRefs(Constants.R_TAGS);
 			for (Ref ref : refList.values()) {
 				tags.add(ref);
 			}
 		} catch (IOException e) {
 			throw new JGitInternalException(e.getMessage(), e);
-		} finally {
-			revWalk.release();
 		}
 		Collections.sort(tags, new Comparator<Ref>() {
 			public int compare(Ref o1, Ref o2) {

org.eclipse.jgit/src/org/eclipse/jgit/api/MergeCommand.java

@@ -369,9 +369,11 @@ public class MergeCommand extends GitCommand<MergeResult> {
 						mergeStatus = MergeStatus.MERGED_NOT_COMMITTED;
 					}
 					if (commit && !squash) {
-						newHeadId = new Git(getRepository()).commit()
+						try (Git git = new Git(getRepository())) {
+							newHeadId = git.commit()
 									.setReflogComment(refLogMessage.toString())
 									.call().getId();
+						}
 						mergeStatus = MergeStatus.MERGED;
 					}
 					if (commit && squash) {
@@ -416,7 +418,7 @@ public class MergeCommand extends GitCommand<MergeResult> {
 							e), e);
 		} finally {
 			if (revWalk != null)
-				revWalk.release();
+				revWalk.close();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/api/RebaseCommand.java

@@ -405,13 +405,14 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 						.call();
 			} catch (StashApplyFailureException e) {
 				conflicts = true;
-				RevWalk rw = new RevWalk(repo);
+				try (RevWalk rw = new RevWalk(repo)) {
 					ObjectId stashId = repo.resolve(stash);
 					RevCommit commit = rw.parseCommit(stashId);
 					updateStashRef(commit, commit.getAuthorIdent(),
 							commit.getShortMessage());
 				}
 			}
+		}
 		return conflicts;
 	}
 
@@ -518,15 +519,16 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 			// here we should skip this step in order to avoid
 			// confusing pseudo-changed
 			String ourCommitName = getOurCommitName();
-			CherryPickResult cherryPickResult = new Git(repo).cherryPick()
+			try (Git git = new Git(repo)) {
+				CherryPickResult cherryPickResult = git.cherryPick()
 					.include(commitToPick).setOurCommitName(ourCommitName)
 					.setReflogPrefix(REFLOG_PREFIX).setStrategy(strategy)
 					.call();
 				switch (cherryPickResult.getStatus()) {
 				case FAILED:
 					if (operation == Operation.BEGIN)
-					return abort(RebaseResult.failed(cherryPickResult
+						return abort(RebaseResult
-							.getFailingPaths()));
+								.failed(cherryPickResult.getFailingPaths()));
 					else
 						return stop(commitToPick, Status.STOPPED);
 				case CONFLICTING:
@@ -535,6 +537,7 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 					newHead = cherryPickResult.getNewHead();
 				}
 			}
+		}
 		return null;
 	}
 
@@ -563,12 +566,15 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 			// Use the cherry-pick strategy if all non-first parents did not
 			// change. This is different from C Git, which always uses the merge
 			// strategy (see below).
+			try (Git git = new Git(repo)) {
 				if (otherParentsUnchanged) {
 					boolean isMerge = commitToPick.getParentCount() > 1;
 					String ourCommitName = getOurCommitName();
-				CherryPickCommand pickCommand = new Git(repo).cherryPick()
+					CherryPickCommand pickCommand = git.cherryPick()
-						.include(commitToPick).setOurCommitName(ourCommitName)
+							.include(commitToPick)
-						.setReflogPrefix(REFLOG_PREFIX).setStrategy(strategy);
+							.setOurCommitName(ourCommitName)
+							.setReflogPrefix(REFLOG_PREFIX)
+							.setStrategy(strategy);
 					if (isMerge) {
 						pickCommand.setMainlineParentNumber(1);
 						// We write a MERGE_HEAD and later commit explicitly
@@ -579,16 +585,17 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 					switch (cherryPickResult.getStatus()) {
 					case FAILED:
 						if (operation == Operation.BEGIN)
-						return abort(RebaseResult.failed(cherryPickResult
+							return abort(RebaseResult.failed(
-								.getFailingPaths()));
+									cherryPickResult.getFailingPaths()));
 						else
 							return stop(commitToPick, Status.STOPPED);
 					case CONFLICTING:
 						return stop(commitToPick, Status.STOPPED);
 					case OK:
 						if (isMerge) {
-						// Commit the merge (setup above using writeMergeInfo())
+							// Commit the merge (setup above using
-						CommitCommand commit = new Git(repo).commit();
+							// writeMergeInfo())
+							CommitCommand commit = git.commit();
 							commit.setAuthor(commitToPick.getAuthorIdent());
 							commit.setReflogComment(REFLOG_PREFIX + " " //$NON-NLS-1$
 									+ commitToPick.getShortMessage());
@@ -600,28 +607,29 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 				} else {
 					// Use the merge strategy to redo merges, which had some of
 					// their non-first parents rewritten
-				MergeCommand merge = new Git(repo).merge()
+					MergeCommand merge = git.merge()
 							.setFastForward(MergeCommand.FastForwardMode.NO_FF)
 							.setCommit(false);
 					for (int i = 1; i < commitToPick.getParentCount(); i++)
 						merge.include(newParents.get(i));
 					MergeResult mergeResult = merge.call();
 					if (mergeResult.getMergeStatus().isSuccessful()) {
-					CommitCommand commit = new Git(repo).commit();
+						CommitCommand commit = git.commit();
 						commit.setAuthor(commitToPick.getAuthorIdent());
 						commit.setMessage(commitToPick.getFullMessage());
 						commit.setReflogComment(REFLOG_PREFIX + " " //$NON-NLS-1$
 								+ commitToPick.getShortMessage());
 						newHead = commit.call();
 					} else {
-					if (operation == Operation.BEGIN
+						if (operation == Operation.BEGIN && mergeResult
-							&& mergeResult.getMergeStatus() == MergeResult.MergeStatus.FAILED)
+								.getMergeStatus() == MergeResult.MergeStatus.FAILED)
-						return abort(RebaseResult.failed(mergeResult
+							return abort(RebaseResult
-								.getFailingPaths()));
+									.failed(mergeResult.getFailingPaths()));
 						return stop(commitToPick, Status.STOPPED);
 					}
 				}
 			}
+		}
 		return null;
 	}
 
@@ -758,15 +766,15 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 		String commitMessage = rebaseState
 				.readFile(MESSAGE_SQUASH);
 
-		if (nextStep == null
+		try (Git git = new Git(repo)) {
-				|| ((nextStep.getAction() != Action.FIXUP) && (nextStep
+			if (nextStep == null || ((nextStep.getAction() != Action.FIXUP)
-						.getAction() != Action.SQUASH))) {
+					&& (nextStep.getAction() != Action.SQUASH))) {
 				// this is the last step in this sequence
 				if (sequenceContainsSquash) {
 					commitMessage = interactiveHandler
 							.modifyCommitMessage(commitMessage);
 				}
-			retNewHead = new Git(repo).commit()
+				retNewHead = git.commit()
 						.setMessage(stripCommentLines(commitMessage))
 						.setAmend(true).setNoVerify(true).call();
 				rebaseState.getFile(MESSAGE_SQUASH).delete();
@@ -774,9 +782,10 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 
 			} else {
 				// Next step is either Squash or Fixup
-			retNewHead = new Git(repo).commit().setMessage(commitMessage)
+				retNewHead = git.commit().setMessage(commitMessage)
 						.setAmend(true).setNoVerify(true).call();
 			}
+		}
 		return retNewHead;
 	}
 
@@ -917,11 +926,11 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 		} finally {
 			dc.unlock();
 		}
-		RevWalk rw = new RevWalk(repo);
+		try (RevWalk rw = new RevWalk(repo)) {
 			RevCommit commit = rw.parseCommit(repo.resolve(Constants.HEAD));
-		rw.release();
 			return commit;
 		}
+	}
 
 	/**
 	 * @return the commit if we had to do a commit, otherwise null
@@ -936,7 +945,8 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 			throw new UnmergedPathsException();
 
 		// determine whether we need to commit
-		TreeWalk treeWalk = new TreeWalk(repo);
+		boolean needsCommit;
+		try (TreeWalk treeWalk = new TreeWalk(repo)) {
 			treeWalk.reset();
 			treeWalk.setRecursive(true);
 			treeWalk.addTree(new DirCacheIterator(dc));
@@ -949,15 +959,16 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 
 			treeWalk.setFilter(TreeFilter.ANY_DIFF);
 
-		boolean needsCommit = treeWalk.next();
+			needsCommit = treeWalk.next();
-		treeWalk.release();
+		}
-
 		if (needsCommit) {
-			CommitCommand commit = new Git(repo).commit();
+			try (Git git = new Git(repo)) {
+				CommitCommand commit = git.commit();
 				commit.setMessage(rebaseState.readFile(MESSAGE));
 				commit.setAuthor(parseAuthor());
 				return commit.call();
 			}
+		}
 		return null;
 	}
 
@@ -979,9 +990,10 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 		rebaseState.createFile(AUTHOR_SCRIPT, authorScript);
 		rebaseState.createFile(MESSAGE, commitToPick.getFullMessage());
 		ByteArrayOutputStream bos = new ByteArrayOutputStream();
-		DiffFormatter df = new DiffFormatter(bos);
+		try (DiffFormatter df = new DiffFormatter(bos)) {
 			df.setRepository(repo);
 			df.format(commitToPick.getParent(0), commitToPick);
+		}
 		rebaseState.createFile(PATCH, new String(bos.toByteArray(),
 				Constants.CHARACTER_ENCODING));
 		rebaseState.createFile(STOPPED_SHA,
@@ -1124,9 +1136,11 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 
 	private List<RevCommit> calculatePickList(RevCommit headCommit)
 			throws GitAPIException, NoHeadException, IOException {
-		LogCommand cmd = new Git(repo).log().addRange(upstreamCommit,
+		Iterable<RevCommit> commitsToUse;
-				headCommit);
+		try (Git git = new Git(repo)) {
-		Iterable<RevCommit> commitsToUse = cmd.call();
+			LogCommand cmd = git.log().addRange(upstreamCommit, headCommit);
+			commitsToUse = cmd.call();
+		}
 		List<RevCommit> cherryPickList = new ArrayList<RevCommit>();
 		for (RevCommit commit : commitsToUse) {
 			if (preserveMerges || commit.getParentCount() == 1)
@@ -1312,7 +1326,7 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 			}
 			dco.setFailOnConflict(false);
 			dco.checkout();
-			walk.release();
+			walk.close();
 		} finally {
 			monitor.endTask();
 		}
@@ -1387,7 +1401,7 @@ public class RebaseCommand extends GitCommand<RebaseResult> {
 				throw new IOException("Could not rewind to upstream commit");
 			}
 		} finally {
-			walk.release();
+			walk.close();
 			monitor.endTask();
 		}
 		return true;

org.eclipse.jgit/src/org/eclipse/jgit/api/RemoveNoteCommand.java

@@ -81,11 +81,10 @@ public class RemoveNoteCommand extends GitCommand<Note> {
 
 	public Note call() throws GitAPIException {
 		checkCallable();
-		RevWalk walk = new RevWalk(repo);
+		try (RevWalk walk = new RevWalk(repo);
-		ObjectInserter inserter = repo.newObjectInserter();
+				ObjectInserter inserter = repo.newObjectInserter()) {
 			NoteMap map = NoteMap.newEmptyMap();
 			RevCommit notesCommit = null;
-		try {
 			Ref ref = repo.getRef(notesRef);
 			// if we have a notes ref, use it
 			if (ref != null) {
@@ -98,9 +97,6 @@ public class RemoveNoteCommand extends GitCommand<Note> {
 			return map.getNote(id);
 		} catch (IOException e) {
 			throw new JGitInternalException(e.getMessage(), e);
-		} finally {
-			inserter.release();
-			walk.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/api/ResetCommand.java

@@ -234,17 +234,12 @@ public class ResetCommand extends GitCommand<Ref> {
 	}
 
 	private RevCommit parseCommit(final ObjectId commitId) {
-		RevCommit commit;
+		try (RevWalk rw = new RevWalk(repo)) {
-		RevWalk rw = new RevWalk(repo);
+			return rw.parseCommit(commitId);
-		try {
-			commit = rw.parseCommit(commitId);
 		} catch (IOException e) {
 			throw new JGitInternalException(MessageFormat.format(
 					JGitText.get().cannotReadCommit, commitId.toString()), e);
-		} finally {
-			rw.release();
 		}
-		return commit;
 	}
 
 	private ObjectId resolveRefToCommitId() {
@@ -305,11 +300,10 @@ public class ResetCommand extends GitCommand<Ref> {
 
 	private void resetIndexForPaths(ObjectId commitTree) {
 		DirCache dc = null;
-		try {
+		try (final TreeWalk tw = new TreeWalk(repo)) {
 			dc = repo.lockDirCache();
 			DirCacheBuilder builder = dc.builder();
 
-			final TreeWalk tw = new TreeWalk(repo);
 			tw.addTree(new DirCacheBuildIterator(builder));
 			if (commitTree != null)
 				tw.addTree(commitTree);
@@ -342,11 +336,9 @@ public class ResetCommand extends GitCommand<Ref> {
 
 	private void resetIndex(ObjectId commitTree) throws IOException {
 		DirCache dc = repo.lockDirCache();
-		TreeWalk walk = null;
+		try (TreeWalk walk = new TreeWalk(repo)) {
-		try {
 			DirCacheBuilder builder = dc.builder();
 
-			walk = new TreeWalk(repo);
 			if (commitTree != null)
 				walk.addTree(commitTree);
 			else
@@ -380,8 +372,6 @@ public class ResetCommand extends GitCommand<Ref> {
 			builder.commit();
 		} finally {
 			dc.unlock();
-			if (walk != null)
-				walk.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/api/RevertCommand.java

@@ -126,8 +126,7 @@ public class RevertCommand extends GitCommand<RevCommit> {
 		RevCommit newHead = null;
 		checkCallable();
 
-		RevWalk revWalk = new RevWalk(repo);
+		try (RevWalk revWalk = new RevWalk(repo)) {
-		try {
 
 			// get the head commit
 			Ref headRef = repo.getRef(Constants.HEAD);
@@ -182,9 +181,11 @@ public class RevertCommand extends GitCommand<RevCommit> {
 							merger.getResultTreeId());
 					dco.setFailOnConflict(true);
 					dco.checkout();
-					newHead = new Git(getRepository()).commit()
+					try (Git git = new Git(getRepository())) {
-							.setMessage(newMessage)
+						newHead = git.commit().setMessage(newMessage)
-							.setReflogComment("revert: " + shortMessage).call(); //$NON-NLS-1$
+								.setReflogComment("revert: " + shortMessage) //$NON-NLS-1$
+								.call();
+					}
 					revertedRefs.add(src);
 					headCommit = newHead;
 				} else {
@@ -220,8 +221,6 @@ public class RevertCommand extends GitCommand<RevCommit> {
 					MessageFormat.format(
 									JGitText.get().exceptionCaughtDuringExecutionOfRevertCommand,
 							e), e);
-		} finally {
-			revWalk.release();
 		}
 		return newHead;
 	}

org.eclipse.jgit/src/org/eclipse/jgit/api/RmCommand.java

@@ -144,10 +144,9 @@ public class RmCommand extends GitCommand<DirCache> {
 		checkCallable();
 		DirCache dc = null;
 
-		try {
+		try (final TreeWalk tw = new TreeWalk(repo)) {
 			dc = repo.lockDirCache();
 			DirCacheBuilder builder = dc.builder();
-			final TreeWalk tw = new TreeWalk(repo);
 			tw.reset(); // drop the first empty tree, which we do not need here
 			tw.setRecursive(true);
 			tw.setFilter(PathFilterGroup.createFromStrings(filepatterns));

org.eclipse.jgit/src/org/eclipse/jgit/api/ShowNoteCommand.java

@@ -76,10 +76,9 @@ public class ShowNoteCommand extends GitCommand<Note> {
 
 	public Note call() throws GitAPIException {
 		checkCallable();
-		RevWalk walk = new RevWalk(repo);
 		NoteMap map = NoteMap.newEmptyMap();
 		RevCommit notesCommit = null;
-		try {
+		try (RevWalk walk = new RevWalk(repo)) {
 			Ref ref = repo.getRef(notesRef);
 			// if we have a notes ref, use it
 			if (ref != null) {
@@ -89,8 +88,6 @@ public class ShowNoteCommand extends GitCommand<Note> {
 			return map.getNote(id);
 		} catch (IOException e) {
 			throw new JGitInternalException(e.getMessage(), e);
-		} finally {
-			walk.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/api/StashApplyCommand.java

@@ -166,9 +166,8 @@ public class StashApplyCommand extends GitCommand<ObjectId> {
 					JGitText.get().stashApplyOnUnsafeRepository,
 					repo.getRepositoryState()));
 
-		ObjectReader reader = repo.newObjectReader();
+		try (ObjectReader reader = repo.newObjectReader();
-		try {
+				RevWalk revWalk = new RevWalk(reader)) {
-			RevWalk revWalk = new RevWalk(reader);
 
 			ObjectId headCommit = repo.resolve(Constants.HEAD);
 			if (headCommit == null)
@@ -250,8 +249,6 @@ public class StashApplyCommand extends GitCommand<ObjectId> {
 			throw e;
 		} catch (IOException e) {
 			throw new JGitInternalException(JGitText.get().stashApplyFailed, e);
-		} finally {
-			reader.release();
 		}
 	}
 
@@ -286,11 +283,9 @@ public class StashApplyCommand extends GitCommand<ObjectId> {
 
 	private void resetIndex(RevTree tree) throws IOException {
 		DirCache dc = repo.lockDirCache();
-		TreeWalk walk = null;
+		try (TreeWalk walk = new TreeWalk(repo)) {
-		try {
 			DirCacheBuilder builder = dc.builder();
 
-			walk = new TreeWalk(repo);
 			walk.addTree(tree);
 			walk.addTree(new DirCacheIterator(dc));
 			walk.setRecursive(true);
@@ -321,15 +316,13 @@ public class StashApplyCommand extends GitCommand<ObjectId> {
 			builder.commit();
 		} finally {
 			dc.unlock();
-			if (walk != null)
-				walk.release();
 		}
 	}
 
 	private void resetUntracked(RevTree tree) throws CheckoutConflictException,
 			IOException {
-		TreeWalk walk = new TreeWalk(repo); // maybe NameConflictTreeWalk;
+		// TODO maybe NameConflictTreeWalk ?
-		try {
+		try (TreeWalk walk = new TreeWalk(repo)) {
 			walk.addTree(tree);
 			walk.addTree(new FileTreeIterator(repo));
 			walk.setRecursive(true);
@@ -359,8 +352,6 @@ public class StashApplyCommand extends GitCommand<ObjectId> {
 
 				checkoutPath(entry, reader);
 			}
-		} finally {
-			walk.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/api/StashCreateCommand.java

@@ -187,9 +187,10 @@ public class StashCreateCommand extends GitCommand<RevCommit> {
 
 	private RevCommit parseCommit(final ObjectReader reader,
 			final ObjectId headId) throws IOException {
-		final RevWalk walk = new RevWalk(reader);
+		try (final RevWalk walk = new RevWalk(reader)) {
 			return walk.parseCommit(headId);
 		}
+	}
 
 	private CommitBuilder createBuilder() {
 		CommitBuilder builder = new CommitBuilder();
@@ -239,14 +240,13 @@ public class StashCreateCommand extends GitCommand<RevCommit> {
 		checkCallable();
 
 		Ref head = getHead();
-		ObjectReader reader = repo.newObjectReader();
+		try (ObjectReader reader = repo.newObjectReader()) {
-		try {
 			RevCommit headCommit = parseCommit(reader, head.getObjectId());
 			DirCache cache = repo.lockDirCache();
-			ObjectInserter inserter = repo.newObjectInserter();
 			ObjectId commitId;
-			try {
+			try (ObjectInserter inserter = repo.newObjectInserter();
-				TreeWalk treeWalk = new TreeWalk(reader);
+					TreeWalk treeWalk = new TreeWalk(reader)) {
+
 				treeWalk.setRecursive(true);
 				treeWalk.addTree(headCommit.getTree());
 				treeWalk.addTree(new DirCacheIterator(cache));
@@ -380,7 +380,6 @@ public class StashCreateCommand extends GitCommand<RevCommit> {
 				}
 
 			} finally {
-				inserter.release();
 				cache.unlock();
 			}
 
@@ -391,8 +390,6 @@ public class StashCreateCommand extends GitCommand<RevCommit> {
 			return parseCommit(reader, commitId);
 		} catch (IOException e) {
 			throw new JGitInternalException(JGitText.get().stashFailed, e);
-		} finally {
-			reader.release();
 		}
 	}
 }

org.eclipse.jgit/src/org/eclipse/jgit/api/SubmoduleUpdateCommand.java

@@ -143,8 +143,7 @@ public class SubmoduleUpdateCommand extends
 			RefNotFoundException, GitAPIException {
 		checkCallable();
 
-		try {
+		try (SubmoduleWalk generator = SubmoduleWalk.forIndex(repo)) {
-			SubmoduleWalk generator = SubmoduleWalk.forIndex(repo);
 			if (!paths.isEmpty())
 				generator.setFilter(PathFilterGroup.createFromStrings(paths));
 			List<String> updated = new ArrayList<String>();
@@ -171,8 +170,7 @@ public class SubmoduleUpdateCommand extends
 					submoduleRepo = clone.call().getRepository();
 				}
 
-				try {
+				try (RevWalk walk = new RevWalk(submoduleRepo)) {
-					RevWalk walk = new RevWalk(submoduleRepo);
 					RevCommit commit = walk
 							.parseCommit(generator.getObjectId());
 

org.eclipse.jgit/src/org/eclipse/jgit/api/TagCommand.java

@@ -128,8 +128,7 @@ public class TagCommand extends GitCommand<Ref> {
 		RepositoryState state = repo.getRepositoryState();
 		processOptions(state);
 
-		RevWalk revWalk = new RevWalk(repo);
+		try (RevWalk revWalk = new RevWalk(repo)) {
-		try {
 			// if no id is set, we should attempt to use HEAD
 			if (id == null) {
 				ObjectId objectId = repo.resolve(Constants.HEAD + "^{commit}"); //$NON-NLS-1$
@@ -157,24 +156,19 @@ public class TagCommand extends GitCommand<Ref> {
 			newTag.setObjectId(id);
 
 			// write the tag object
-			ObjectInserter inserter = repo.newObjectInserter();
+			try (ObjectInserter inserter = repo.newObjectInserter()) {
-			try {
 				ObjectId tagId = inserter.insert(newTag);
 				inserter.flush();
 
 				String tag = newTag.getTag();
 				return updateTagRef(tagId, revWalk, tag, newTag.toString());
 
-			} finally {
-				inserter.release();
 			}
 
 		} catch (IOException e) {
 			throw new JGitInternalException(
 					JGitText.get().exceptionCaughtDuringExecutionOfTagCommand,
 					e);
-		} finally {
-			revWalk.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/blame/BlameGenerator.java

@@ -172,7 +172,7 @@ public class BlameGenerator implements AutoCloseable {
 			throw new IllegalStateException();
 
 		if (revPool != null)
-			revPool.release();
+			revPool.close();
 
 		if (reverse)
 			revPool = new ReverseWalk(getRepository());
@@ -450,7 +450,7 @@ public class BlameGenerator implements AutoCloseable {
 				r.computeAll();
 			return r;
 		} finally {
-			release();
+			close();
 		}
 	}
 
@@ -513,7 +513,7 @@ public class BlameGenerator implements AutoCloseable {
 	}
 
 	private boolean done() {
-		release();
+		close();
 		return false;
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/diff/RenameDetector.java

@@ -323,7 +323,7 @@ public class RenameDetector {
 			try {
 				return compute(objectReader, pm);
 			} finally {
-				objectReader.release();
+				objectReader.close();
 			}
 		}
 		return Collections.unmodifiableList(entries);

org.eclipse.jgit/src/org/eclipse/jgit/dircache/DirCacheCheckout.java

@@ -403,8 +403,7 @@ public class DirCacheCheckout {
 			MissingObjectException, IncorrectObjectTypeException,
 			CheckoutConflictException, IndexWriteException {
 		toBeDeleted.clear();
-		ObjectReader objectReader = repo.getObjectDatabase().newReader();
+		try (ObjectReader objectReader = repo.getObjectDatabase().newReader()) {
-		try {
 			if (headCommitTree != null)
 				preScanTwoTrees();
 			else
@@ -454,8 +453,6 @@ public class DirCacheCheckout {
 			// commit the index builder - a new index is persisted
 			if (!builder.commit())
 				throw new IndexWriteException();
-		} finally {
-			objectReader.release();
 		}
 		return toBeDeleted.size() == 0;
 	}
@@ -1056,8 +1053,7 @@ public class DirCacheCheckout {
 	 */
 	private boolean isModifiedSubtree_IndexWorkingtree(String path)
 			throws CorruptObjectException, IOException {
-		NameConflictTreeWalk tw = new NameConflictTreeWalk(repo);
+		try (NameConflictTreeWalk tw = new NameConflictTreeWalk(repo)) {
-		try {
 			tw.addTree(new DirCacheIterator(dc));
 			tw.addTree(new FileTreeIterator(repo));
 			tw.setRecursive(true);
@@ -1075,8 +1071,6 @@ public class DirCacheCheckout {
 				}
 			}
 			return false;
-		} finally {
-			tw.release();
 		}
 	}
 
@@ -1105,8 +1099,7 @@ public class DirCacheCheckout {
 	 */
 	private boolean isModifiedSubtree_IndexTree(String path, ObjectId tree)
 			throws CorruptObjectException, IOException {
-		NameConflictTreeWalk tw = new NameConflictTreeWalk(repo);
+		try (NameConflictTreeWalk tw = new NameConflictTreeWalk(repo)) {
-		try {
 			tw.addTree(new DirCacheIterator(dc));
 			tw.addTree(tree);
 			tw.setRecursive(true);
@@ -1124,8 +1117,6 @@ public class DirCacheCheckout {
 					return true;
 			}
 			return false;
-		} finally {
-			tw.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/gitrepo/RepoCommand.java

@@ -214,15 +214,10 @@ public class RepoCommand extends GitCommand<RevCommit> {
 		 */
 		protected byte[] readFileFromRepo(Repository repo,
 				String ref, String path) throws GitAPIException, IOException {
-			ObjectReader reader = repo.newObjectReader();
+			try (ObjectReader reader = repo.newObjectReader()) {
-			byte[] result;
-			try {
 				ObjectId oid = repo.resolve(ref + ":" + path); //$NON-NLS-1$
-				result = reader.open(oid).getBytes(Integer.MAX_VALUE);
+				return reader.open(oid).getBytes(Integer.MAX_VALUE);
-			} finally {
-				reader.release();
 			}
-			return result;
 		}
 	}
 
@@ -748,8 +743,7 @@ public class RepoCommand extends GitCommand<RevCommit> {
 			DirCache index = DirCache.newInCore();
 			DirCacheBuilder builder = index.builder();
 			ObjectInserter inserter = repo.newObjectInserter();
-			RevWalk rw = new RevWalk(repo);
+			try (RevWalk rw = new RevWalk(repo)) {
-			try {
 				Config cfg = new Config();
 				for (Project proj : bareProjects) {
 					String name = proj.path;
@@ -831,8 +825,6 @@ public class RepoCommand extends GitCommand<RevCommit> {
 				return rw.parseCommit(commitId);
 			} catch (IOException e) {
 				throw new ManifestErrorException(e);
-			} finally {
-				rw.release();
 			}
 		} else {
 			return git
@@ -859,8 +851,10 @@ public class RepoCommand extends GitCommand<RevCommit> {
 			try {
 				Repository subRepo = add.call();
 				if (revision != null) {
-					Git sub = new Git(subRepo);
+					try (Git sub = new Git(subRepo)) {
-					sub.checkout().setName(findRef(revision, subRepo)).call();
+						sub.checkout().setName(findRef(revision, subRepo))
+								.call();
+					}
 					subRepo.close();
 					git.add().addFilepattern(name).call();
 				}

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsGarbageCollector.java

@@ -230,7 +230,7 @@ public class DfsGarbageCollector {
 					objdb.rollbackPack(newPackDesc);
 			}
 		} finally {
-			ctx.release();
+			ctx.close();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsInserter.java

@@ -601,7 +601,7 @@ public class DfsInserter extends ObjectInserter {
 
 		@Override
 		public void release() {
-			ctx.release();
+			ctx.close();
 		}
 	}
 
@@ -631,7 +631,7 @@ public class DfsInserter extends ObjectInserter {
 					// The newly created pack is registered in the cache.
 					return ctx.open(id, type).openStream();
 				} finally {
-					ctx.release();
+					ctx.close();
 				}
 			}
 
@@ -642,7 +642,7 @@ public class DfsInserter extends ObjectInserter {
 							new ReadBackStream(pos), inf, bufsz), bufsz)) {
 				@Override
 				public void close() throws IOException {
-					ctx.release();
+					ctx.close();
 					super.close();
 				}
 			};

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsPackCompactor.java

@@ -179,11 +179,8 @@ public class DfsPackCompactor {
 	 */
 	public DfsPackCompactor exclude(DfsPackFile pack) throws IOException {
 		final PackIndex idx;
-		DfsReader ctx = (DfsReader) repo.newObjectReader();
+		try (DfsReader ctx = (DfsReader) repo.newObjectReader()) {
-		try {
 			idx = pack.getPackIndex(ctx);
-		} finally {
-			ctx.release();
 		}
 		return exclude(new PackWriter.ObjectIdSet() {
 			public boolean contains(AnyObjectId id) {
@@ -206,8 +203,7 @@ public class DfsPackCompactor {
 			pm = NullProgressMonitor.INSTANCE;
 
 		DfsObjDatabase objdb = repo.getObjectDatabase();
-		DfsReader ctx = (DfsReader) objdb.newReader();
+		try (DfsReader ctx = (DfsReader) objdb.newReader()) {
-		try {
 			PackConfig pc = new PackConfig(repo);
 			pc.setIndexVersion(2);
 			pc.setDeltaCompress(false);
@@ -236,7 +232,7 @@ public class DfsPackCompactor {
 					writeIndex(objdb, pack, pw);
 
 					PackWriter.Statistics stats = pw.getStatistics();
-					pw.release();
+					pw.close();
 					pw = null;
 
 					pack.setPackStats(stats);
@@ -250,11 +246,10 @@ public class DfsPackCompactor {
 				}
 			} finally {
 				if (pw != null)
-					pw.release();
+					pw.close();
 			}
 		} finally {
 			rw = null;
-			ctx.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/DfsRefDatabase.java

@@ -183,8 +183,7 @@ public abstract class DfsRefDatabase extends RefDatabase {
 
 	private Ref doPeel(final Ref leaf) throws MissingObjectException,
 			IOException {
-		RevWalk rw = new RevWalk(repository);
+		try (RevWalk rw = new RevWalk(repository)) {
-		try {
 			RevObject obj = rw.parseAny(leaf.getObjectId());
 			if (obj instanceof RevTag) {
 				return new ObjectIdRef.PeeledTag(
@@ -198,8 +197,6 @@ public abstract class DfsRefDatabase extends RefDatabase {
 						leaf.getName(),
 						leaf.getObjectId());
 			}
-		} finally {
-			rw.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/LargePackedWholeObject.java

@@ -112,8 +112,10 @@ final class LargePackedWholeObject extends ObjectLoader {
 				ObjectId obj = pack.getReverseIdx(ctx).findObject(objectOffset);
 				return ctx.open(obj, type).openStream();
 			} finally {
-				ctx.release();
+				ctx.close();
 			}
+		} finally {
+			ctx.close();
 		}
 
 		// Align buffer to inflater size, at a larger than default block.

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/dfs/PackInputStream.java

@@ -80,6 +80,6 @@ final class PackInputStream extends InputStream {
 
 	@Override
 	public void close() {
-		ctx.release();
+		ctx.close();
 	}
 }

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/RefDirectory.java

@@ -477,8 +477,7 @@ public class RefDirectory extends RefDatabase {
 
 	private ObjectIdRef doPeel(final Ref leaf) throws MissingObjectException,
 			IOException {
-		RevWalk rw = new RevWalk(getRepository());
+		try (RevWalk rw = new RevWalk(getRepository())) {
-		try {
 			RevObject obj = rw.parseAny(leaf.getObjectId());
 			if (obj instanceof RevTag) {
 				return new ObjectIdRef.PeeledTag(leaf.getStorage(), leaf
@@ -487,8 +486,6 @@ public class RefDirectory extends RefDatabase {
 				return new ObjectIdRef.PeeledNonTag(leaf.getStorage(), leaf
 						.getName(), leaf.getObjectId());
 			}
-		} finally {
-			rw.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/file/RefDirectoryRename.java

@@ -96,8 +96,7 @@ class RefDirectoryRename extends RefRename {
 		objId = source.getOldObjectId();
 		updateHEAD = needToUpdateHEAD();
 		tmp = refdb.newTemporaryUpdate();
-		final RevWalk rw = new RevWalk(refdb.getRepository());
+		try (final RevWalk rw = new RevWalk(refdb.getRepository())) {
-		try {
 			// First backup the source so its never unreachable.
 			tmp.setNewObjectId(objId);
 			tmp.setForceUpdate(true);
@@ -178,7 +177,6 @@ class RefDirectoryRename extends RefRename {
 			} catch (IOException err) {
 				FileUtils.delete(refdb.fileFor(tmp.getName()));
 			}
-			rw.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/pack/DeltaTask.java

@@ -288,7 +288,7 @@ final class DeltaTask implements Callable<Object> {
 				runWindow(w);
 		} finally {
 			block.pm.endWorker();
-			or.release();
+			or.close();
 			or = null;
 		}
 		return null;

org.eclipse.jgit/src/org/eclipse/jgit/internal/storage/pack/PackWriter.java

@@ -987,7 +987,7 @@ public class PackWriter implements AutoCloseable {
 		}
 
 		stats.totalBytes = out.length();
-		reader.release();
+		reader.close();
 		endPhase(writeMonitor);
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/lib/IndexDiff.java

@@ -400,7 +400,7 @@ public class IndexDiff {
 			throws IOException {
 		dirCache = repository.readDirCache();
 
-		TreeWalk treeWalk = new TreeWalk(repository);
+		try (TreeWalk treeWalk = new TreeWalk(repository)) {
 			treeWalk.setRecursive(true);
 			// add the trees (tree, dirchache, workdir)
 			if (tree != null)
@@ -434,8 +434,8 @@ public class IndexDiff {
 						AbstractTreeIterator.class);
 				DirCacheIterator dirCacheIterator = treeWalk.getTree(INDEX,
 						DirCacheIterator.class);
-			WorkingTreeIterator workingTreeIterator = treeWalk.getTree(WORKDIR,
+				WorkingTreeIterator workingTreeIterator = treeWalk
-					WorkingTreeIterator.class);
+						.getTree(WORKDIR, WorkingTreeIterator.class);
 
 				if (dirCacheIterator != null) {
 					final DirCacheEntry dirCacheEntry = dirCacheIterator
@@ -453,8 +453,9 @@ public class IndexDiff {
 				if (treeIterator != null) {
 					if (dirCacheIterator != null) {
 						if (!treeIterator.idEqual(dirCacheIterator)
-							|| treeIterator.getEntryRawMode()
+								|| treeIterator
-							!= dirCacheIterator.getEntryRawMode()) {
+										.getEntryRawMode() != dirCacheIterator
+												.getEntryRawMode()) {
 							// in repo, in index, content diff => changed
 							if (!isEntryGitLink(treeIterator)
 									|| !isEntryGitLink(dirCacheIterator)
@@ -495,8 +496,10 @@ public class IndexDiff {
 								dirCacheIterator.getDirCacheEntry(), true,
 								treeWalk.getObjectReader())) {
 							// in index, in workdir, content differs => modified
-						if (!isEntryGitLink(dirCacheIterator) || !isEntryGitLink(workingTreeIterator)
+							if (!isEntryGitLink(dirCacheIterator)
-								|| (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL && ignoreSubmoduleMode != IgnoreSubmoduleMode.DIRTY))
+									|| !isEntryGitLink(workingTreeIterator)
+									|| (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL
+											&& ignoreSubmoduleMode != IgnoreSubmoduleMode.DIRTY))
 								modified.add(treeWalk.getPathString());
 						}
 					}
@@ -513,6 +516,7 @@ public class IndexDiff {
 					}
 				}
 			}
+		}
 
 		if (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL) {
 			IgnoreSubmoduleMode localIgnoreSubmoduleMode = ignoreSubmoduleMode;

org.eclipse.jgit/src/org/eclipse/jgit/lib/RefUpdate.java

@@ -460,11 +460,8 @@ public abstract class RefUpdate {
 	 *             an unexpected IO error occurred while writing changes.
 	 */
 	public Result update() throws IOException {
-		RevWalk rw = new RevWalk(getRepository());
+		try (RevWalk rw = new RevWalk(getRepository())) {
-		try {
 			return update(rw);
-		} finally {
-			rw.release();
 		}
 	}
 
@@ -510,11 +507,8 @@ public abstract class RefUpdate {
 	 * @throws IOException
 	 */
 	public Result delete() throws IOException {
-		RevWalk rw = new RevWalk(getRepository());
+		try (RevWalk rw = new RevWalk(getRepository())) {
-		try {
 			return delete(rw);
-		} finally {
-			rw.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/lib/Repository.java

@@ -379,8 +379,7 @@ public abstract class Repository implements AutoCloseable {
 	public ObjectId resolve(final String revstr)
 			throws AmbiguousObjectException, IncorrectObjectTypeException,
 			RevisionSyntaxException, IOException {
-		RevWalk rw = new RevWalk(this);
+		try (RevWalk rw = new RevWalk(this)) {
-		try {
 			Object resolved = resolve(rw, revstr);
 			if (resolved instanceof String) {
 				final Ref ref = getRef((String)resolved);
@@ -388,8 +387,6 @@ public abstract class Repository implements AutoCloseable {
 			} else {
 				return (ObjectId) resolved;
 			}
-		} finally {
-			rw.release();
 		}
 	}
 
@@ -406,8 +403,7 @@ public abstract class Repository implements AutoCloseable {
 	 */
 	public String simplify(final String revstr)
 			throws AmbiguousObjectException, IOException {
-		RevWalk rw = new RevWalk(this);
+		try (RevWalk rw = new RevWalk(this)) {
-		try {
 			Object resolved = resolve(rw, revstr);
 			if (resolved != null)
 				if (resolved instanceof String)
@@ -415,8 +411,6 @@ public abstract class Repository implements AutoCloseable {
 				else
 					return ((AnyObjectId) resolved).getName();
 			return null;
-		} finally {
-			rw.release();
 		}
 	}
 
@@ -791,8 +785,7 @@ public abstract class Repository implements AutoCloseable {
 	private ObjectId resolveAbbreviation(final String revstr) throws IOException,
 			AmbiguousObjectException {
 		AbbreviatedObjectId id = AbbreviatedObjectId.fromString(revstr);
-		ObjectReader reader = newObjectReader();
+		try (ObjectReader reader = newObjectReader()) {
-		try {
 			Collection<ObjectId> matches = reader.resolve(id);
 			if (matches.size() == 0)
 				return null;
@@ -800,8 +793,6 @@ public abstract class Repository implements AutoCloseable {
 				return matches.iterator().next();
 			else
 				throw new AmbiguousObjectException(id, matches);
-		} finally {
-			reader.release();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/merge/RecursiveMerger.java

@@ -269,7 +269,7 @@ public class RecursiveMerger extends ResolveMerger {
 	private DirCache dircacheFromTree(ObjectId treeId) throws IOException {
 		DirCache ret = DirCache.newInCore();
 		DirCacheBuilder aBuilder = ret.builder();
-		TreeWalk atw = new TreeWalk(reader);
+		try (TreeWalk atw = new TreeWalk(reader)) {
 			atw.addTree(treeId);
 			atw.setRecursive(true);
 			while (atw.next()) {
@@ -278,6 +278,7 @@ public class RecursiveMerger extends ResolveMerger {
 				e.setObjectId(atw.getObjectId(0));
 				aBuilder.add(e);
 			}
+		}
 		aBuilder.finish();
 		return ret;
 	}

org.eclipse.jgit/src/org/eclipse/jgit/notes/LeafBucket.java

@@ -53,6 +53,7 @@ import java.util.NoSuchElementException;
 import org.eclipse.jgit.lib.AnyObjectId;
 import org.eclipse.jgit.lib.ObjectId;
 import org.eclipse.jgit.lib.ObjectInserter;
+import org.eclipse.jgit.lib.ObjectInserter.Formatter;
 import org.eclipse.jgit.lib.ObjectReader;
 import org.eclipse.jgit.lib.TreeFormatter;
 
@@ -183,7 +184,9 @@ class LeafBucket extends InMemoryNoteBucket {
 
 	@Override
 	ObjectId getTreeId() {
-		return new ObjectInserter.Formatter().idFor(build());
+		try (Formatter f = new ObjectInserter.Formatter()) {
+			return f.idFor(build());
+		}
 	}
 
 	private TreeFormatter build() {

org.eclipse.jgit/src/org/eclipse/jgit/submodule/SubmoduleWalk.java

@@ -122,7 +122,7 @@ public class SubmoduleWalk implements AutoCloseable {
 			DirCache index = repository.readDirCache();
 			generator.setTree(new DirCacheIterator(index));
 		} catch (IOException e) {
-			generator.release();
+			generator.close();
 			throw e;
 		}
 		return generator;
@@ -152,10 +152,10 @@ public class SubmoduleWalk implements AutoCloseable {
 				if (filter.isDone(generator.walk))
 					return generator;
 		} catch (IOException e) {
-			generator.release();
+			generator.close();
 			throw e;
 		}
-		generator.release();
+		generator.close();
 		return null;
 	}
 
@@ -183,10 +183,10 @@ public class SubmoduleWalk implements AutoCloseable {
 				if (filter.isDone(generator.walk))
 					return generator;
 		} catch (IOException e) {
-			generator.release();
+			generator.close();
 			throw e;
 		}
-		generator.release();
+		generator.close();
 		return null;
 	}
 
@@ -419,8 +419,7 @@ public class SubmoduleWalk implements AutoCloseable {
 			config.load();
 			modulesConfig = config;
 		} else {
-			TreeWalk configWalk = new TreeWalk(repository);
+			try (TreeWalk configWalk = new TreeWalk(repository)) {
-			try {
 				configWalk.addTree(rootTree);
 
 				// The root tree may be part of the submodule walk, so we need to revert
@@ -446,8 +445,6 @@ public class SubmoduleWalk implements AutoCloseable {
 					if (idx > 0)
 						rootTree.next(idx);
 				}
-			} finally {
-				configWalk.release();
 			}
 		}
 		return this;

org.eclipse.jgit/src/org/eclipse/jgit/transport/PushProcess.java

@@ -177,7 +177,7 @@ class PushProcess {
 			}
 			return res;
 		} finally {
-			walker.release();
+			walker.close();
 		}
 	}
 

org.eclipse.jgit/src/org/eclipse/jgit/transport/UploadPack.java

@@ -630,7 +630,7 @@ public class UploadPack {
 			service();
 		} finally {
 			msgOut = NullOutputStream.INSTANCE;
-			walk.release();
+			walk.close();
 			if (timer != null) {
 				try {
 					timer.terminate();
@@ -737,8 +737,8 @@ public class UploadPack {
 	}
 
 	private void processShallow() throws IOException {
-		DepthWalk.RevWalk depthWalk =
+		try (DepthWalk.RevWalk depthWalk = new DepthWalk.RevWalk(
-			new DepthWalk.RevWalk(walk.getObjectReader(), depth);
+				walk.getObjectReader(), depth)) {
 
 			// Find all the commits which will be shallow
 			for (ObjectId o : wantIds) {
@@ -765,7 +765,7 @@ public class UploadPack {
 					pckOut.writeString("unshallow " + c.name()); //$NON-NLS-1$
 				}
 			}
-
+		}
 		pckOut.end();
 	}
 
@@ -1460,7 +1460,7 @@ public class UploadPack {
 			statistics = pw.getStatistics();
 			if (statistics != null)
 				logger.onPackStatistics(statistics);
-			pw.release();
+			pw.close();
 		}
 
 		if (sideband)

org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkFetchConnection.java

@@ -252,8 +252,8 @@ class WalkFetchConnection extends BaseFetchConnection {
 
 	@Override
 	public void close() {
-		inserter.release();
+		inserter.close();
-		reader.release();
+		reader.close();
 		for (final RemotePack p : unfetchedPacks) {
 			if (p.tmpIdx != null)
 				p.tmpIdx.delete();

org.eclipse.jgit/src/org/eclipse/jgit/transport/WalkPushConnection.java

@@ -220,9 +220,9 @@ class WalkPushConnection extends BaseConnection implements PushConnection {
 		String pathPack = null;
 		String pathIdx = null;
 
-		final PackWriter writer = new PackWriter(transport.getPackConfig(),
+		try (final PackWriter writer = new PackWriter(transport.getPackConfig(),
-				local.newObjectReader());
+				local.newObjectReader())) {
-		try {
+
 			final Set<ObjectId> need = new HashSet<ObjectId>();
 			final Set<ObjectId> have = new HashSet<ObjectId>();
 			for (final RemoteRefUpdate r : updates)
@@ -293,8 +293,6 @@ class WalkPushConnection extends BaseConnection implements PushConnection {
 			safeDelete(pathPack);
 
 			throw new TransportException(uri, JGitText.get().cannotStoreObjects, err);
-		} finally {
-			writer.release();
 		}
 	}