diff --git a/dulwich/ignore.py b/dulwich/ignore.py
index 2227acb1..fb81c7fc 100644
--- a/dulwich/ignore.py
+++ b/dulwich/ignore.py
@@ -1,373 +1,390 @@
 # Copyright (C) 2017 Jelmer Vernooij <jelmer@jelmer.uk>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 """Parsing of gitignore files.
 
 For details for the matching rules, see https://git-scm.com/docs/gitignore
 """
 
 import os.path
 import re
+from typing import (
+    BinaryIO,
+    Iterable,
+    List,
+    Optional,
+    TYPE_CHECKING,
+    Dict,
+    Union,
+    )
 
-from dulwich.config import get_xdg_config_home_path
+if TYPE_CHECKING:
+    from dulwich.repo import Repo
 
+from dulwich.config import get_xdg_config_home_path, Config
 
-def _translate_segment(segment):
+
+def _translate_segment(segment: bytes) -> bytes:
     if segment == b"*":
         return b'[^/]+'
     res = b""
     i, n = 0, len(segment)
     while i < n:
         c = segment[i:i+1]
         i = i+1
         if c == b'*':
             res += b'[^/]*'
         elif c == b'?':
             res += b'[^/]'
         elif c == b'[':
             j = i
             if j < n and segment[j:j+1] == b'!':
                 j = j+1
             if j < n and segment[j:j+1] == b']':
                 j = j+1
             while j < n and segment[j:j+1] != b']':
                 j = j+1
             if j >= n:
                 res += b'\\['
             else:
                 stuff = segment[i:j].replace(b'\\', b'\\\\')
                 i = j+1
                 if stuff.startswith(b'!'):
                     stuff = b'^' + stuff[1:]
                 elif stuff.startswith(b'^'):
                     stuff = b'\\' + stuff
                 res += b'[' + stuff + b']'
         else:
             res += re.escape(c)
     return res
 
 
-def translate(pat):
+def translate(pat: bytes) -> bytes:
     """Translate a shell PATTERN to a regular expression.
 
     There is no way to quote meta-characters.
 
     Originally copied from fnmatch in Python 2.7, but modified for Dulwich
     to cope with features in Git ignore patterns.
     """
 
     res = b'(?ms)'
 
     if b'/' not in pat[:-1]:
         # If there's no slash, this is a filename-based match
         res += b'(.*/)?'
 
     if pat.startswith(b'**/'):
         # Leading **/
         pat = pat[2:]
         res += b'(.*/)?'
 
     if pat.startswith(b'/'):
         pat = pat[1:]
 
     for i, segment in enumerate(pat.split(b'/')):
         if segment == b'**':
             res += b'(/.*)?'
             continue
         else:
             res += ((re.escape(b'/') if i > 0 else b'') +
                     _translate_segment(segment))
 
     if not pat.endswith(b'/'):
         res += b'/?'
 
     return res + b'\\Z'
 
 
-def read_ignore_patterns(f):
+def read_ignore_patterns(f: BinaryIO) -> Iterable[bytes]:
     """Read a git ignore file.
 
     Args:
       f: File-like object to read from
     Returns: List of patterns
     """
 
     for line in f:
         line = line.rstrip(b"\r\n")
 
         # Ignore blank lines, they're used for readability.
         if not line:
             continue
 
         if line.startswith(b'#'):
             # Comment
             continue
 
         # Trailing spaces are ignored unless they are quoted with a backslash.
         while line.endswith(b' ') and not line.endswith(b'\\ '):
             line = line[:-1]
         line = line.replace(b'\\ ', b' ')
 
         yield line
 
 
-def match_pattern(path, pattern, ignorecase=False):
+def match_pattern(
+        path: bytes, pattern: bytes, ignorecase: bool = False) -> bool:
     """Match a gitignore-style pattern against a path.
 
     Args:
       path: Path to match
       pattern: Pattern to match
       ignorecase: Whether to do case-sensitive matching
     Returns:
       bool indicating whether the pattern matched
     """
     return Pattern(pattern, ignorecase).match(path)
 
 
 class Pattern(object):
     """A single ignore pattern."""
 
-    def __init__(self, pattern, ignorecase=False):
+    def __init__(self, pattern: bytes, ignorecase: bool = False):
         self.pattern = pattern
         self.ignorecase = ignorecase
         if pattern[0:1] == b'!':
             self.is_exclude = False
             pattern = pattern[1:]
         else:
             if pattern[0:1] == b'\\':
                 pattern = pattern[1:]
             self.is_exclude = True
         flags = 0
         if self.ignorecase:
             flags = re.IGNORECASE
         self._re = re.compile(translate(pattern), flags)
 
-    def __bytes__(self):
+    def __bytes__(self) -> bytes:
         return self.pattern
 
-    def __str__(self):
+    def __str__(self) -> str:
         return os.fsdecode(self.pattern)
 
-    def __eq__(self, other):
-        return (type(self) == type(other) and
+    def __eq__(self, other: object) -> bool:
+        return (isinstance(other, type(self)) and
                 self.pattern == other.pattern and
                 self.ignorecase == other.ignorecase)
 
-    def __repr__(self):
-        return "%s(%s, %r)" % (
+    def __repr__(self) -> str:
+        return "%s(%r, %r)" % (
             type(self).__name__, self.pattern, self.ignorecase)
 
-    def match(self, path):
+    def match(self, path: bytes) -> bool:
         """Try to match a path against this ignore pattern.
 
         Args:
           path: Path to match (relative to ignore location)
         Returns: boolean
         """
         return bool(self._re.match(path))
 
 
 class IgnoreFilter(object):
 
-    def __init__(self, patterns, ignorecase=False):
-        self._patterns = []
+    def __init__(self, patterns: Iterable[bytes], ignorecase: bool = False,
+                 path=None):
+        self._patterns = []  # type: List[Pattern]
         self._ignorecase = ignorecase
+        self._path = path
         for pattern in patterns:
             self.append_pattern(pattern)
 
-    def append_pattern(self, pattern):
+    def append_pattern(self, pattern: bytes) -> None:
         """Add a pattern to the set."""
         self._patterns.append(Pattern(pattern, self._ignorecase))
 
-    def find_matching(self, path):
+    def find_matching(self, path: Union[bytes, str]) -> Iterable[Pattern]:
         """Yield all matching patterns for path.
 
         Args:
           path: Path to match
         Returns:
