ol 7.3.0 → 7.3.1-dev

package/style/expressions.js

@@ -21,15 +21,16 @@ import {asArray, fromString, isStringColor} from '../color.js';
  *     of bands, depending on the underlying data source and
  *     {@link import("../source/GeoTIFF.js").Options configuration}. `xOffset` and `yOffset` are optional
  *     and allow specifying pixel offsets for x and y. This is used for sampling data from neighboring pixels.
- *   * `['get', 'attributeName']` fetches a feature attribute (it will be prefixed by `a_` in the shader)
- *     Note: those will be taken from the attributes provided to the renderer
+ *   * `['get', 'attributeName', typeHint]` fetches a feature property value, similar to `feature.get('attributeName')`
+ *     A type hint can optionally be specified, in case the resulting expression contains a type ambiguity which
+ *     will make it invalid. Type hints can be one of: 'string', 'color', 'number', 'boolean', 'number[]'
  *   * `['resolution']` returns the current resolution
  *   * `['time']` returns the time in seconds since the creation of the layer
- *   * `['var', 'varName']` fetches a value from the style variables, or 0 if undefined
+ *   * `['var', 'varName']` fetches a value from the style variables; will throw an error if that variable is undefined
  *   * `['zoom']` returns the current zoom level
  *
  * * Math operators:
- *   * `['*', value1, value2]` multiplies `value1` by `value2`
+ *   * `['*', value1, value2]` multiplies `value1` by `value2` (either numbers or colors)
  *   * `['/', value1, value2]` divides `value1` by `value2`
  *   * `['+', value1, value2]` adds `value1` and `value2`
  *   * `['-', value1, value2]` subtracts `value2` from `value1`
@@ -90,6 +91,7 @@ import {asArray, fromString, isStringColor} from '../color.js';
  * Literal values can be of the following types:
  * * `boolean`
  * * `number`
+ * * `number[]` (number arrays can only have a length of 2, 3 or 4)
  * * `string`
  * * {@link module:ol/color~Color}
  *
@@ -112,14 +114,36 @@ export const ValueTypes = {
   NONE: 0,
 };
 
