feat($parse): provide a mechanism to access the locals object

Extends the built-in identifiers definitions by adding `$local`. This is a
non-assignable reference to the locals object.

Closes: #13247

Author: lgalfaso

docs/content/guide/expression.ngdoc

@@ -113,6 +113,9 @@ This restriction is intentional. It prevents accidental access to the global sta
 Instead use services like `$window` and `$location` in functions called from expressions. Such services
 provide mockable access to globals.
 
+It is possible to access the context object using the identifier `this` and the locals object using the
+identifier `$local`.
+
 <example module="expressionExample">
   <file name="index.html">
     <div class="example2" ng-controller="ExampleController">

src/ng/parse.js

@@ -325,6 +325,7 @@ AST.ArrayExpression = 'ArrayExpression';
 AST.Property = 'Property';
 AST.ObjectExpression = 'ObjectExpression';
 AST.ThisExpression = 'ThisExpression';
+AST.LocalExpression = 'LocalExpression';
 
 // Internal use only
 AST.NGValueParameter = 'NGValueParameter';
@@ -625,7 +626,8 @@ AST.prototype = {
     'false': { type: AST.Literal, value: false },
     'null': { type: AST.Literal, value: null },
     'undefined': {type: AST.Literal, value: undefined },
-    'this': {type: AST.ThisExpression }
+    'this': {type: AST.ThisExpression },
+    '$local': {type: AST.LocalExpression }
   }
 };
 
@@ -745,6 +747,10 @@ function findConstantAndWatchExpressions(ast, $filter) {
     ast.constant = false;
     ast.toWatch = [];
     break;
+  case AST.LocalExpression:
+    ast.constant = false;
+    ast.toWatch = [];
+    break;
   }
 }
 
@@ -1114,6 +1120,10 @@ ASTCompiler.prototype = {
       this.assign(intoId, 's');
       recursionFn('s');
       break;
+    case AST.LocalExpression:
+      this.assign(intoId, 'l');
+      recursionFn('l');
+      break;
     case AST.NGValueParameter:
       this.assign(intoId, 'v');
       recursionFn('v');
@@ -1441,6 +1451,10 @@ ASTInterpreter.prototype = {
       return function(scope) {
         return context ? {value: scope} : scope;
       };
+    case AST.LocalExpression:
+      return function(scope, locals) {
+        return context ? {value: locals} : locals;
+      };
     case AST.NGValueParameter:
       return function(scope, locals, assign, inputs) {
         return context ? {value: assign} : assign;

test/ng/parseSpec.js

@@ -550,8 +550,23 @@ describe('parser', function() {
     });
 
 
-    it('should not confuse `this`, `undefined`, `true`, `false`, `null` when used as identfiers', function() {
-      forEach(['this', 'undefined', 'true', 'false', 'null'], function(identifier) {
+    it('should understand the `$local` expression', function() {
+      expect(createAst('$local')).toEqual(
+        {
+          type: 'Program',
+          body: [
+            {
+              type: 'ExpressionStatement',
+              expression: { type: 'LocalExpression' }
+            }
+          ]
+        }
+      );
+    });
+
+
+    it('should not confuse `this`, `$local`, `undefined`, `true`, `false`, `null` when used as identfiers', function() {
+      forEach(['this', '$local', 'undefined', 'true', 'false', 'null'], function(identifier) {
         expect(createAst('foo.' + identifier)).toEqual(
           {
             type: 'Program',
@@ -3589,6 +3604,28 @@ describe('parser', function() {
           $rootScope.null = {a: 42};
           expect($rootScope.$eval('this.null.a')).toBe(42);
         }));
+
+        it('should allow accessing $local', inject(function($rootScope) {
+          $rootScope.foo = 'foo';
+          $rootScope.bar = 'bar';
+          $rootScope.$local = 'foo';
+          var local = {foo: 42};
+          expect($rootScope.$eval('$local')).toBeUndefined();
+          expect($rootScope.$eval('$local.foo')).toBeUndefined();
+          expect(function() {
+            $rootScope.$eval('$local = {}');
+          }).toThrow();
+          expect(function() {
+            $rootScope.$eval('$local.bar = 23');
+          }).toThrow();
+          expect($rootScope.$eval('$local', local)).toBe(local);
+          expect($rootScope.$eval('$local.foo', local)).toBe(42);
+          expect(function() {
+            $rootScope.$eval('$local = {}', local);
+          }).toThrow();
+          expect($rootScope.$eval('$local.bar = 23', local)).toEqual(23);
+          expect(local.bar).toBe(23);
+        }));
       });
     });
   });