@@ -530,15 +530,15 @@
 
 	@try {
 		void *pool = objc_autoreleasePoolPush();
 		OFString *typeString;
 
-		if (![[element name] isEqual: [self className]] ||
-		    ![[element namespace] isEqual: OF_SERIALIZATION_NS])
+		if (![element.name isEqual: self.className] ||
+		    ![element.namespace isEqual: OF_SERIALIZATION_NS])
 			@throw [OFInvalidArgumentException exception];
 
-		typeString = [[element attributeForName: @"type"] stringValue];
+		typeString = [element attributeForName: @"type"].stringValue;
 
 		if ([typeString isEqual: @"boolean"]) {
 			_type = OF_NUMBER_TYPE_BOOL;
 
 			if ([[element stringValue] isEqual: @"true"])
@@ -551,22 +551,22 @@
 			/*
 			 * FIXME: This will fail if the value is bigger than
 			 *	  INTMAX_MAX!
 			 */
 			_type = OF_NUMBER_TYPE_UINTMAX;
-			_value.uIntMax = [element decimalValue];
+			_value.uIntMax = element.decimalValue;
 		} else if ([typeString isEqual: @"signed"]) {
 			_type = OF_NUMBER_TYPE_INTMAX;
-			_value.intMax = [element decimalValue];
+			_value.intMax = element.decimalValue;
 		} else if ([typeString isEqual: @"float"]) {
 			union {
 				float f;
 				uint32_t u;
 			} f;
 
 			f.u = OF_BSWAP32_IF_LE(
-			    (uint32_t)[element hexadecimalValue]);
+			    (uint32_t)element.hexadecimalValue);
 
 			_type = OF_NUMBER_TYPE_FLOAT;
 			_value.float_ = OF_BSWAP_FLOAT_IF_LE(f.f);
 		} else if ([typeString isEqual: @"double"]) {
 			union {
@@ -573,11 +573,11 @@
 				double d;
 				uint64_t u;
 			} d;
 
 			d.u = OF_BSWAP64_IF_LE(
-			    (uint64_t)[element hexadecimalValue]);
+			    (uint64_t)element.hexadecimalValue);
 
 			_type = OF_NUMBER_TYPE_DOUBLE;
 			_value.double_ = OF_BSWAP_DOUBLE_IF_LE(d.d);
 		} else
 			@throw [OFInvalidArgumentException exception];
@@ -984,12 +984,12 @@
 
 	number = object;
 
 	if (_type & OF_NUMBER_TYPE_FLOAT ||
 	    number->_type & OF_NUMBER_TYPE_FLOAT) {
-		double value1 = [number doubleValue];
-		double value2 = [self doubleValue];
+		double value1 = number.doubleValue;
+		double value2 = self.doubleValue;
 
 		if (isnan(value1) && isnan(value2))
 			return true;
 		if (isnan(value1) || isnan(value2))
 			return false;
@@ -997,13 +997,13 @@
 		return (value1 == value2);
 	}
 
 	if (_type & OF_NUMBER_TYPE_SIGNED ||
 	    number->_type & OF_NUMBER_TYPE_SIGNED)
-		return ([number intMaxValue] == [self intMaxValue]);
+		return (number.intMaxValue == self.intMaxValue);
 