+/**
+ * @param {string} typeHint Type hint
+ * @return {ValueTypes} Resulting value type (will be a single type)
+ */
+function getTypeFromHint(typeHint) {
+  switch (typeHint) {
+    case 'string':
+      return ValueTypes.STRING;
+    case 'color':
+      return ValueTypes.COLOR;
+    case 'number':
+      return ValueTypes.NUMBER;
+    case 'boolean':
+      return ValueTypes.BOOLEAN;
+    case 'number[]':
+      return ValueTypes.NUMBER_ARRAY;
+    default:
+      throw new Error(`Unrecognized type hint: ${typeHint}`);
+  }
+}
+
 /**
  * An operator declaration must contain two methods: `getReturnType` which returns a type based on
  * the operator arguments, and `toGlsl` which returns a GLSL-compatible string.
  * Note: both methods can process arguments recursively.
  * @typedef {Object} Operator
  * @property {function(Array<ExpressionValue>): ValueTypes|number} getReturnType Returns one or several types
- * @property {function(ParsingContext, Array<ExpressionValue>, ValueTypes=): string} toGlsl Returns a GLSL-compatible string
- * Note: takes in an optional type hint as 3rd parameter
+ * @property {function(ParsingContext, Array<ExpressionValue>, ValueTypes): string} toGlsl Returns a GLSL-compatible string
+ * given a parsing context, an array of arguments and an expected type.
+ * Note: the expected type can be a combination such as ValueTypes.NUMBER | ValueTypes.STRING or ValueTypes.ANY for instance
  */
 
 /**
@@ -185,16 +209,48 @@ export function isTypeUnique(valueType) {
   return Math.log2(valueType) % 1 === 0;
 }
 
+/**
+ * Print types as a readable string
+ * @param {ValueTypes|number} valueType Number containing value type binary flags
+ * @return {string} Types
+ */
+function printTypes(valueType) {
+  const result = [];
+  if ((valueType & ValueTypes.NUMBER) > 0) {
+    result.push('number');
+  }
+  if ((valueType & ValueTypes.COLOR) > 0) {
+    result.push('color');
+  }
+  if ((valueType & ValueTypes.BOOLEAN) > 0) {
+    result.push('boolean');
+  }
+  if ((valueType & ValueTypes.NUMBER_ARRAY) > 0) {
+    result.push('number[]');
+  }
+  if ((valueType & ValueTypes.STRING) > 0) {
+    result.push('string');
+  }
+  return result.length > 0 ? result.join(', ') : '(no type)';
+}
+
+/**
+ * @typedef {Object} ParsingContextExternal
+ * @property {string} name Name, unprefixed
+ * @property {ValueTypes} type One of the value types constants
+ */
+
 /**
  * Context available during the parsing of an expression.
  * @typedef {Object} ParsingContext
  * @property {boolean} [inFragmentShader] If false, means the expression output should be made for a vertex shader
- * @property {Array<string>} variables List of variables used in the expression; contains **unprefixed names**
- * @property {Array<string>} attributes List of attributes used in the expression; contains **unprefixed names**
+ * @property {Array<ParsingContextExternal>} variables External variables used in the expression
+ * @property {Array<ParsingContextExternal>} attributes External attributes used in the expression
  * @property {Object<string, number>} stringLiteralsMap This object maps all encountered string values to a number
  * @property {Object<string, string>} functions Lookup of functions used by the style.
  * @property {number} [bandCount] Number of bands per pixel.
  * @property {Array<PaletteTexture>} [paletteTextures] List of palettes used by the style.
+ * @property {import("../style/literal").LiteralStyle} style The style being parsed
  */
 
 /**
@@ -229,15 +285,15 @@ export function arrayToGlsl(array) {
  * @return {string} The color expressed in the `vec4(1.0, 1.0, 1.0, 1.0)` form.
  */
 export function colorToGlsl(color) {
-  const array = asArray(color).slice();
-  if (array.length < 4) {
-    array.push(1);
-  }
-  return arrayToGlsl(
-    array.map(function (c, i) {
-      return i < 3 ? c / 255 : c;
-    })
-  );
+  const array = asArray(color);
+  const alpha = array.length > 3 ? array[3] : 1;
+  // all components are premultiplied with alpha value
+  return arrayToGlsl([
+    (array[0] / 255) * alpha,
+    (array[1] / 255) * alpha,
+    (array[2] / 255) * alpha,
+    alpha,
+  ]);
 }
 
 /**
@@ -271,10 +327,13 @@ export function stringToGlsl(context, string) {
  * will be read and modified during the parsing operation.
  * @param {ParsingContext} context Parsing context
  * @param {ExpressionValue} value Value
- * @param {ValueTypes|number} [typeHint] Hint for the expected final type (can be several types combined)
+ * @param {ValueTypes|number} [expectedType] Expected final type (can be several types combined)
+ * If omitted, defaults to ValueTypes.NUMBER
  * @return {string} GLSL-compatible output
  */
