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

 			RefNotFoundException, InvalidRefNameException {
 		checkCallable();
 		processOptions();
-		RevWalk revWalk = new RevWalk(repo);
-		try {
+		try (RevWalk revWalk = new RevWalk(repo)) {
 			Ref refToCheck = repo.getRef(name);
 			boolean exists = refToCheck != null
 					&& refToCheck.getName().startsWith(Constants.R_HEADS);
 			return result;
 		} catch (IOException ioe) {
 			throw new JGitInternalException(ioe.getMessage(), ioe);
-		} finally {
-			revWalk.release();
 		}
 	}
 

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

 			if (!force) {
 				// check if the branches to be deleted
 				// are all merged into the current branch
-				RevWalk walk = new RevWalk(repo);
-				RevCommit tip = walk.parseCommit(repo.resolve(Constants.HEAD));
-				for (String branchName : branchNames) {
-					if (branchName == null)
-						continue;
-					Ref currentRef = repo.getRef(branchName);
-					if (currentRef == null)
-						continue;
+				try (RevWalk walk = new RevWalk(repo)) {
+					RevCommit tip = walk
+							.parseCommit(repo.resolve(Constants.HEAD));
+					for (String branchName : branchNames) {
+						if (branchName == null)
+							continue;
+						Ref currentRef = repo.getRef(branchName);
+						if (currentRef == null)
+							continue;
 
-					RevCommit base = walk.parseCommit(repo.resolve(branchName));
-					if (!walk.isMergedInto(base, tip)) {
-						throw new NotMergedException();
+						RevCommit base = walk
+								.parseCommit(repo.resolve(branchName));
+						if (!walk.isMergedInto(base, tip)) {
+							throw new NotMergedException();
+						}
 					}
 				}
 			}

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

 		if (containsCommitish == null)
 			return refs;
 
-		RevWalk walk = new RevWalk(repo);
-		try {
+		try (RevWalk walk = new RevWalk(repo)) {
 			ObjectId resolved = repo.resolve(containsCommitish);
 			if (resolved == null)
 				throw new RefNotFoundException(MessageFormat.format(
 			RevCommit containsCommit = walk.parseCommit(resolved);
 			return RevWalkUtils.findBranchesReachableFrom(containsCommit, walk,
 					refs);
-		} finally {
-			walk.release();
 		}
 	}
 

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

 	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) {
 				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

 		checkCallable();
 		Map<String, Ref> refList;
 		List<Ref> tags = new ArrayList<Ref>();
-		RevWalk revWalk = new RevWalk(repo);
-		try {
+		try (RevWalk revWalk = new RevWalk(repo)) {
 			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

 						mergeStatus = MergeStatus.MERGED_NOT_COMMITTED;
 					}
 					if (commit && !squash) {
-						newHeadId = new Git(getRepository()).commit()
-								.setReflogComment(refLogMessage.toString())
-								.call().getId();
+						try (Git git = new Git(getRepository())) {
+							newHeadId = git.commit()
+									.setReflogComment(refLogMessage.toString())
+									.call().getId();
+						}
 						mergeStatus = MergeStatus.MERGED;
 					}
 					if (commit && squash) {
 							e), e);
 		} finally {
 			if (revWalk != null)
-				revWalk.release();
+				revWalk.close();
 		}
 	}
 

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

 						.call();
 			} catch (StashApplyFailureException e) {
 				conflicts = true;
-				RevWalk rw = new RevWalk(repo);
-				ObjectId stashId = repo.resolve(stash);
-				RevCommit commit = rw.parseCommit(stashId);
-				updateStashRef(commit, commit.getAuthorIdent(),
-						commit.getShortMessage());
+				try (RevWalk rw = new RevWalk(repo)) {
+					ObjectId stashId = repo.resolve(stash);
+					RevCommit commit = rw.parseCommit(stashId);
+					updateStashRef(commit, commit.getAuthorIdent(),
+							commit.getShortMessage());
+				}
 			}
 		}
 		return conflicts;
 			// 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
-							.getFailingPaths()));
-				else
+				switch (cherryPickResult.getStatus()) {
+				case FAILED:
+					if (operation == Operation.BEGIN)
+						return abort(RebaseResult
+								.failed(cherryPickResult.getFailingPaths()));
+					else
+						return stop(commitToPick, Status.STOPPED);
+				case CONFLICTING:
 					return stop(commitToPick, Status.STOPPED);
-			case CONFLICTING:
-				return stop(commitToPick, Status.STOPPED);
-			case OK:
-				newHead = cherryPickResult.getNewHead();
+				case OK:
+					newHead = cherryPickResult.getNewHead();
+				}
 			}
 		}
 		return null;
 			// 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).
