@@ -18,13 +18,13 @@
 #include "config.h"
 
 #import "OFTarArchive.h"
 #import "OFTarArchiveEntry.h"
 #import "OFTarArchiveEntry+Private.h"
-#import "OFStream.h"
+#import "OFDate.h"
 #import "OFSeekableStream.h"
-#import "OFDate.h"
+#import "OFStream.h"
 #ifdef OF_HAVE_FILES
 # import "OFFile.h"
 #endif
 
 #import "OFInvalidArgumentException.h"
@@ -35,11 +35,11 @@
 #import "OFWriteFailedException.h"
 
 @interface OFTarArchive_FileReadStream: OFStream <OFReadyForReadingObserving>
 {
 	OFTarArchiveEntry *_entry;
-	OF_KINDOF(OFStream *) _stream;
+	OFStream *_stream;
 	uint64_t _toRead;
 	bool _atEndOfStream, _skipped;
 }
 
 - (instancetype)of_initWithStream: (OFStream *)stream
@@ -48,22 +48,22 @@
 @end
 
 @interface OFTarArchive_FileWriteStream: OFStream <OFReadyForWritingObserving>
 {
 	OFTarArchiveEntry *_entry;
-	OF_KINDOF(OFStream *) _stream;
+	OFStream *_stream;
 	uint64_t _toWrite;
 }
 
-- (instancetype)of_initWithStream: (OF_KINDOF(OFStream *))stream
+- (instancetype)of_initWithStream: (OFStream *)stream
 			    entry: (OFTarArchiveEntry *)entry;
 @end
 
 @implementation OFTarArchive: OFObject
 @synthesize encoding = _encoding;
 
-+ (instancetype)archiveWithStream: (OF_KINDOF(OFStream *))stream
++ (instancetype)archiveWithStream: (OFStream *)stream
 			     mode: (OFString *)mode
 {
 	return [[[self alloc] initWithStream: stream
 					mode: mode] autorelease];
 }
@@ -80,11 +80,11 @@
 - (instancetype)init
 {
 	OF_INVALID_INIT_METHOD
 }
 
