The msgSend function has always returned nil if the receiver has been nil or undefined.
Example:
var a = undefined;
var b = [a someSelector]; // b = nil
The variable b is now nil.
This pull request adds the ability for the msgSend function to return undefined if the receiver is undefined. If the receiver is nil it still return nil.
The above example again:
var a = undefined;
var b = [a someSelector]; // b = undefined
The variable b is now undefined.
Background.
The use of nil in Objective-C corresponds to the use of null in C and C++ and stands for "no value". A fundamental function in Objective-C is when you send a message to a receiver that is nil the result is again a nil value. This can be very convenient as you don't need the check if a receiver is nil before sending a message to it.
Objective-J adds the ability the use class structures and message send functionality for Javascript in the same way as Objective-C adds this to C and C++. Javascript also has the value null and is handled in the same way for Objective-J. Javascript also has the value undefined that stands for "not yet defined". This can sometimes be confusing and many try to handle null and undefined as the same thing. This is almost what Objective-J and the Cappuccino frameworks always has been doing. They try to always check for both null and ``undefined and always return nil but never undefined. We can say that Objective-J understands undefined but will try to translate it to nil.
Why do we need this change.
Javascript has both null and undefined and Objective-J is a superset of Javascript. It is now very hard to use undefined in Objective-J code as it will always try to translate it to nil. There are some Javascript libraries that use both null and undefined values and they are very hard to use from Objective-J programs today. Same if you decide to use nil and undefined as a value in your own Objective-J code. This small change will make undefined a full member of the Objective-J language. It should be as it is a superset of Javascript. The Cappuccino frameworks will still handle undefined but only return nil.
How will it impact.
Today most methods will never return undefined so this is a very limited problem. If any does this the main concern is if some code will only check for nil and not undefined.
Example:
var a = [someObject someSelector];
If (a === nil) a = 42;
...
If the variable someObject contains undefined the variable a will now be set to undefined instead of nil. But the variable a will then never be set to 42.
The correct way is to check for both nil and undefined like this:
var a = [someObject someSelector];
If (a == nil) a = 42;
...
To mimic Objective-C correctly the +initialize method should not be sent on a class hierarchy if it does not implement it.
Also the +initialize method should not allowed to be forwarded to another target with Invocation or any other forwarding mechanism.
Added test cases for this and cleaned up some test cases that succeeded for the wrong reason.
This change will not affect many projects as all classes inherit from CPObject.
A long standing bug that never mattered because each class is
initialized with a protocol_list set to an empty array. This
is not the case for the protocol objects but there the syntax
was correct already.
From the first day this class was added to the repo, the sub_classes
property, which is initialized with an empty array, has gone unused.
Removing it. A little less code. A little subsequent processing
and memory used.
Previously, ObjJ was ignoring unknow ivar type. This patch adds some check to ensure the type is either a known class, the current class
itself, a global, a basic JS type or a declared custom type.
In order to declare custom types, this patch introduces the @typedef keyword.
For instance, this will throw a warning:
```objj
@import <Foundation/Foundation.j>
@implementation MyClass: CPObject
{
NUSuppaType mode;
}
@end
```
This will not:
```objj
@import <Foundation/Foundation.j>
@typedef NUSuppaType
@implementation NUMyClass: CPObject
{
NUSuppaType mode;
}
@end
```
Declared types are shared accross all application, one type can only be declared once.
The Objective-J parser and compiler now handles protocol syntax. The Objective-J runtime has new functions to handle protocols. The method 'conformsToProtocol:' has been added to CPObject as an instance and a class method.
1. Fix infinite recursion when no superclass and method isn't implemented. Closes#469.
2. Fix infinite recursion when coercing an object without description implemented into a string. Closes#1289.
3. Add -forwardingTargetForSelector: support.
Reviewed by @tolmasky.
1. Added class_getInstanceVariable to runtime.
2. Changed KVC to rely on class-defined variables vs prototypal ones.
3. Modified KVO code to use public APIs.
Reviewed by me.
Martin Carlberg
Frank Rehwinkel
Martin Carlberg
Martin Carlberg
Antoine Mercadal
Alexander Ljungberg
Aparajita Fishman
Alexander Ljungberg
Francisco Ryan Tolmasky I
Francisco Ryan Tolmasky I
cacaodevandRoss Boucher
Aparajita FishmanandAlexander Ljungberg
Tom Robinson
Paul BaumgartandRoss Boucher