-			if (otherParentsUnchanged) {
-				boolean isMerge = commitToPick.getParentCount() > 1;
-				String ourCommitName = getOurCommitName();
-				CherryPickCommand pickCommand = new Git(repo).cherryPick()
-						.include(commitToPick).setOurCommitName(ourCommitName)
-						.setReflogPrefix(REFLOG_PREFIX).setStrategy(strategy);
-				if (isMerge) {
-					pickCommand.setMainlineParentNumber(1);
-					// We write a MERGE_HEAD and later commit explicitly
-					pickCommand.setNoCommit(true);
-					writeMergeInfo(commitToPick, newParents);
-				}
-				CherryPickResult cherryPickResult = pickCommand.call();
-				switch (cherryPickResult.getStatus()) {
-				case FAILED:
-					if (operation == Operation.BEGIN)
-						return abort(RebaseResult.failed(cherryPickResult
-								.getFailingPaths()));
-					else
-						return stop(commitToPick, Status.STOPPED);
-				case CONFLICTING:
-					return stop(commitToPick, Status.STOPPED);
-				case OK:
+			try (Git git = new Git(repo)) {
+				if (otherParentsUnchanged) {
+					boolean isMerge = commitToPick.getParentCount() > 1;
+					String ourCommitName = getOurCommitName();
+					CherryPickCommand pickCommand = git.cherryPick()
+							.include(commitToPick)
+							.setOurCommitName(ourCommitName)
+							.setReflogPrefix(REFLOG_PREFIX)
+							.setStrategy(strategy);
 					if (isMerge) {
-						// Commit the merge (setup above using writeMergeInfo())
-						CommitCommand commit = new Git(repo).commit();
+						pickCommand.setMainlineParentNumber(1);
+						// We write a MERGE_HEAD and later commit explicitly
+						pickCommand.setNoCommit(true);
+						writeMergeInfo(commitToPick, newParents);
+					}
+					CherryPickResult cherryPickResult = pickCommand.call();
+					switch (cherryPickResult.getStatus()) {
+					case FAILED:
+						if (operation == Operation.BEGIN)
+							return abort(RebaseResult.failed(
+									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())
+							CommitCommand commit = git.commit();
+							commit.setAuthor(commitToPick.getAuthorIdent());
+							commit.setReflogComment(REFLOG_PREFIX + " " //$NON-NLS-1$
+									+ commitToPick.getShortMessage());
+							newHead = commit.call();
+						} else
+							newHead = cherryPickResult.getNewHead();
+						break;
+					}
+				} else {
+					// Use the merge strategy to redo merges, which had some of
+					// their non-first parents rewritten
+					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 = git.commit();
 						commit.setAuthor(commitToPick.getAuthorIdent());
+						commit.setMessage(commitToPick.getFullMessage());
 						commit.setReflogComment(REFLOG_PREFIX + " " //$NON-NLS-1$
 								+ commitToPick.getShortMessage());
 						newHead = commit.call();
-					} else
-						newHead = cherryPickResult.getNewHead();
-					break;
-				}
-			} else {
-				// Use the merge strategy to redo merges, which had some of
-				// their non-first parents rewritten
-				MergeCommand merge = new Git(repo).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();
-					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
-							&& mergeResult.getMergeStatus() == MergeResult.MergeStatus.FAILED)
-						return abort(RebaseResult.failed(mergeResult
-								.getFailingPaths()));
-					return stop(commitToPick, Status.STOPPED);
+					} else {
+						if (operation == Operation.BEGIN && mergeResult
+								.getMergeStatus() == MergeResult.MergeStatus.FAILED)
+							return abort(RebaseResult
+									.failed(mergeResult.getFailingPaths()));
+						return stop(commitToPick, Status.STOPPED);
+					}
 				}
 			}
 		}
 		String commitMessage = rebaseState
 				.readFile(MESSAGE_SQUASH);
 
-		if (nextStep == null
-				|| ((nextStep.getAction() != Action.FIXUP) && (nextStep
-						.getAction() != Action.SQUASH))) {
-			// this is the last step in this sequence
-			if (sequenceContainsSquash) {
-				commitMessage = interactiveHandler
-						.modifyCommitMessage(commitMessage);
-			}
-			retNewHead = new Git(repo).commit()
-					.setMessage(stripCommentLines(commitMessage))
-					.setAmend(true).setNoVerify(true).call();
-			rebaseState.getFile(MESSAGE_SQUASH).delete();
-			rebaseState.getFile(MESSAGE_FIXUP).delete();
+		try (Git git = new Git(repo)) {
+			if (nextStep == null || ((nextStep.getAction() != Action.FIXUP)
+					&& (nextStep.getAction() != Action.SQUASH))) {
+				// this is the last step in this sequence
+				if (sequenceContainsSquash) {
+					commitMessage = interactiveHandler
+							.modifyCommitMessage(commitMessage);
+				}
+				retNewHead = git.commit()
+						.setMessage(stripCommentLines(commitMessage))
+						.setAmend(true).setNoVerify(true).call();
+				rebaseState.getFile(MESSAGE_SQUASH).delete();
+				rebaseState.getFile(MESSAGE_FIXUP).delete();
 
-		} else {
-			// Next step is either Squash or Fixup
-			retNewHead = new Git(repo).commit().setMessage(commitMessage)
-					.setAmend(true).setNoVerify(true).call();
+			} else {
+				// Next step is either Squash or Fixup
+				retNewHead = git.commit().setMessage(commitMessage)
+						.setAmend(true).setNoVerify(true).call();
+			}
 		}
 		return retNewHead;
 	}
 		} finally {
 			dc.unlock();
 		}