-- (instancetype)initWithStream: (OF_KINDOF(OFStream *))stream
+- (instancetype)initWithStream: (OFStream *)stream
 			  mode: (OFString *)mode
 {
 	self = [super init];
 
 	@try {
@@ -107,24 +107,24 @@
 			bool empty = true;
 
 			if (![_stream isKindOfClass: [OFSeekableStream class]])
 				@throw [OFInvalidArgumentException exception];
 
-			[_stream seekToOffset: -1024
-				       whence: SEEK_END];
-			[_stream readIntoBuffer: buffer.c
+			[(OFSeekableStream *)stream seekToOffset: -1024
+							  whence: SEEK_END];
+			[stream readIntoBuffer: buffer.c
 				    exactLength: 1024];
 
 			for (size_t i = 0; i < 1024 / sizeof(uint32_t); i++)
 				if (buffer.u32[i] != 0)
 					empty = false;
 
 			if (!empty)
 				@throw [OFInvalidFormatException exception];
 
-			[_stream seekToOffset: -1024
-				       whence: SEEK_END];
+			[(OFSeekableStream *)stream seekToOffset: -1024
+							  whence: SEEK_END];
 		}
 
 		_encoding = OF_STRING_ENCODING_UTF_8;
 	} @catch (id e) {
 		[self release];
@@ -175,16 +175,16 @@
 	bool empty = true;
 
 	if (_mode != OF_TAR_ARCHIVE_MODE_READ)
 		@throw [OFInvalidArgumentException exception];
 
-	[_lastReturnedStream of_skip];
+	[(OFTarArchive_FileReadStream *)_lastReturnedStream of_skip];
 	[_lastReturnedStream close];
 	[_lastReturnedStream release];
 	_lastReturnedStream = nil;
 
-	if ([_stream isAtEndOfStream])
+	if (_stream.atEndOfStream)
 		return nil;
 
 	[_stream readIntoBuffer: buffer.c
 		    exactLength: 512];
 
@@ -220,11 +220,12 @@
 		@throw [OFInvalidArgumentException exception];
 
 	if (_lastReturnedStream == nil)
 		@throw [OFInvalidArgumentException exception];
 
-	return [[_lastReturnedStream retain] autorelease];
+	return [[(OFTarArchive_FileReadStream *)_lastReturnedStream
+	    retain] autorelease];
 }
 
 - (OFStream <OFReadyForWritingObserving> *)
     streamForWritingEntry: (OFTarArchiveEntry *)entry
 {
@@ -247,11 +248,12 @@
 	    of_initWithStream: _stream
 			entry: entry];
 
 	objc_autoreleasePoolPop(pool);
 
-	return [[_lastReturnedStream retain] autorelease];
+	return [[(OFTarArchive_FileWriteStream *)_lastReturnedStream
+	    retain] autorelease];
 }
 
 - (void)close
 {
 	if (_stream == nil)
@@ -281,11 +283,11 @@
 	self = [super init];
 
 	@try {
 		_entry = [entry copy];
 		_stream = [stream retain];
-		_toRead = [entry size];
+		_toRead = entry.size;
 	} @catch (id e) {
 		[self release];
 		@throw e;
 	}
 
@@ -339,16 +341,17 @@
 	return _atEndOfStream;
 }
 
 - (bool)hasDataInReadBuffer
 {
-	return ([super hasDataInReadBuffer] || [_stream hasDataInReadBuffer]);
+	return (super.hasDataInReadBuffer || _stream.hasDataInReadBuffer);
 }
 
 - (int)fileDescriptorForReading
 {
-	return [_stream fileDescriptorForReading];
+	return ((id <OFReadyForReadingObserving>)_stream)
+	    .fileDescriptorForReading;
 }
 
 - (void)close
 {
 	[self of_skip];
@@ -366,20 +369,21 @@
 
 	if ([_stream isKindOfClass: [OFSeekableStream class]] &&
 	    _toRead <= INT64_MAX && (of_offset_t)_toRead == (int64_t)_toRead) {
 		uint64_t size;
 
-		[_stream seekToOffset: (of_offset_t)_toRead
-			       whence: SEEK_CUR];
+		[(OFSeekableStream *)_stream seekToOffset: (of_offset_t)_toRead
+						   whence: SEEK_CUR];
 
 		_toRead = 0;
 
-		size = [_entry size];
+		size = _entry.size;
 
 		if (size % 512 != 0)
-			[_stream seekToOffset: 512 - (size % 512)
-				       whence: SEEK_CUR];
+			[(OFSeekableStream *)_stream
+			    seekToOffset: 512 - (size % 512)
+				  whence: SEEK_CUR];
 	} else {
 		char buffer[512];
 		uint64_t size;
 
 		while (_toRead >= 512) {
@@ -392,11 +396,11 @@
 			[_stream readIntoBuffer: buffer
 				    exactLength: (size_t)_toRead];
 			_toRead = 0;
 		}
 
-		size = [_entry size];
+		size = _entry.size;
 
 		if (size % 512 != 0)
 			[_stream readIntoBuffer: buffer
 				    exactLength: (size_t)(512 - (size % 512))];
 	}
@@ -404,19 +408,19 @@
 	_skipped = true;
 }
 @end
 
 @implementation OFTarArchive_FileWriteStream
-- (instancetype)of_initWithStream: (OF_KINDOF(OFStream *))stream
+- (instancetype)of_initWithStream: (OFStream *)stream
 			    entry: (OFTarArchiveEntry *)entry
 {
 	self = [super init];
 
 	@try {
 		_entry = [entry copy];
 		_stream = [stream retain];
-		_toWrite = [entry size];
+		_toWrite = entry.size;
 	} @catch (id e) {
 		[self release];
 		@throw e;
 	}
 
@@ -445,11 +449,11 @@
 
 	@try {
 		bytesWritten = [_stream writeBuffer: buffer
 					     length: length];
 	} @catch (OFWriteFailedException *e) {
-		_toWrite -= [e bytesWritten];
+		_toWrite -= e.bytesWritten;
 		@throw e;
 	}
 
 	_toWrite -= bytesWritten;
 
@@ -464,36 +468,37 @@
 	return (_toWrite == 0);
 }
 
 - (int)fileDescriptorForWriting
 {
-	return [_stream fileDescriptorForWriting];
+	return ((id <OFReadyForWritingObserving>)_stream)
+	    .fileDescriptorForWriting;
 }
 
 - (void)close
 {
 	if (_stream == nil)
 		return;
 
-	uint64_t remainder = 512 - [_entry size] % 512;
+	uint64_t remainder = 512 - _entry.size % 512;
 
 	if (_toWrite > 0)
 		@throw [OFTruncatedDataException exception];
 
 	if (remainder != 512) {
-		bool wasWriteBuffered = [_stream isWriteBuffered];
+		bool wasWriteBuffered = _stream.writeBuffered;
 
 		[_stream setWriteBuffered: true];
 
 		while (remainder--)
 			[_stream writeInt8: 0];
 
 		[_stream flushWriteBuffer];
-		[_stream setWriteBuffered: wasWriteBuffered];
+		_stream.writeBuffered = wasWriteBuffered;
 	}
 
 	[_stream release];
 	_stream = nil;
 
 	[super close];
 }
 @end