-          Iterator over  iterators
+          Iterator over iterators
         """
         if not isinstance(path, bytes):
             path = os.fsencode(path)
         for pattern in self._patterns:
             if pattern.match(path):
                 yield pattern
 
-    def is_ignored(self, path):
+    def is_ignored(self, path: bytes) -> Optional[bool]:
         """Check whether a path is ignored.
 
         For directories, include a trailing slash.
 
         Returns: status is None if file is not mentioned, True if it is
             included, False if it is explicitly excluded.
         """
         status = None
         for pattern in self.find_matching(path):
             status = pattern.is_exclude
         return status
 
     @classmethod
-    def from_path(cls, path, ignorecase=False):
+    def from_path(cls, path, ignorecase: bool = False) -> 'IgnoreFilter':
         with open(path, 'rb') as f:
-            ret = cls(read_ignore_patterns(f), ignorecase)
-            ret._path = path
-            return ret
+            return cls(read_ignore_patterns(f), ignorecase, path=path)
 
-    def __repr__(self):
-        if getattr(self, '_path', None) is None:
-            return "<%s>" % (type(self).__name__)
+    def __repr__(self) -> str:
+        path = getattr(self, '_path', None)
+        if path is not None:
+            return "%s.from_path(%r)" % (
+                type(self).__name__, path)
         else:
-            return "%s.from_path(%r)" % (type(self).__name__, self._path)
+            return "<%s>" % (type(self).__name__)
 
 
 class IgnoreFilterStack(object):
     """Check for ignore status in multiple filters."""
 
     def __init__(self, filters):
         self._filters = filters
 
-    def is_ignored(self, path):
+    def is_ignored(self, path: str) -> Optional[bool]:
         """Check whether a path is explicitly included or excluded in ignores.
 
         Args:
           path: Path to check
         Returns:
           None if the file is not mentioned, True if it is included,
           False if it is explicitly excluded.
         """
         status = None
         for filter in self._filters:
             status = filter.is_ignored(path)
             if status is not None:
                 return status
         return status
 
 
-def default_user_ignore_filter_path(config):
+def default_user_ignore_filter_path(config: Config) -> str:
     """Return default user ignore filter path.
 
     Args:
       config: A Config object
     Returns:
       Path to a global ignore file
     """
     try:
         return config.get((b'core', ), b'excludesFile')
     except KeyError:
         pass
 
     return get_xdg_config_home_path('git', 'ignore')
 
 
 class IgnoreFilterManager(object):
     """Ignore file manager."""
 
-    def __init__(self, top_path, global_filters, ignorecase):
-        self._path_filters = {}
+    def __init__(
+            self, top_path: str, global_filters: List[IgnoreFilter],
+            ignorecase: bool):
+        self._path_filters = {}  # type: Dict[str, Optional[IgnoreFilter]]
         self._top_path = top_path
         self._global_filters = global_filters
         self._ignorecase = ignorecase
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "%s(%s, %r, %r)" % (
             type(self).__name__, self._top_path,
             self._global_filters,
             self._ignorecase)
 
-    def _load_path(self, path):
+    def _load_path(self, path: str) -> Optional[IgnoreFilter]:
         try:
             return self._path_filters[path]
         except KeyError:
             pass
 
         p = os.path.join(self._top_path, path, '.gitignore')
         try:
             self._path_filters[path] = IgnoreFilter.from_path(
                 p, self._ignorecase)
         except IOError:
             self._path_filters[path] = None
         return self._path_filters[path]
 
-    def find_matching(self, path):
+    def find_matching(self, path: str) -> Iterable[Pattern]:
         """Find matching patterns for path.
 
         Stops after the first ignore file with matches.
 
         Args:
           path: Path to check
         Returns:
           Iterator over Pattern instances
         """
         if os.path.isabs(path):
             raise ValueError('%s is an absolute path' % path)
         filters = [(0, f) for f in self._global_filters]
         if os.path.sep != '/':
             path = path.replace(os.path.sep, '/')
         parts = path.split('/')
         for i in range(len(parts)+1):
             dirname = '/'.join(parts[:i])
             for s, f in filters:
                 relpath = '/'.join(parts[s:i])
                 if i < len(parts):
                     # Paths leading up to the final part are all directories,
                     # so need a trailing slash.
                     relpath += '/'
                 matches = list(f.find_matching(relpath))
                 if matches:
                     return iter(matches)
             ignore_filter = self._load_path(dirname)
             if ignore_filter is not None:
                 filters.insert(0, (i, ignore_filter))
         return iter([])
 
-    def is_ignored(self, path):
+    def is_ignored(self, path: str) -> Optional[bool]:
         """Check whether a path is explicitly included or excluded in ignores.
 
         Args:
           path: Path to check
         Returns:
           None if the file is not mentioned, True if it is included,
           False if it is explicitly excluded.
         """
         matches = list(self.find_matching(path))
         if matches:
             return matches[-1].is_exclude
         return None
 
     @classmethod
-    def from_repo(cls, repo):
+    def from_repo(cls, repo: 'Repo') -> 'IgnoreFilterManager':
         """Create a IgnoreFilterManager from a repository.
 
         Args:
           repo: Repository object
         Returns:
           A `IgnoreFilterManager` object
         """
         global_filters = []
         for p in [
                 os.path.join(repo.controldir(), 'info', 'exclude'),
                 default_user_ignore_filter_path(repo.get_config_stack())]:
             try:
                 global_filters.append(
                     IgnoreFilter.from_path(os.path.expanduser(p)))
             except IOError:
                 pass
         config = repo.get_config_stack()
         ignorecase = config.get_boolean((b'core'), (b'ignorecase'), False)
         return cls(repo.path, global_filters, ignorecase)