Global state refs (#1120)

* collect global-state refs

* update prepare script (to be removed)

* unit test

* unit

* revert prepare script change

Author: zbigniewmatysek-tomtom

src/expression/expression.test.ts

@@ -39,6 +39,18 @@ describe('createPropertyExpression', () => {
         expect(value[0].message).toBe('"interpolate" expressions cannot be used with this property');
     });
 
+    test('sets globalStateRefs', () => {
+        const {value} = createPropertyExpression(['case', ['>', ['global-state','stateKey'], 0], 100, ['global-state', 'anotherStateKey']], {
+            type: 'number',
+            'property-type': 'data-driven',
+            expression: {
+                'interpolated': false,
+                'parameters': ['zoom', 'feature']
+            }
+        } as any as StylePropertySpecification) as {value: StylePropertyExpression};
+
+        expect(value.globalStateRefs).toEqual(new Set(['stateKey', 'anotherStateKey']));
+    });
 });
 
 describe('evaluate expression', () => {

src/expression/index.ts

@@ -38,6 +38,7 @@ import {NumberArray} from './types/number_array';
 import {ColorArray} from './types/color_array';
 import {VariableAnchorOffsetCollection} from './types/variable_anchor_offset_collection';
 import {ProjectionDefinition} from './types/projection_definition';
+import {GlobalState} from './definitions/global_state';
 
 export type Feature = {
     readonly type: 0 | 1 | 2 | 3 | 'Unknown' | 'Point' | 'MultiPoint' | 'LineString' | 'MultiLineString' | 'Polygon' | 'MultiPolygon';
@@ -165,12 +166,14 @@ export function createExpression(expression: unknown, propertySpec?: StyleProper
 export class ZoomConstantExpression<Kind extends EvaluationKind> {
     kind: Kind;
     isStateDependent: boolean;
+    globalStateRefs: Set<string>;
     _styleExpression: StyleExpression;
 
     constructor(kind: Kind, expression: StyleExpression) {
         this.kind = kind;
         this._styleExpression = expression;
         this.isStateDependent = kind !== ('constant' as EvaluationKind) && !isStateConstant(expression.expression);
+        this.globalStateRefs = findGlobalStateRefs(expression.expression);
     }
 
     evaluateWithoutErrorHandling(
@@ -200,7 +203,7 @@ export class ZoomDependentExpression<Kind extends EvaluationKind> {
     kind: Kind;
     zoomStops: Array<number>;
     isStateDependent: boolean;
-
+    globalStateRefs: Set<string>;
     _styleExpression: StyleExpression;
     interpolationType: InterpolationType;
 
@@ -209,6 +212,7 @@ export class ZoomDependentExpression<Kind extends EvaluationKind> {
         this.zoomStops = zoomStops;
         this._styleExpression = expression;
         this.isStateDependent = kind !== ('camera' as EvaluationKind) && !isStateConstant(expression.expression);
+        this.globalStateRefs = findGlobalStateRefs(expression.expression);
         this.interpolationType = interpolationType;
     }
 
@@ -249,6 +253,7 @@ export function isZoomExpression(expression: any): expression is ZoomConstantExp
 
 export type ConstantExpression = {
     kind: 'constant';
+    globalStateRefs: Set<string>;
     readonly evaluate: (
         globals: GlobalProperties,
         feature?: Feature,
@@ -261,6 +266,7 @@ export type ConstantExpression = {
 export type SourceExpression = {
     kind: 'source';
     isStateDependent: boolean;
+    globalStateRefs: Set<string>;
     readonly evaluate: (
         globals: GlobalProperties,
         feature?: Feature,
@@ -273,6 +279,7 @@ export type SourceExpression = {
 
 export type CameraExpression = {
     kind: 'camera';
+    globalStateRefs: Set<string>;
     readonly evaluate: (
         globals: GlobalProperties,
         feature?: Feature,
@@ -288,6 +295,7 @@ export type CameraExpression = {
 export type CompositeExpression = {
     kind: 'composite';
     isStateDependent: boolean;
+    globalStateRefs: Set<string>;
     readonly evaluate: (
         globals: GlobalProperties,
         feature?: Feature,
@@ -406,6 +414,7 @@ export function normalizePropertyExpression<T>(
             constant = ProjectionDefinition.parse(value);
         }
         return {
+            globalStateRefs: new Set<string>(),
             kind: 'constant',
             evaluate: () => constant
         };
@@ -453,6 +462,17 @@ function findZoomCurve(expression: Expression): Step | Interpolate | ExpressionP
     return result;
 }
 
+export function findGlobalStateRefs(expression: Expression, results = new Set<string>()): Set<string> {
+    if (expression instanceof GlobalState) {
+        results.add(expression.key);
+    }
+
+    expression.eachChild(childExpression => {
+        findGlobalStateRefs(childExpression, results);
+    });
+    return results;
+}
+
 function getExpectedType(spec: StylePropertySpecification): Type {
     const types = {
         color: ColorType,

src/feature_filter/feature_filter.test.ts

@@ -175,6 +175,13 @@ describe('filter', () => {
 
 });
 
+describe('getGlobalStateRefs', () => {
+    test('returns global-state keys', () => {
+        const filter = featureFilter(['==', ['global-state', 'x'], ['zoom']]);
+        expect(filter.getGlobalStateRefs()).toEqual(new Set(['x']));
+    });
+});
+
 describe('legacy filter detection', () => {
     test('definitely legacy filters', () => {
         // Expressions with more than two arguments.

src/feature_filter/index.ts

@@ -1,4 +1,4 @@
-import {createExpression} from '../expression';
+import {createExpression, findGlobalStateRefs} from '../expression';
 import type {GlobalProperties, Feature} from '../expression';
 import {ICanonicalTileID} from '../tiles_and_coordinates';
 import {StylePropertySpecification} from '..';
@@ -13,6 +13,7 @@ type FilterExpression = (
 export type FeatureFilter = {
     filter: FilterExpression;
     needGeometry: boolean;
+    getGlobalStateRefs: () => Set<string>;
 };
 
 export function isExpressionFilter(filter: any): filter is ExpressionFilterSpecification {
@@ -79,7 +80,7 @@ const filterSpec = {
  */
 export function featureFilter(filter: any): FeatureFilter {
     if (filter === null || filter === undefined) {
-        return {filter: () => true, needGeometry: false};
+        return {filter: () => true, needGeometry: false, getGlobalStateRefs: () => new Set()};
     }
 
     if (!isExpressionFilter(filter)) {
@@ -91,8 +92,11 @@ export function featureFilter(filter: any): FeatureFilter {
         throw new Error(compiled.value.map(err => `${err.key}: ${err.message}`).join(', '));
     } else {
         const needGeometry = geometryNeeded(filter);
-        return {filter: (globalProperties: GlobalProperties, feature: Feature, canonical?: ICanonicalTileID) => compiled.value.evaluate(globalProperties, feature, {}, canonical),
-            needGeometry};
+        return {
+            filter: (globalProperties: GlobalProperties, feature: Feature, canonical?: ICanonicalTileID) => compiled.value.evaluate(globalProperties, feature, {}, canonical),
+            needGeometry,
+            getGlobalStateRefs: () => findGlobalStateRefs(compiled.value.expression)
+        };
     }
 }