-	return ([number uIntMaxValue] == [self uIntMaxValue]);
+	return (number.uIntMaxValue == self.uIntMaxValue);
 }
 
 - (of_comparison_result_t)compare: (id <OFComparing>)object
 {
 	OFNumber *number;
@@ -1013,33 +1013,33 @@
 
 	number = (OFNumber *)object;
 
 	if (_type & OF_NUMBER_TYPE_FLOAT ||
 	    number->_type & OF_NUMBER_TYPE_FLOAT) {
-		double double1 = [self doubleValue];
-		double double2 = [number doubleValue];
+		double double1 = self.doubleValue;
+		double double2 = number.doubleValue;
 
 		if (double1 > double2)
 			return OF_ORDERED_DESCENDING;
 		if (double1 < double2)
 			return OF_ORDERED_ASCENDING;
 
 		return OF_ORDERED_SAME;
 	} else if (_type & OF_NUMBER_TYPE_SIGNED ||
 	    number->_type & OF_NUMBER_TYPE_SIGNED) {
-		intmax_t int1 = [self intMaxValue];
-		intmax_t int2 = [number intMaxValue];
+		intmax_t int1 = self.intMaxValue;
+		intmax_t int2 = number.intMaxValue;
 
 		if (int1 > int2)
 			return OF_ORDERED_DESCENDING;
 		if (int1 < int2)
 			return OF_ORDERED_ASCENDING;
 
 		return OF_ORDERED_SAME;
 	} else {
-		uintmax_t uint1 = [self uIntMaxValue];
-		uintmax_t uint2 = [number uIntMaxValue];
+		uintmax_t uint1 = self.uIntMaxValue;
+		uintmax_t uint2 = number.uIntMaxValue;
 
 		if (uint1 > uint2)
 			return OF_ORDERED_DESCENDING;
 		if (uint1 < uint2)
 			return OF_ORDERED_ASCENDING;
@@ -1052,24 +1052,24 @@
 {
 	of_number_type_t type = _type;
 	uint32_t hash;
 
 	/* Do we really need signed to represent this number? */
-	if (type & OF_NUMBER_TYPE_SIGNED && [self intMaxValue] >= 0)
+	if (type & OF_NUMBER_TYPE_SIGNED && self.intMaxValue >= 0)
 		type &= ~OF_NUMBER_TYPE_SIGNED;
 
 	/* Do we really need floating point to represent this number? */
 	if (type & OF_NUMBER_TYPE_FLOAT) {
-		double v = [self doubleValue];
+		double v = self.doubleValue;
 
 		if (v < 0) {
-			if (v == [self intMaxValue]) {
+			if (v == self.intMaxValue) {
 				type &= ~OF_NUMBER_TYPE_FLOAT;
 				type |= OF_NUMBER_TYPE_SIGNED;
 			}
 		} else {
-			if (v == [self uIntMaxValue])
+			if (v == self.uIntMaxValue)
 				type &= ~OF_NUMBER_TYPE_FLOAT;
 		}
 	}
 
 	OF_HASH_INIT(hash);
@@ -1078,28 +1078,28 @@
 		union {
 			double d;
 			uint8_t b[sizeof(double)];
 		} d;
 
-		if (isnan([self doubleValue]))
+		if (isnan(self.doubleValue))
 			return 0;
 
-		d.d = OF_BSWAP_DOUBLE_IF_BE([self doubleValue]);
+		d.d = OF_BSWAP_DOUBLE_IF_BE(self.doubleValue);
 
 		for (uint_fast8_t i = 0; i < sizeof(double); i++)
 			OF_HASH_ADD(hash, d.b[i]);
 	} else if (type & OF_NUMBER_TYPE_SIGNED) {
-		intmax_t v = [self intMaxValue] * -1;
+		intmax_t v = self.intMaxValue * -1;
 
 		while (v != 0) {
 			OF_HASH_ADD(hash, v & 0xFF);
 			v >>= 8;
 		}
 
 		OF_HASH_ADD(hash, 1);
 	} else {
-		uintmax_t v = [self uIntMaxValue];
+		uintmax_t v = self.uIntMaxValue;
 
 		while (v != 0) {
 			OF_HASH_ADD(hash, v & 0xFF);
 			v >>= 8;
 		}
@@ -1132,11 +1132,11 @@
 	case OF_NUMBER_TYPE_UINT32:
 	case OF_NUMBER_TYPE_UINT64:
 	case OF_NUMBER_TYPE_SIZE:
 	case OF_NUMBER_TYPE_UINTMAX:
 	case OF_NUMBER_TYPE_UINTPTR:
-		return [OFString stringWithFormat: @"%ju", [self uIntMaxValue]];
+		return [OFString stringWithFormat: @"%ju", self.uIntMaxValue];
 	case OF_NUMBER_TYPE_CHAR:
 	case OF_NUMBER_TYPE_SHORT:
 	case OF_NUMBER_TYPE_INT:
 	case OF_NUMBER_TYPE_LONG:
 	case OF_NUMBER_TYPE_LONGLONG:
@@ -1146,11 +1146,11 @@
 	case OF_NUMBER_TYPE_INT64:
 	case OF_NUMBER_TYPE_SSIZE:
 	case OF_NUMBER_TYPE_INTMAX:
 	case OF_NUMBER_TYPE_PTRDIFF:
 	case OF_NUMBER_TYPE_INTPTR:
-		return [OFString stringWithFormat: @"%jd", [self intMaxValue]];
+		return [OFString stringWithFormat: @"%jd", self.intMaxValue];
 	case OF_NUMBER_TYPE_FLOAT:
 		ret = [OFMutableString stringWithFormat: @"%g", _value.float_];
 
 		if (![ret containsString: @"."])
 			[ret appendString: @".0"];
@@ -1175,13 +1175,13 @@
 - (OFXMLElement *)XMLElementBySerializing
 {
 	void *pool = objc_autoreleasePoolPush();
 	OFXMLElement *element;
 
-	element = [OFXMLElement elementWithName: [self className]
+	element = [OFXMLElement elementWithName: self.className
 				      namespace: OF_SERIALIZATION_NS
-				    stringValue: [self description]];
+				    stringValue: self.description];
 
 	switch (_type) {
 	case OF_NUMBER_TYPE_BOOL:
 		[element addAttributeWithName: @"type"
 				  stringValue: @"boolean"];
@@ -1225,13 +1225,13 @@
 
 		f.f = OF_BSWAP_FLOAT_IF_LE(_value.float_);
 
 		[element addAttributeWithName: @"type"
 				  stringValue: @"float"];
-		[element setStringValue:
+		element.stringValue =
 		    [OFString stringWithFormat: @"%08" PRIx32,
-						OF_BSWAP32_IF_LE(f.u)]];
+						OF_BSWAP32_IF_LE(f.u)];
 
 		break;
 	case OF_NUMBER_TYPE_DOUBLE:;
 		union {
 			double d;
@@ -1240,13 +1240,13 @@
 
 		d.d = OF_BSWAP_DOUBLE_IF_LE(_value.double_);
 
 		[element addAttributeWithName: @"type"
 				  stringValue: @"double"];
-		[element setStringValue:
+		element.stringValue =
 		    [OFString stringWithFormat: @"%016" PRIx64,
-						OF_BSWAP64_IF_LE(d.u)]];
+						OF_BSWAP64_IF_LE(d.u)];
 
 		break;
 	default:
 		@throw [OFInvalidFormatException exception];
 	}
@@ -1276,11 +1276,11 @@
 	double doubleValue;
 
 	if (_type == OF_NUMBER_TYPE_BOOL)
 		return (_value.bool_ ? @"true" : @"false");
 
-	doubleValue = [self doubleValue];
+	doubleValue = self.doubleValue;
 	if (isinf(doubleValue)) {
 		if (options & OF_JSON_REPRESENTATION_JSON5) {
 			if (doubleValue > 0)
 				return @"Infinity";
 			else
@@ -1287,11 +1287,11 @@
 				return @"-Infinity";
 		} else
 			@throw [OFInvalidArgumentException exception];
 	}
 
-	return [self description];
+	return self.description;
 }
 
 - (OFData *)messagePackRepresentation
 {
 	OFMutableData *data;
@@ -1320,11 +1320,11 @@
 
 		[data addItem: &type];
 		[data addItems: &tmp
 			 count: sizeof(tmp)];
 	} else if (_type & OF_NUMBER_TYPE_SIGNED) {
-		intmax_t value = [self intMaxValue];
+		intmax_t value = self.intMaxValue;
 
 		if (value >= -32 && value < 0) {
 			uint8_t tmp = 0xE0 | ((uint8_t)(value - 32) & 0x1F);
 
 			data = [OFMutableData dataWithItems: &tmp
@@ -1369,11 +1369,11 @@
 			[data addItems: &tmp
 				 count: sizeof(tmp)];
 		} else
 			@throw [OFOutOfRangeException exception];
 	} else {
-		uintmax_t value = [self uIntMaxValue];
+		uintmax_t value = self.uIntMaxValue;
 
 		if (value <= 127) {
 			uint8_t tmp = ((uint8_t)value & 0x7F);
 
 			data = [OFMutableData dataWithItems: &tmp