directives with isolated scope and a optional function '&?' should be returned as undefined if the function is missing

[davidemoro]

Overview of the issue

It is not a bug, probably just a design issue about directives with isolated scope and optional functions passed via '&?'.

If you don't pass any function to the directive, you get a function that returns undefined instead of undefined.

Errors

No errors are thrown.

Motivation for or Use Case

If you declare a scope property as optional, probably the expected behaviour is getting undefined if you try to access this property.
This is exactly what happens when you have a '@?' binding and you don't fill in the optional attribute: you get undefined trying to access $scope.property.

The way to understand if there is a function parameter is inspecting the attrs.
So this seems a special case not motivated for '&?'.

Angular Version(s)

All versions, no regression.

Browsers and Operating System

All browsers and operting systems.

Suggestion

In order to get a common behaviour for optional parameters you could just add the following control to

angular.js/src/ng/compile.js

Line 1463 in 4a6a3ba

case '&':

:
if (optional && !attrs[attrName]) {
return;
}

If you find that this proposal is ok I can make a pull request from: https://github.com/davidemoro/angular.js/blob/master/src/ng/compile.js

I've just run the tests and all seems fine.

[btford]

Thanks for this! I think this will take some serious consideration since changes to $compile tend to have far-reaching effects and unintended consequences.

I don't have a particularly strong opinion on this.

@IgorMinar @caitp @tbosch what do you think?

[caitp]

Right now, the compiler doesn't really track whether or not an expression makes a function call or not (or how many, as it could be more than one). I don't feel like this really makes a lot of sense.

If we did force an expression to do something meaningful (for some definition of "meaningful", by throwing if it doesn't), this would break some apps.

I guess it's a tradeoff between notifying people that they might be doing something they don't expect to do, but I think that given how hard it is to tell if an expression is doing something useful, it's probably not a good idea to change this.

edit: It isn't that bad to make the "optional" flag actually do something for & properties, though. That seems okay with me.

edit again: actually, making these optional would still be a breaking change for directives using optional-flagged expression properties, because it would require the directive to test for the presence of the scope property before evaluating the expression. This seems bad.

[IgorMinar]

I agree that the current behavior is weird. It is not intentional.

We should fix this in 1.3

[davidemoro]

Ok, how can I help you? I want to dive into angular and there are tickets that needs a PR, so I would be glad to contribute.
I just need a mentor that reviews my code