-export function expressionToGlsl(context, value, typeHint) {
+export function expressionToGlsl(context, value, expectedType) {
+  const returnType =
+    expectedType !== undefined ? expectedType : ValueTypes.NUMBER;
   // operator
   if (Array.isArray(value) && typeof value[0] === 'string') {
     const operator = Operators[value[0]];
@@ -283,41 +342,39 @@ export function expressionToGlsl(context, value, typeHint) {
         `Unrecognized expression operator: ${JSON.stringify(value)}`
       );
     }
-    return operator.toGlsl(context, value.slice(1), typeHint);
+    return operator.toGlsl(context, value.slice(1), returnType);
   }
 
-  const valueType = getValueType(value);
-  if ((valueType & ValueTypes.NUMBER) > 0) {
+  const possibleType = getValueType(value) & returnType;
+  assertNotEmptyType(value, possibleType, '');
+
+  if ((possibleType & ValueTypes.NUMBER) > 0) {
     return numberToGlsl(/** @type {number} */ (value));
   }
 
-  if ((valueType & ValueTypes.BOOLEAN) > 0) {
+  if ((possibleType & ValueTypes.BOOLEAN) > 0) {
     return value.toString();
   }
 
-  if (
-    (valueType & ValueTypes.STRING) > 0 &&
-    (typeHint === undefined || typeHint == ValueTypes.STRING)
-  ) {
+  if ((possibleType & ValueTypes.STRING) > 0) {
     return stringToGlsl(context, value.toString());
   }
 
-  if (
-    (valueType & ValueTypes.COLOR) > 0 &&
-    (typeHint === undefined || typeHint == ValueTypes.COLOR)
-  ) {
+  if ((possibleType & ValueTypes.COLOR) > 0) {
     return colorToGlsl(/** @type {Array<number> | string} */ (value));
   }
 
-  if ((valueType & ValueTypes.NUMBER_ARRAY) > 0) {
+  if ((possibleType & ValueTypes.NUMBER_ARRAY) > 0) {
     return arrayToGlsl(/** @type {Array<number>} */ (value));
   }
 
-  throw new Error(`Unexpected expression ${value} (expected type ${typeHint})`);
+  throw new Error(
+    `Unexpected expression ${value} (expected type ${printTypes(returnType)})`
+  );
 }
 
 function assertNumber(value) {
-  if (!(getValueType(value) & ValueTypes.NUMBER)) {
+  if ((getValueType(value) & ValueTypes.NUMBER) === 0) {
     throw new Error(
       `A numeric value was expected, got ${JSON.stringify(value)} instead`
     );
@@ -329,14 +386,14 @@ function assertNumbers(values) {
   }
 }
 function assertString(value) {
-  if (!(getValueType(value) & ValueTypes.STRING)) {
+  if ((getValueType(value) & ValueTypes.STRING) === 0) {
     throw new Error(
       `A string value was expected, got ${JSON.stringify(value)} instead`
     );
   }
 }
 function assertBoolean(value) {
-  if (!(getValueType(value) & ValueTypes.BOOLEAN)) {
+  if ((getValueType(value) & ValueTypes.BOOLEAN) === 0) {
     throw new Error(
       `A boolean value was expected, got ${JSON.stringify(value)} instead`
     );
@@ -366,40 +423,81 @@ function assertArgsMaxCount(args, count) {
 function assertArgsEven(args) {
   if (args.length % 2 !== 0) {
     throw new Error(
-      `An even amount of arguments was expected, got ${args} instead`
+      `An even amount of arguments was expected, got ${JSON.stringify(
+        args
+      )} instead`
     );
   }
 }
 function assertArgsOdd(args) {
   if (args.length % 2 === 0) {
     throw new Error(
-      `An odd amount of arguments was expected, got ${args} instead`
+      `An odd amount of arguments was expected, got ${JSON.stringify(
+        args
+      )} instead`
     );
   }
 }
-function assertUniqueInferredType(args, types) {
-  if (!isTypeUnique(types)) {
+function assertNotEmptyType(args, types, descriptor) {
+  if (types === ValueTypes.NONE) {
     throw new Error(
-      `Could not infer only one type from the following expression: ${JSON.stringify(
+      `No matching type was found for the following expression ${descriptor}: ${JSON.stringify(
         args
       )}`
     );
   }
 }
+function assertSingleType(args, types, descriptor) {
+  assertNotEmptyType(args, types, descriptor);
+  if (!isTypeUnique(types)) {
+    throw new Error(
+      `Expected to have a unique type for the following expression ${descriptor}: ${JSON.stringify(
+        args
+      )}
+Got the following types instead: ${printTypes(types)}`
+    );
+  }
+}
+function assertOfType(args, types, expectedTypes, descriptor) {
+  if ((types & expectedTypes) === ValueTypes.NONE) {
+    throw new Error(
+      `Expected the ${descriptor} type of the following expression: ${JSON.stringify(
+        args
+      )} to be of the following types: ${printTypes(expectedTypes)}
+Got these types instead: ${printTypes(types)}`
+    );
+  }
+}
 
 Operators['get'] = {
   getReturnType: function (args) {
+    if (args.length === 2) {
+      const hint = args[1];
+      return getTypeFromHint(/** @type {string} */ (hint));
+    }
     return ValueTypes.ANY;
   },
-  toGlsl: function (context, args) {
-    assertArgsCount(args, 1);
+  toGlsl: function (context, args, expectedType) {
+    assertArgsMinCount(args, 1);
+    assertArgsMaxCount(args, 2);
     assertString(args[0]);
-    const value = args[0].toString();
-    if (!context.attributes.includes(value)) {
-      context.attributes.push(value);
+    const outputType = expectedType & Operators['get'].getReturnType(args);
+    assertSingleType(['get', ...args], outputType, '');
+    const name = args[0].toString();
+    const existing = context.attributes.find((a) => a.name === name);
+    if (!existing) {
+      context.attributes.push({
+        name: name,
+        type: outputType,
+      });
+    } else if (outputType !== existing.type) {
+      throw new Error(
+        `The following attribute was used in different places with incompatible types: ${name}
+Types were: ${printTypes(existing.type)} and ${printTypes(outputType)}`
+      );
     }
     const prefix = context.inFragmentShader ? 'v_' : 'a_';
-    return prefix + value;
+    return prefix + name;
   },
 };
 
@@ -413,17 +511,37 @@ export function uniformNameForVariable(variableName) {
 }
 
 Operators['var'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.ANY;
   },
-  toGlsl: function (context, args) {
+  toGlsl: function (context, args, expectedType) {
     assertArgsCount(args, 1);
     assertString(args[0]);
-    const value = args[0].toString();
-    if (!context.variables.includes(value)) {
-      context.variables.push(value);
+    const name = args[0].toString();
+    if (
+      !context.style.variables ||
+      context.style.variables[name] === undefined
+    ) {
+      throw new Error(
+        `The following variable is missing from the style: ${name}`
+      );
     }
-    return uniformNameForVariable(value);
+    const initialValue = context.style.variables[name];
+    const outputType = expectedType & getValueType(initialValue);
+    assertSingleType(['var', ...args], outputType, '');
+    const existing = context.variables.find((a) => a.name === name);
+    if (!existing) {
+      context.variables.push({
+        name: name,
+        type: outputType,
+      });
+    } else if (outputType !== existing.type) {
+      throw new Error(
+        `The following variable was used in different places with incompatible types: ${name}
+Types were: ${printTypes(existing.type)} and ${printTypes(outputType)}`
+      );
+    }
+    return uniformNameForVariable(name);
   },
 };
 
@@ -431,7 +549,7 @@ export const PALETTE_TEXTURE_ARRAY = 'u_paletteTextures';
 
 // ['palette', index, colors]
 Operators['palette'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.COLOR;
   },
   toGlsl: function (context, args) {
@@ -489,7 +607,7 @@ Operators['palette'] = {
 const GET_BAND_VALUE_FUNC = 'getBandValue';
 
 Operators['band'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -532,7 +650,7 @@ Operators['band'] = {
 };
 
 Operators['time'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -542,7 +660,7 @@ Operators['time'] = {
 };
 
 Operators['zoom'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -552,7 +670,7 @@ Operators['zoom'] = {
 };
 
 Operators['resolution'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -563,17 +681,32 @@ Operators['resolution'] = {
 
 Operators['*'] = {
   getReturnType: function (args) {
-    return ValueTypes.NUMBER;
+    let outputType = ValueTypes.NUMBER | ValueTypes.COLOR;
+    for (let i = 0; i < args.length; i++) {
+      outputType = outputType & getValueType(args[i]);
+    }
+    return outputType;
   },
-  toGlsl: function (context, args) {
+  toGlsl: function (context, args, expectedType) {
     assertArgsMinCount(args, 2);
-    assertNumbers(args);
-    return `(${args.map((arg) => expressionToGlsl(context, arg)).join(' * ')})`;
+    let outputType = expectedType;
+    for (let i = 0; i < args.length; i++) {
+      outputType = outputType & getValueType(args[i]);
+    }
+    assertOfType(
+      args,
+      outputType,
+      ValueTypes.NUMBER | ValueTypes.COLOR,
+      'output'
+    );
+    return `(${args
+      .map((arg) => expressionToGlsl(context, arg, outputType))
+      .join(' * ')})`;
   },
 };
 
 Operators['/'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -587,19 +720,18 @@ Operators['/'] = {
 };
 
 Operators['+'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
     assertArgsMinCount(args, 2);
     assertNumbers(args);
-
     return `(${args.map((arg) => expressionToGlsl(context, arg)).join(' + ')})`;
   },
 };
 
 Operators['-'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -613,7 +745,7 @@ Operators['-'] = {
 };
 
 Operators['clamp'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -626,7 +758,7 @@ Operators['clamp'] = {
 };
 
 Operators['%'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -640,7 +772,7 @@ Operators['%'] = {
 };
 
 Operators['^'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -654,7 +786,7 @@ Operators['^'] = {
 };
 
 Operators['abs'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -665,7 +797,7 @@ Operators['abs'] = {
 };
 
 Operators['floor'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -676,7 +808,7 @@ Operators['floor'] = {
 };
 
 Operators['round'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -687,7 +819,7 @@ Operators['round'] = {
 };
 
 Operators['ceil'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -698,7 +830,7 @@ Operators['ceil'] = {
 };
 
 Operators['sin'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -709,7 +841,7 @@ Operators['sin'] = {
 };
 
 Operators['cos'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -720,7 +852,7 @@ Operators['cos'] = {
 };
 
 Operators['atan'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER;
   },
   toGlsl: function (context, args) {
@@ -737,7 +869,7 @@ Operators['atan'] = {
 };
 
 Operators['>'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.BOOLEAN;
   },
   toGlsl: function (context, args) {
@@ -751,7 +883,7 @@ Operators['>'] = {
 };
 
 Operators['>='] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.BOOLEAN;
   },
   toGlsl: function (context, args) {
@@ -765,7 +897,7 @@ Operators['>='] = {
 };
 
 Operators['<'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.BOOLEAN;
   },
   toGlsl: function (context, args) {
@@ -779,7 +911,7 @@ Operators['<'] = {
 };
 
 Operators['<='] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.BOOLEAN;
   },
   toGlsl: function (context, args) {
@@ -794,7 +926,7 @@ Operators['<='] = {
 
 function getEqualOperator(operator) {
   return {
-    getReturnType: function (args) {
+    getReturnType: function () {
       return ValueTypes.BOOLEAN;
     },
     toGlsl: function (context, args) {
@@ -831,19 +963,19 @@ Operators['=='] = getEqualOperator('==');
 Operators['!='] = getEqualOperator('!=');
 
 Operators['!'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.BOOLEAN;
   },
   toGlsl: function (context, args) {
     assertArgsCount(args, 1);
     assertBoolean(args[0]);
-    return `(!${expressionToGlsl(context, args[0])})`;
+    return `(!${expressionToGlsl(context, args[0], ValueTypes.BOOLEAN)})`;
   },
 };
 
 function getDecisionOperator(operator) {
   return {
-    getReturnType: function (args) {
+    getReturnType: function () {
       return ValueTypes.BOOLEAN;
     },
     toGlsl: function (context, args) {
@@ -851,9 +983,8 @@ function getDecisionOperator(operator) {
       for (let i = 0; i < args.length; i++) {
         assertBoolean(args[i]);
       }
-      let result = '';
-      result = args
-        .map((arg) => expressionToGlsl(context, arg))
+      let result = args
+        .map((arg) => expressionToGlsl(context, arg, ValueTypes.BOOLEAN))
         .join(` ${operator} `);
       result = `(${result})`;
       return result;
@@ -866,7 +997,7 @@ Operators['all'] = getDecisionOperator('&&');
 Operators['any'] = getDecisionOperator('||');
 
 Operators['between'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.BOOLEAN;
   },
   toGlsl: function (context, args) {
@@ -880,7 +1011,7 @@ Operators['between'] = {
 };
 
 Operators['array'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.NUMBER_ARRAY;
   },
   toGlsl: function (context, args) {
@@ -888,31 +1019,28 @@ Operators['array'] = {
     assertArgsMaxCount(args, 4);
     assertNumbers(args);
     const parsedArgs = args.map(function (val) {
-      return expressionToGlsl(context, val, ValueTypes.NUMBER);
+      return expressionToGlsl(context, val);
     });
     return `vec${args.length}(${parsedArgs.join(', ')})`;
   },
 };
 
 Operators['color'] = {
-  getReturnType: function (args) {
+  getReturnType: function () {
     return ValueTypes.COLOR;
   },
   toGlsl: function (context, args) {
     assertArgsMinCount(args, 3);
     assertArgsMaxCount(args, 4);
     assertNumbers(args);
-    const array = /** @type {Array<number>} */ (args);
+    const parsedArgs = args
+      .slice(0, 3)
+      .map((val) => `${expressionToGlsl(context, val)} / 255.0`);
     if (args.length === 3) {
-      array.push(1);
+      return `vec4(${parsedArgs.join(', ')}, 1.0)`;
     }
-    const parsedArgs = args.map(function (val, i) {
-      return (
-        expressionToGlsl(context, val, ValueTypes.NUMBER) +
-        (i < 3 ? ' / 255.0' : '')
-      );
-    });
-    return `vec${args.length}(${parsedArgs.join(', ')})`;
+    const alpha = expressionToGlsl(context, args[3]);
+    return `(${alpha} * vec4(${parsedArgs.join(', ')}, 1.0))`;
   },
 };
 
@@ -924,7 +1052,7 @@ Operators['interpolate'] = {
     }
     return type;
   },
-  toGlsl: function (context, args, typeHint) {
+  toGlsl: function (context, args, expectedType) {
     assertArgsEven(args);
     assertArgsMinCount(args, 6);
 
@@ -950,19 +1078,20 @@ Operators['interpolate'] = {
     }
 
     // compute input/output types
-    typeHint = typeHint !== undefined ? typeHint : ValueTypes.ANY;
-    const outputType = Operators['interpolate'].getReturnType(args) & typeHint;
-    assertUniqueInferredType(args, outputType);
+    const inputType = ValueTypes.NUMBER;
+    const outputType =
+      Operators['interpolate'].getReturnType(args) & expectedType;
+    assertSingleType(['interpolate', ...args], outputType, 'output');
 
-    const input = expressionToGlsl(context, args[1]);
+    const input = expressionToGlsl(context, args[1], inputType);
     const exponent = numberToGlsl(interpolation);
 
     let result = '';
     for (let i = 2; i < args.length - 2; i += 2) {
-      const stop1 = expressionToGlsl(context, args[i]);
+      const stop1 = expressionToGlsl(context, args[i], inputType);
       const output1 =
         result || expressionToGlsl(context, args[i + 1], outputType);
-      const stop2 = expressionToGlsl(context, args[i + 2]);
+      const stop2 = expressionToGlsl(context, args[i + 2], inputType);
       const output2 = expressionToGlsl(context, args[i + 3], outputType);
       result = `mix(${output1}, ${output2}, pow(clamp((${input} - ${stop1}) / (${stop2} - ${stop1}), 0.0, 1.0), ${exponent}))`;
     }
@@ -979,15 +1108,27 @@ Operators['match'] = {
     type = type & getValueType(args[args.length - 1]);
     return type;
   },
-  toGlsl: function (context, args, typeHint) {
+  toGlsl: function (context, args, expectedType) {
     assertArgsEven(args);
     assertArgsMinCount(args, 4);
 
-    typeHint = typeHint !== undefined ? typeHint : ValueTypes.ANY;
-    const outputType = Operators['match'].getReturnType(args) & typeHint;
-    assertUniqueInferredType(args, outputType);
+    let inputType = getValueType(args[0]);
+    for (let i = 1; i < args.length - 1; i += 2) {
+      inputType = inputType & getValueType(args[i]);
+    }
+    assertOfType(
+      ['match', ...args],
+      inputType,
+      ValueTypes.STRING | ValueTypes.NUMBER | ValueTypes.BOOLEAN,
+      'input'
+    );
+    inputType =
+      (ValueTypes.STRING | ValueTypes.NUMBER | ValueTypes.BOOLEAN) & inputType;
+
+    const outputType = Operators['match'].getReturnType(args) & expectedType;
+    assertSingleType(['match', ...args], outputType, 'output');
 
-    const input = expressionToGlsl(context, args[0]);
+    const input = expressionToGlsl(context, args[0], inputType);
     const fallback = expressionToGlsl(
       context,
       args[args.length - 1],
@@ -995,7 +1136,7 @@ Operators['match'] = {
     );
     let result = null;
     for (let i = args.length - 3; i >= 1; i -= 2) {
-      const match = expressionToGlsl(context, args[i]);
+      const match = expressionToGlsl(context, args[i], inputType);
       const output = expressionToGlsl(context, args[i + 1], outputType);
       result = `(${input} == ${match} ? ${output} : ${result || fallback})`;
     }
@@ -1012,13 +1153,12 @@ Operators['case'] = {
     type = type & getValueType(args[args.length - 1]);
     return type;
   },
-  toGlsl: function (context, args, typeHint) {
+  toGlsl: function (context, args, expectedType) {
     assertArgsOdd(args);
     assertArgsMinCount(args, 3);
 
-    typeHint = typeHint !== undefined ? typeHint : ValueTypes.ANY;
-    const outputType = Operators['case'].getReturnType(args) & typeHint;
-    assertUniqueInferredType(args, outputType);
+    const outputType = Operators['case'].getReturnType(args) & expectedType;
+    assertSingleType(['case', ...args], outputType, 'output');
     for (let i = 0; i < args.length - 1; i += 2) {
       assertBoolean(args[i]);
     }
@@ -1030,7 +1170,7 @@ Operators['case'] = {
     );
     let result = null;
     for (let i = args.length - 3; i >= 0; i -= 2) {
-      const condition = expressionToGlsl(context, args[i]);
+      const condition = expressionToGlsl(context, args[i], ValueTypes.BOOLEAN);
       const output = expressionToGlsl(context, args[i + 1], outputType);
       result = `(${condition} ? ${output} : ${result || fallback})`;
     }