-		RevWalk rw = new RevWalk(repo);
-		RevCommit commit = rw.parseCommit(repo.resolve(Constants.HEAD));
-		rw.release();
-		return commit;
+		try (RevWalk rw = new RevWalk(repo)) {
+			RevCommit commit = rw.parseCommit(repo.resolve(Constants.HEAD));
+			return commit;
+		}
 	}
 
 	/**
 			throw new UnmergedPathsException();
 
 		// determine whether we need to commit
-		TreeWalk treeWalk = new TreeWalk(repo);
-		treeWalk.reset();
-		treeWalk.setRecursive(true);
-		treeWalk.addTree(new DirCacheIterator(dc));
-		ObjectId id = repo.resolve(Constants.HEAD + "^{tree}"); //$NON-NLS-1$
-		if (id == null)
-			throw new NoHeadException(
-					JGitText.get().cannotRebaseWithoutCurrentHead);
+		boolean needsCommit;
+		try (TreeWalk treeWalk = new TreeWalk(repo)) {
+			treeWalk.reset();
+			treeWalk.setRecursive(true);
+			treeWalk.addTree(new DirCacheIterator(dc));
+			ObjectId id = repo.resolve(Constants.HEAD + "^{tree}"); //$NON-NLS-1$
+			if (id == null)
+				throw new NoHeadException(
+						JGitText.get().cannotRebaseWithoutCurrentHead);
 
-		treeWalk.addTree(id);
+			treeWalk.addTree(id);
 
-		treeWalk.setFilter(TreeFilter.ANY_DIFF);
-
-		boolean needsCommit = treeWalk.next();
-		treeWalk.release();
+			treeWalk.setFilter(TreeFilter.ANY_DIFF);
 
+			needsCommit = treeWalk.next();
+		}
 		if (needsCommit) {
-			CommitCommand commit = new Git(repo).commit();
-			commit.setMessage(rebaseState.readFile(MESSAGE));
-			commit.setAuthor(parseAuthor());
-			return commit.call();
+			try (Git git = new Git(repo)) {
+				CommitCommand commit = git.commit();
+				commit.setMessage(rebaseState.readFile(MESSAGE));
+				commit.setAuthor(parseAuthor());
+				return commit.call();
+			}
 		}
 		return null;
 	}
 		rebaseState.createFile(AUTHOR_SCRIPT, authorScript);
 		rebaseState.createFile(MESSAGE, commitToPick.getFullMessage());
 		ByteArrayOutputStream bos = new ByteArrayOutputStream();
-		DiffFormatter df = new DiffFormatter(bos);
-		df.setRepository(repo);
-		df.format(commitToPick.getParent(0), commitToPick);
+		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,
 
 	private List<RevCommit> calculatePickList(RevCommit headCommit)
 			throws GitAPIException, NoHeadException, IOException {
-		LogCommand cmd = new Git(repo).log().addRange(upstreamCommit,
-				headCommit);
-		Iterable<RevCommit> commitsToUse = cmd.call();
+		Iterable<RevCommit> commitsToUse;
+		try (Git git = new Git(repo)) {
+			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)
 			}
 			dco.setFailOnConflict(false);
 			dco.checkout();
-			walk.release();
+			walk.close();
 		} finally {
 			monitor.endTask();
 		}
 				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

 
 	public Note call() throws GitAPIException {
 		checkCallable();
-		RevWalk walk = new RevWalk(repo);
-		ObjectInserter inserter = repo.newObjectInserter();
-		NoteMap map = NoteMap.newEmptyMap();
-		RevCommit notesCommit = null;
-		try {
+		try (RevWalk walk = new RevWalk(repo);
+				ObjectInserter inserter = repo.newObjectInserter()) {
+			NoteMap map = NoteMap.newEmptyMap();
+			RevCommit notesCommit = null;
 			Ref ref = repo.getRef(notesRef);
 			// if we have a notes ref, use it
 			if (ref != null) {
 			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

 	}
 
 	private RevCommit parseCommit(final ObjectId commitId) {
-		RevCommit commit;
-		RevWalk rw = new RevWalk(repo);
-		try {
-			commit = rw.parseCommit(commitId);
+		try (RevWalk rw = new RevWalk(repo)) {
+			return 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() {
 
 	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);
 
 	private void resetIndex(ObjectId commitTree) throws IOException {
 		DirCache dc = repo.lockDirCache();
-		TreeWalk walk = null;
-		try {
+		try (TreeWalk walk = new TreeWalk(repo)) {
 			DirCacheBuilder builder = dc.builder();
 
-			walk = new TreeWalk(repo);
 			if (commitTree != null)
 				walk.addTree(commitTree);
 			else
 			builder.commit();
 		} finally {
 			dc.unlock();
-			if (walk != null)
-				walk.release();
 		}
 	}
 

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

 		RevCommit newHead = null;
 		checkCallable();
 
-		RevWalk revWalk = new RevWalk(repo);
-		try {
+		try (RevWalk revWalk = new RevWalk(repo)) {
 
 			// get the head commit
 			Ref headRef = repo.getRef(Constants.HEAD);
 							merger.getResultTreeId());
 					dco.setFailOnConflict(true);
 					dco.checkout();
-					newHead = new Git(getRepository()).commit()
-							.setMessage(newMessage)
-							.setReflogComment("revert: " + shortMessage).call(); //$NON-NLS-1$
+					try (Git git = new Git(getRepository())) {
+						newHead = git.commit().setMessage(newMessage)
+								.setReflogComment("revert: " + shortMessage) //$NON-NLS-1$
+								.call();
+					}
 					revertedRefs.add(src);
 					headCommit = newHead;
 				} else {
 					MessageFormat.format(
 									JGitText.get().exceptionCaughtDuringExecutionOfRevertCommand,
 							e), e);
-		} finally {
-			revWalk.release();
 		}
 		return newHead;
 	}

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

 		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

 
 	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) {
 			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

 					JGitText.get().stashApplyOnUnsafeRepository,
 					repo.getRepositoryState()));
 
-		ObjectReader reader = repo.newObjectReader();
-		try {
-			RevWalk revWalk = new RevWalk(reader);
+		try (ObjectReader reader = repo.newObjectReader();
+				RevWalk revWalk = new RevWalk(reader)) {
 
 			ObjectId headCommit = repo.resolve(Constants.HEAD);
 			if (headCommit == null)
 			throw e;
 		} catch (IOException e) {
 			throw new JGitInternalException(JGitText.get().stashApplyFailed, e);
-		} finally {
-			reader.release();
 		}
 	}
 
 
 	private void resetIndex(RevTree tree) throws IOException {
 		DirCache dc = repo.lockDirCache();
-		TreeWalk walk = null;
-		try {
+		try (TreeWalk walk = new TreeWalk(repo)) {
 			DirCacheBuilder builder = dc.builder();
 
-			walk = new TreeWalk(repo);
 			walk.addTree(tree);
 			walk.addTree(new DirCacheIterator(dc));
 			walk.setRecursive(true);
 			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;
-		try {
+		// TODO maybe NameConflictTreeWalk ?
+		try (TreeWalk walk = new TreeWalk(repo)) {
 			walk.addTree(tree);
 			walk.addTree(new FileTreeIterator(repo));
 			walk.setRecursive(true);
 
 				checkoutPath(entry, reader);
 			}
-		} finally {
-			walk.release();
 		}
 	}
 

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

 
 	private RevCommit parseCommit(final ObjectReader reader,
 			final ObjectId headId) throws IOException {
-		final RevWalk walk = new RevWalk(reader);
-		return walk.parseCommit(headId);
+		try (final RevWalk walk = new RevWalk(reader)) {
+			return walk.parseCommit(headId);
+		}
 	}
 
 	private CommitBuilder createBuilder() {
 		checkCallable();
 
 		Ref head = getHead();
-		ObjectReader reader = repo.newObjectReader();
-		try {
+		try (ObjectReader reader = repo.newObjectReader()) {
 			RevCommit headCommit = parseCommit(reader, head.getObjectId());
 			DirCache cache = repo.lockDirCache();
-			ObjectInserter inserter = repo.newObjectInserter();
 			ObjectId commitId;
-			try {
-				TreeWalk treeWalk = new TreeWalk(reader);
+			try (ObjectInserter inserter = repo.newObjectInserter();
+					TreeWalk treeWalk = new TreeWalk(reader)) {
+
 				treeWalk.setRecursive(true);
 				treeWalk.addTree(headCommit.getTree());
 				treeWalk.addTree(new DirCacheIterator(cache));
 				}
 
 			} finally {
-				inserter.release();
 				cache.unlock();
 			}
 
 			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

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

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

 		RepositoryState state = repo.getRepositoryState();
 		processOptions(state);
 
-		RevWalk revWalk = new RevWalk(repo);
-		try {
+		try (RevWalk revWalk = new RevWalk(repo)) {
 			// if no id is set, we should attempt to use HEAD
 			if (id == null) {
 				ObjectId objectId = repo.resolve(Constants.HEAD + "^{commit}"); //$NON-NLS-1$
 			newTag.setObjectId(id);
 
 			// write the tag object
-			ObjectInserter inserter = repo.newObjectInserter();
-			try {
+			try (ObjectInserter inserter = repo.newObjectInserter()) {
 				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

 			throw new IllegalStateException();
 
 		if (revPool != null)
-			revPool.release();
+			revPool.close();
 
 		if (reverse)
 			revPool = new ReverseWalk(getRepository());
 				r.computeAll();
 			return r;
 		} finally {
-			release();
+			close();
 		}
 	}
 
 	}
 
 	private boolean done() {
-		release();
+		close();
 		return false;
 	}
 

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

 			try {
 				return compute(objectReader, pm);
 			} finally {
-				objectReader.release();
+				objectReader.close();
 			}
 		}
 		return Collections.unmodifiableList(entries);

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

 			MissingObjectException, IncorrectObjectTypeException,
 			CheckoutConflictException, IndexWriteException {
 		toBeDeleted.clear();
-		ObjectReader objectReader = repo.getObjectDatabase().newReader();
-		try {
+		try (ObjectReader objectReader = repo.getObjectDatabase().newReader()) {
 			if (headCommitTree != null)
 				preScanTwoTrees();
 			else
 			// commit the index builder - a new index is persisted
 			if (!builder.commit())
 				throw new IndexWriteException();
-		} finally {
-			objectReader.release();
 		}
 		return toBeDeleted.size() == 0;
 	}
 	 */
 	private boolean isModifiedSubtree_IndexWorkingtree(String path)
 			throws CorruptObjectException, IOException {
-		NameConflictTreeWalk tw = new NameConflictTreeWalk(repo);
-		try {
+		try (NameConflictTreeWalk tw = new NameConflictTreeWalk(repo)) {
 			tw.addTree(new DirCacheIterator(dc));
 			tw.addTree(new FileTreeIterator(repo));
 			tw.setRecursive(true);
 				}
 			}
 			return false;
-		} finally {
-			tw.release();
 		}
 	}
 
 	 */
 	private boolean isModifiedSubtree_IndexTree(String path, ObjectId tree)
 			throws CorruptObjectException, IOException {
-		NameConflictTreeWalk tw = new NameConflictTreeWalk(repo);
-		try {
+		try (NameConflictTreeWalk tw = new NameConflictTreeWalk(repo)) {
 			tw.addTree(new DirCacheIterator(dc));
 			tw.addTree(tree);
 			tw.setRecursive(true);
 					return true;
 			}
 			return false;
-		} finally {
-			tw.release();
 		}
 	}
 

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

 		 */
 		protected byte[] readFileFromRepo(Repository repo,
 				String ref, String path) throws GitAPIException, IOException {
-			ObjectReader reader = repo.newObjectReader();
-			byte[] result;
-			try {
+			try (ObjectReader reader = repo.newObjectReader()) {
 				ObjectId oid = repo.resolve(ref + ":" + path); //$NON-NLS-1$
-				result = reader.open(oid).getBytes(Integer.MAX_VALUE);
-			} finally {
-				reader.release();
+				return reader.open(oid).getBytes(Integer.MAX_VALUE);
 			}
-			return result;
 		}
 	}
 
 			DirCache index = DirCache.newInCore();
 			DirCacheBuilder builder = index.builder();
 			ObjectInserter inserter = repo.newObjectInserter();
-			RevWalk rw = new RevWalk(repo);
-			try {
+			try (RevWalk rw = new RevWalk(repo)) {
 				Config cfg = new Config();
 				for (Project proj : bareProjects) {
 					String name = proj.path;
 				return rw.parseCommit(commitId);
 			} catch (IOException e) {
 				throw new ManifestErrorException(e);
-			} finally {
-				rw.release();
 			}
 		} else {
 			return git
 			try {
 				Repository subRepo = add.call();
 				if (revision != null) {
-					Git sub = new Git(subRepo);
-					sub.checkout().setName(findRef(revision, subRepo)).call();
+					try (Git sub = new Git(subRepo)) {
+						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

 					objdb.rollbackPack(newPackDesc);
 			}
 		} finally {
-			ctx.release();
+			ctx.close();
 		}
 	}
 

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

 
 		@Override
 		public void release() {
-			ctx.release();
+			ctx.close();
 		}
 	}
 
 					// The newly created pack is registered in the cache.
 					return ctx.open(id, type).openStream();
 				} finally {
-					ctx.release();
+					ctx.close();
 				}
 			}
 
 							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

 	 */
 	public DfsPackCompactor exclude(DfsPackFile pack) throws IOException {
 		final PackIndex idx;
-		DfsReader ctx = (DfsReader) repo.newObjectReader();
-		try {
+		try (DfsReader ctx = (DfsReader) repo.newObjectReader()) {
 			idx = pack.getPackIndex(ctx);
-		} finally {
-			ctx.release();
 		}
 		return exclude(new PackWriter.ObjectIdSet() {
 			public boolean contains(AnyObjectId id) {
 			pm = NullProgressMonitor.INSTANCE;
 
 		DfsObjDatabase objdb = repo.getObjectDatabase();
-		DfsReader ctx = (DfsReader) objdb.newReader();
-		try {
+		try (DfsReader ctx = (DfsReader) objdb.newReader()) {
 			PackConfig pc = new PackConfig(repo);
 			pc.setIndexVersion(2);
 			pc.setDeltaCompress(false);
 					writeIndex(objdb, pack, pw);
 
 					PackWriter.Statistics stats = pw.getStatistics();
-					pw.release();
+					pw.close();
 					pw = null;
 
 					pack.setPackStats(stats);
 				}
 			} 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

 
 	private Ref doPeel(final Ref leaf) throws MissingObjectException,
 			IOException {
-		RevWalk rw = new RevWalk(repository);
-		try {
+		try (RevWalk rw = new RevWalk(repository)) {
 			RevObject obj = rw.parseAny(leaf.getObjectId());
 			if (obj instanceof RevTag) {
 				return new ObjectIdRef.PeeledTag(
 						leaf.getName(),
 						leaf.getObjectId());
 			}
-		} finally {
-			rw.release();
 		}
 	}
 

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

 				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

 
 	@Override
 	public void close() {
-		ctx.release();
+		ctx.close();
 	}
 }

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

 
 	private ObjectIdRef doPeel(final Ref leaf) throws MissingObjectException,
 			IOException {
-		RevWalk rw = new RevWalk(getRepository());
-		try {
+		try (RevWalk rw = new RevWalk(getRepository())) {
 			RevObject obj = rw.parseAny(leaf.getObjectId());
 			if (obj instanceof RevTag) {
 				return new ObjectIdRef.PeeledTag(leaf.getStorage(), leaf
 				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

 		objId = source.getOldObjectId();
 		updateHEAD = needToUpdateHEAD();
 		tmp = refdb.newTemporaryUpdate();
-		final RevWalk rw = new RevWalk(refdb.getRepository());
-		try {
+		try (final RevWalk rw = new RevWalk(refdb.getRepository())) {
 			// First backup the source so its never unreachable.
 			tmp.setNewObjectId(objId);
 			tmp.setForceUpdate(true);
 			} catch (IOException err) {
 				FileUtils.delete(refdb.fileFor(tmp.getName()));
 			}
-			rw.release();
 		}
 	}
 

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

 				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

 		}
 
 		stats.totalBytes = out.length();
-		reader.release();
+		reader.close();
 		endPhase(writeMonitor);
 	}
 

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

 			throws IOException {
 		dirCache = repository.readDirCache();
 
-		TreeWalk treeWalk = new TreeWalk(repository);
-		treeWalk.setRecursive(true);
-		// add the trees (tree, dirchache, workdir)
-		if (tree != null)
-			treeWalk.addTree(tree);
-		else
-			treeWalk.addTree(new EmptyTreeIterator());
-		treeWalk.addTree(new DirCacheIterator(dirCache));
-		treeWalk.addTree(initialWorkingTreeIterator);
-		Collection<TreeFilter> filters = new ArrayList<TreeFilter>(4);
-
-		if (monitor != null) {
-			// Get the maximum size of the work tree and index
-			// and add some (quite arbitrary)
-			if (estIndexSize == 0)
-				estIndexSize = dirCache.getEntryCount();
-			int total = Math.max(estIndexSize * 10 / 9,
-					estWorkTreeSize * 10 / 9);
-			monitor.beginTask(title, total);
-			filters.add(new ProgressReportingFilter(monitor, total));
-		}
+		try (TreeWalk treeWalk = new TreeWalk(repository)) {
+			treeWalk.setRecursive(true);
+			// add the trees (tree, dirchache, workdir)
+			if (tree != null)
+				treeWalk.addTree(tree);
+			else
+				treeWalk.addTree(new EmptyTreeIterator());
+			treeWalk.addTree(new DirCacheIterator(dirCache));
+			treeWalk.addTree(initialWorkingTreeIterator);
+			Collection<TreeFilter> filters = new ArrayList<TreeFilter>(4);
+
+			if (monitor != null) {
+				// Get the maximum size of the work tree and index
+				// and add some (quite arbitrary)
+				if (estIndexSize == 0)
+					estIndexSize = dirCache.getEntryCount();
+				int total = Math.max(estIndexSize * 10 / 9,
+						estWorkTreeSize * 10 / 9);
+				monitor.beginTask(title, total);
+				filters.add(new ProgressReportingFilter(monitor, total));
+			}
 
-		if (filter != null)
-			filters.add(filter);
-		filters.add(new SkipWorkTreeFilter(INDEX));
-		indexDiffFilter = new IndexDiffFilter(INDEX, WORKDIR);
-		filters.add(indexDiffFilter);
-		treeWalk.setFilter(AndTreeFilter.create(filters));
-		fileModes.clear();
-		while (treeWalk.next()) {
-			AbstractTreeIterator treeIterator = treeWalk.getTree(TREE,
-					AbstractTreeIterator.class);
-			DirCacheIterator dirCacheIterator = treeWalk.getTree(INDEX,
-					DirCacheIterator.class);
-			WorkingTreeIterator workingTreeIterator = treeWalk.getTree(WORKDIR,
-					WorkingTreeIterator.class);
-
-			if (dirCacheIterator != null) {
-				final DirCacheEntry dirCacheEntry = dirCacheIterator
-						.getDirCacheEntry();
-				if (dirCacheEntry != null) {
-					int stage = dirCacheEntry.getStage();
-					if (stage > 0) {
-						String path = treeWalk.getPathString();
-						addConflict(path, stage);
-						continue;
+			if (filter != null)
+				filters.add(filter);
+			filters.add(new SkipWorkTreeFilter(INDEX));
+			indexDiffFilter = new IndexDiffFilter(INDEX, WORKDIR);
+			filters.add(indexDiffFilter);
+			treeWalk.setFilter(AndTreeFilter.create(filters));
+			fileModes.clear();
+			while (treeWalk.next()) {
+				AbstractTreeIterator treeIterator = treeWalk.getTree(TREE,
+						AbstractTreeIterator.class);
+				DirCacheIterator dirCacheIterator = treeWalk.getTree(INDEX,
+						DirCacheIterator.class);
+				WorkingTreeIterator workingTreeIterator = treeWalk
+						.getTree(WORKDIR, WorkingTreeIterator.class);
+
+				if (dirCacheIterator != null) {
+					final DirCacheEntry dirCacheEntry = dirCacheIterator
+							.getDirCacheEntry();
+					if (dirCacheEntry != null) {
+						int stage = dirCacheEntry.getStage();
+						if (stage > 0) {
+							String path = treeWalk.getPathString();
+							addConflict(path, stage);
+							continue;
+						}
 					}
 				}
-			}
 
-			if (treeIterator != null) {
-				if (dirCacheIterator != null) {
-					if (!treeIterator.idEqual(dirCacheIterator)
-							|| treeIterator.getEntryRawMode()
-							!= dirCacheIterator.getEntryRawMode()) {
-						// in repo, in index, content diff => changed
+				if (treeIterator != null) {
+					if (dirCacheIterator != null) {
+						if (!treeIterator.idEqual(dirCacheIterator)
+								|| treeIterator
+										.getEntryRawMode() != dirCacheIterator
+												.getEntryRawMode()) {
+							// in repo, in index, content diff => changed
+							if (!isEntryGitLink(treeIterator)
+									|| !isEntryGitLink(dirCacheIterator)
+									|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
+								changed.add(treeWalk.getPathString());
+						}
+					} else {
+						// in repo, not in index => removed
 						if (!isEntryGitLink(treeIterator)
-								|| !isEntryGitLink(dirCacheIterator)
 								|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
-							changed.add(treeWalk.getPathString());
+							removed.add(treeWalk.getPathString());
+						if (workingTreeIterator != null)
+							untracked.add(treeWalk.getPathString());
 					}
 				} else {
-					// in repo, not in index => removed
-					if (!isEntryGitLink(treeIterator)
-							|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
-						removed.add(treeWalk.getPathString());
-					if (workingTreeIterator != null)
-						untracked.add(treeWalk.getPathString());
-				}
-			} else {
-				if (dirCacheIterator != null) {
-					// not in repo, in index => added
-					if (!isEntryGitLink(dirCacheIterator)
-							|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
-						added.add(treeWalk.getPathString());
-				} else {
-					// not in repo, not in index => untracked
-					if (workingTreeIterator != null
-							&& !workingTreeIterator.isEntryIgnored()) {
-						untracked.add(treeWalk.getPathString());
+					if (dirCacheIterator != null) {
+						// not in repo, in index => added
+						if (!isEntryGitLink(dirCacheIterator)
+								|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
+							added.add(treeWalk.getPathString());
+					} else {
+						// not in repo, not in index => untracked
+						if (workingTreeIterator != null
+								&& !workingTreeIterator.isEntryIgnored()) {
+							untracked.add(treeWalk.getPathString());
+						}
 					}
 				}
-			}
 
-			if (dirCacheIterator != null) {
-				if (workingTreeIterator == null) {
-					// in index, not in workdir => missing
-					if (!isEntryGitLink(dirCacheIterator)
-							|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
-						missing.add(treeWalk.getPathString());
-				} else {
-					if (workingTreeIterator.isModified(
-							dirCacheIterator.getDirCacheEntry(), true,
-							treeWalk.getObjectReader())) {
-						// in index, in workdir, content differs => modified
-						if (!isEntryGitLink(dirCacheIterator) || !isEntryGitLink(workingTreeIterator)
-								|| (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL && ignoreSubmoduleMode != IgnoreSubmoduleMode.DIRTY))
-							modified.add(treeWalk.getPathString());
+				if (dirCacheIterator != null) {
+					if (workingTreeIterator == null) {
+						// in index, not in workdir => missing
+						if (!isEntryGitLink(dirCacheIterator)
+								|| ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL)
+							missing.add(treeWalk.getPathString());
+					} else {
+						if (workingTreeIterator.isModified(
+								dirCacheIterator.getDirCacheEntry(), true,
+								treeWalk.getObjectReader())) {
+							// in index, in workdir, content differs => modified
+							if (!isEntryGitLink(dirCacheIterator)
+									|| !isEntryGitLink(workingTreeIterator)
+									|| (ignoreSubmoduleMode != IgnoreSubmoduleMode.ALL
+											&& ignoreSubmoduleMode != IgnoreSubmoduleMode.DIRTY))
+								modified.add(treeWalk.getPathString());
+						}
 					}
 				}
-			}
 
-			for (int i = 0; i < treeWalk.getTreeCount(); i++) {
-				Set<String> values = fileModes.get(treeWalk.getFileMode(i));
-				String path = treeWalk.getPathString();
-				if (path != null) {
-					if (values == null)
-						values = new HashSet<String>();
-					values.add(path);
-					fileModes.put(treeWalk.getFileMode(i), values);
+				for (int i = 0; i < treeWalk.getTreeCount(); i++) {
+					Set<String> values = fileModes.get(treeWalk.getFileMode(i));
+					String path = treeWalk.getPathString();
+					if (path != null) {
+						if (values == null)
+							values = new HashSet<String>();
+						values.add(path);
+						fileModes.put(treeWalk.getFileMode(i), values);
+					}
 				}
 			}
 		}

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

 	 *             an unexpected IO error occurred while writing changes.
 	 */
 	public Result update() throws IOException {
-		RevWalk rw = new RevWalk(getRepository());
-		try {
+		try (RevWalk rw = new RevWalk(getRepository())) {
 			return update(rw);
-		} finally {
-			rw.release();
 		}
 	}
 
 	 * @throws IOException
 	 */
 	public Result delete() throws IOException {
-		RevWalk rw = new RevWalk(getRepository());
-		try {
+		try (RevWalk rw = new RevWalk(getRepository())) {
 			return delete(rw);
-		} finally {
-			rw.release();
 		}
 	}
 

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

 	public ObjectId resolve(final String revstr)
 			throws AmbiguousObjectException, IncorrectObjectTypeException,
 			RevisionSyntaxException, IOException {
-		RevWalk rw = new RevWalk(this);
-		try {
+		try (RevWalk rw = new RevWalk(this)) {
 			Object resolved = resolve(rw, revstr);
 			if (resolved instanceof String) {
 				final Ref ref = getRef((String)resolved);
 			} else {
 				return (ObjectId) resolved;
 			}
-		} finally {
-			rw.release();
 		}
 	}
 
 	 */
 	public String simplify(final String revstr)
 			throws AmbiguousObjectException, IOException {
-		RevWalk rw = new RevWalk(this);
-		try {
+		try (RevWalk rw = new RevWalk(this)) {
 			Object resolved = resolve(rw, revstr);
 			if (resolved != null)
 				if (resolved instanceof String)
 				else
 					return ((AnyObjectId) resolved).getName();
 			return null;
-		} finally {
-			rw.release();
 		}
 	}
 
 	private ObjectId resolveAbbreviation(final String revstr) throws IOException,
 			AmbiguousObjectException {
 		AbbreviatedObjectId id = AbbreviatedObjectId.fromString(revstr);
-		ObjectReader reader = newObjectReader();
-		try {
+		try (ObjectReader reader = newObjectReader()) {
 			Collection<ObjectId> matches = reader.resolve(id);
 			if (matches.size() == 0)
 				return null;
 				return matches.iterator().next();
 			else
 				throw new AmbiguousObjectException(id, matches);
-		} finally {
-			reader.release();
 		}
 	}
 

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

 	private DirCache dircacheFromTree(ObjectId treeId) throws IOException {
 		DirCache ret = DirCache.newInCore();
 		DirCacheBuilder aBuilder = ret.builder();
-		TreeWalk atw = new TreeWalk(reader);
-		atw.addTree(treeId);
-		atw.setRecursive(true);
-		while (atw.next()) {
-			DirCacheEntry e = new DirCacheEntry(atw.getRawPath());
-			e.setFileMode(atw.getFileMode(0));
-			e.setObjectId(atw.getObjectId(0));
-			aBuilder.add(e);
+		try (TreeWalk atw = new TreeWalk(reader)) {
+			atw.addTree(treeId);
+			atw.setRecursive(true);
+			while (atw.next()) {
+				DirCacheEntry e = new DirCacheEntry(atw.getRawPath());
+				e.setFileMode(atw.getFileMode(0));
+				e.setObjectId(atw.getObjectId(0));
+				aBuilder.add(e);
+			}
 		}
 		aBuilder.finish();
 		return ret;

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

 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;
 
 
 	@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

 			DirCache index = repository.readDirCache();
 			generator.setTree(new DirCacheIterator(index));
 		} catch (IOException e) {
-			generator.release();
+			generator.close();
 			throw e;
 		}
 		return generator;
 				if (filter.isDone(generator.walk))
 					return generator;
 		} catch (IOException e) {
-			generator.release();
+			generator.close();
 			throw e;
 		}
-		generator.release();
+		generator.close();
 		return null;
 	}
 
 				if (filter.isDone(generator.walk))
 					return generator;
 		} catch (IOException e) {
-			generator.release();
+			generator.close();
 			throw e;
 		}
-		generator.release();
+		generator.close();
 		return null;
 	}
 
 			config.load();
 			modulesConfig = config;
 		} else {
-			TreeWalk configWalk = new TreeWalk(repository);
-			try {
+			try (TreeWalk configWalk = new TreeWalk(repository)) {
 				configWalk.addTree(rootTree);
 
 				// The root tree may be part of the submodule walk, so we need to revert
 					if (idx > 0)
 						rootTree.next(idx);
 				}
-			} finally {
-				configWalk.release();
 			}
 		}
 		return this;

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

 
 	/**
 	 * Create process for specified transport and refs updates specification.
-	 * 
+	 *
 	 * @param transport
 	 *            transport between remote and local repository, used to create
 	 *            connection.
 			}
 			return res;
 		} finally {
-			walker.release();
+			walker.close();
 		}
 	}
 

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

 			service();
 		} finally {
 			msgOut = NullOutputStream.INSTANCE;
-			walk.release();
+			walk.close();
 			if (timer != null) {
 				try {
 					timer.terminate();
 	}
 
 	private void processShallow() throws IOException {
-		DepthWalk.RevWalk depthWalk =
-			new DepthWalk.RevWalk(walk.getObjectReader(), depth);
+		try (DepthWalk.RevWalk depthWalk = new DepthWalk.RevWalk(
+				walk.getObjectReader(), depth)) {
 
-		// Find all the commits which will be shallow
-		for (ObjectId o : wantIds) {
-			try {
-				depthWalk.markRoot(depthWalk.parseCommit(o));
-			} catch (IncorrectObjectTypeException notCommit) {
-				// Ignore non-commits in this loop.
+			// Find all the commits which will be shallow
+			for (ObjectId o : wantIds) {
+				try {
+					depthWalk.markRoot(depthWalk.parseCommit(o));
+				} catch (IncorrectObjectTypeException notCommit) {
+					// Ignore non-commits in this loop.
+				}
 			}
-		}
 
-		RevCommit o;
-		while ((o = depthWalk.next()) != null) {
-			DepthWalk.Commit c = (DepthWalk.Commit) o;
+			RevCommit o;
+			while ((o = depthWalk.next()) != null) {
+				DepthWalk.Commit c = (DepthWalk.Commit) o;
 
-			// Commits at the boundary which aren't already shallow in
-			// the client need to be marked as such
-			if (c.getDepth() == depth && !clientShallowCommits.contains(c))
-				pckOut.writeString("shallow " + o.name()); //$NON-NLS-1$
+				// Commits at the boundary which aren't already shallow in
+				// the client need to be marked as such
+				if (c.getDepth() == depth && !clientShallowCommits.contains(c))
+					pckOut.writeString("shallow " + o.name()); //$NON-NLS-1$
 
-			// Commits not on the boundary which are shallow in the client
-			// need to become unshallowed
-			if (c.getDepth() < depth && clientShallowCommits.remove(c)) {
-				unshallowCommits.add(c.copy());
-				pckOut.writeString("unshallow " + c.name()); //$NON-NLS-1$
+				// Commits not on the boundary which are shallow in the client
+				// need to become unshallowed
+				if (c.getDepth() < depth && clientShallowCommits.remove(c)) {
+					unshallowCommits.add(c.copy());
+					pckOut.writeString("unshallow " + c.name()); //$NON-NLS-1$
+				}
 			}
 		}
-
 		pckOut.end();
 	}
 
 			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

 
 	@Override
 	public void close() {
-		inserter.release();
-		reader.release();
+		inserter.close();
+		reader.close();
 		for (final RemotePack p : unfetchedPacks) {
 			if (p.tmpIdx != null)
 				p.tmpIdx.delete();

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

 		String pathPack = null;
 		String pathIdx = null;
 
-		final PackWriter writer = new PackWriter(transport.getPackConfig(),
-				local.newObjectReader());
-		try {
+		try (final PackWriter writer = new PackWriter(transport.getPackConfig(),
+				local.newObjectReader())) {
+
 			final Set<ObjectId> need = new HashSet<ObjectId>();
 			final Set<ObjectId> have = new HashSet<ObjectId>();
 			for (final RemoteRefUpdate r : updates)
 			safeDelete(pathPack);
 
 			throw new TransportException(uri, JGitText.get().cannotStoreObjects, err);
-		} finally {
-			writer.release();
 		}
 	}