diff --git a/examples/style-rules.js b/examples/style-rules.js
index 143a10caf9..eafea47bd7 100644
--- a/examples/style-rules.js
+++ b/examples/style-rules.js
@@ -2,7 +2,7 @@ goog.require('ol.Map');
 goog.require('ol.RendererHint');
 goog.require('ol.View2D');
 goog.require('ol.control.defaults');
-goog.require('ol.expression');
+goog.require('ol.expr');
 goog.require('ol.layer.Vector');
 goog.require('ol.parser.GeoJSON');
 goog.require('ol.proj');
@@ -19,7 +19,7 @@ var style = new ol.style.Style({rules: [
     filter: 'where == "outer"',
     symbolizers: [
       new ol.style.Line({
-        strokeColor: ol.expression.parse('color'),
+        strokeColor: ol.expr.parse('color'),
         strokeWidth: 4,
         opacity: 1
       })
@@ -34,7 +34,7 @@ var style = new ol.style.Style({rules: [
         opacity: 1
       }),
       new ol.style.Line({
-        strokeColor: ol.expression.parse('color'),
+        strokeColor: ol.expr.parse('color'),
         strokeWidth: 2,
         opacity: 1
       })
@@ -49,7 +49,7 @@ var style = new ol.style.Style({rules: [
       }),
       new ol.style.Text({
         color: '#bada55',
-        text: ol.expression.parse('label'),
+        text: ol.expr.parse('label'),
         fontFamily: 'Calibri,sans-serif',
         fontSize: 14
       })
diff --git a/examples/vector-layer.js b/examples/vector-layer.js
index 62ee037394..05774f56f5 100644
--- a/examples/vector-layer.js
+++ b/examples/vector-layer.js
@@ -1,7 +1,7 @@
 goog.require('ol.Map');
 goog.require('ol.RendererHint');
 goog.require('ol.View2D');
-goog.require('ol.expression');
+goog.require('ol.expr');
 goog.require('ol.layer.TileLayer');
 goog.require('ol.layer.Vector');
 goog.require('ol.parser.GeoJSON');
@@ -19,7 +19,7 @@ var raster = new ol.layer.TileLayer({
 });
 
 // TODO: discuss scale dependent rules
-ol.expression.register('resolution', function() {
+ol.expr.register('resolution', function() {
   return map.getView().getView2D().getResolution();
 });
 
@@ -40,7 +40,7 @@ var vector = new ol.layer.Vector({
       symbolizers: [
         new ol.style.Text({
           color: '#bada55',
-          text: ol.expression.parse('name'),
+          text: ol.expr.parse('name'),
           fontFamily: 'Calibri,sans-serif',
           fontSize: 12
         })
diff --git a/src/objectliterals.jsdoc b/src/objectliterals.jsdoc
index 6e246e5180..5ef74a191b 100644
--- a/src/objectliterals.jsdoc
+++ b/src/objectliterals.jsdoc
@@ -519,54 +519,54 @@
 
 /**
  * @typedef {Object} ol.style.IconOptions
- * @property {string|ol.expression.Expression} url Icon image url.
- * @property {number|ol.expression.Expression|undefined} width Width of the icon
+ * @property {string|ol.expr.Expression} url Icon image url.
+ * @property {number|ol.expr.Expression|undefined} width Width of the icon
  *     in pixels.  Default is the width of the icon image.
- * @property {number|ol.expression.Expression|undefined} height Height of the
+ * @property {number|ol.expr.Expression|undefined} height Height of the
  *     icon in pixels. Default is the height of the icon image.
- * @property {number|ol.expression.Expression|undefined} opacity Icon opacity
+ * @property {number|ol.expr.Expression|undefined} opacity Icon opacity
  *     (0-1).
- * @property {number|ol.expression.Expression|undefined} rotation Rotation in
+ * @property {number|ol.expr.Expression|undefined} rotation Rotation in
  *     degrees (0-360).
  */
 
 /**
  * @typedef {Object} ol.style.LineOptions
- * @property {string|ol.expression.Expression|undefined} strokeColor Stroke
+ * @property {string|ol.expr.Expression|undefined} strokeColor Stroke
  *     color as hex color code.
- * @property {number|ol.expression.Expression|undefined} strokeWidth Stroke
+ * @property {number|ol.expr.Expression|undefined} strokeWidth Stroke
  *     width in pixels.
- * @property {number|ol.expression.Expression|undefined} opacity Opacity (0-1).
+ * @property {number|ol.expr.Expression|undefined} opacity Opacity (0-1).
  */
 
 /**
  * @typedef {Object} ol.style.PolygonOptions
- * @property {string|ol.expression.Expression|undefined} fillColor Fill color as
+ * @property {string|ol.expr.Expression|undefined} fillColor Fill color as
  *     hex color code.
- * @property {string|ol.expression.Expression|undefined} strokeColor Stroke
+ * @property {string|ol.expr.Expression|undefined} strokeColor Stroke
  *     color as hex color code.
- * @property {number|ol.expression.Expression|undefined} strokeWidth Stroke
+ * @property {number|ol.expr.Expression|undefined} strokeWidth Stroke
  *     width in pixels.
- * @property {number|ol.expression.Expression|undefined} opacity Opacity (0-1).
+ * @property {number|ol.expr.Expression|undefined} opacity Opacity (0-1).
  */
 
 /**
  * @typedef {Object} ol.style.RuleOptions
- * @property {ol.expression.Expression|string|undefined} filter Filter.
+ * @property {ol.expr.Expression|string|undefined} filter Filter.
  * @property {Array.<ol.style.Symbolizer>|undefined} symbolizers Symbolizers.
  */
 
 /**
  * @typedef {Object} ol.style.ShapeOptions
  * @property {ol.style.ShapeType|undefined} type Type.
- * @property {number|ol.expression.Expression|undefined} size Size in pixels.
- * @property {string|ol.expression.Expression|undefined} fillColor Fill color as
+ * @property {number|ol.expr.Expression|undefined} size Size in pixels.
+ * @property {string|ol.expr.Expression|undefined} fillColor Fill color as
  *     hex color code.
- * @property {string|ol.expression.Expression|undefined} strokeColor Stroke
+ * @property {string|ol.expr.Expression|undefined} strokeColor Stroke
  *     color as hex color code.
- * @property {number|ol.expression.Expression|undefined} strokeWidth Stroke
+ * @property {number|ol.expr.Expression|undefined} strokeWidth Stroke
  *     width in pixels.
- * @property {number|ol.expression.Expression|undefined} opacity Opacity (0-1).
+ * @property {number|ol.expr.Expression|undefined} opacity Opacity (0-1).
  */
 
 /**
@@ -576,11 +576,11 @@
 
 /**
  * @typedef {Object} ol.style.TextOptions
- * @property {string|ol.expression.Expression|undefined} color Color.
- * @property {string|ol.expression.Expression|undefined} fontFamily Font family.
- * @property {number|ol.expression.Expression|undefined} fontSize Font size in pixels.
- * @property {string|ol.expression.Expression} text Text for the label.
- * @property {number|ol.expression.Expression|undefined} opacity Opacity (0-1).
+ * @property {string|ol.expr.Expression|undefined} color Color.
+ * @property {string|ol.expr.Expression|undefined} fontFamily Font family.
+ * @property {number|ol.expr.Expression|undefined} fontSize Font size in pixels.
+ * @property {string|ol.expr.Expression} text Text for the label.
+ * @property {number|ol.expr.Expression|undefined} opacity Opacity (0-1).
  */
 
 /**
diff --git a/src/ol/expr.jsdoc b/src/ol/expr.jsdoc
new file mode 100644
index 0000000000..3147c2784e
--- /dev/null
+++ b/src/ol/expr.jsdoc
@@ -0,0 +1,3 @@
+/**
+ * @namespace ol.expr
+ */
diff --git a/src/ol/expr/expression.exports b/src/ol/expr/expression.exports
new file mode 100644
index 0000000000..14b6f57d46
--- /dev/null
+++ b/src/ol/expr/expression.exports
@@ -0,0 +1,2 @@
+@exportSymbol ol.expr.parse
+@exportSymbol ol.expr.register
diff --git a/src/ol/expression/expression.js b/src/ol/expr/expression.js
similarity index 71%
rename from src/ol/expression/expression.js
rename to src/ol/expr/expression.js
index 388317e9d3..8a60e5b2ad 100644
--- a/src/ol/expression/expression.js
+++ b/src/ol/expr/expression.js
@@ -1,29 +1,29 @@
-goog.provide('ol.expression');
+goog.provide('ol.expr');
 
 goog.require('ol.Extent');
 goog.require('ol.Feature');
-goog.require('ol.expression.Call');
-goog.require('ol.expression.Expression');
-goog.require('ol.expression.Identifier');
-goog.require('ol.expression.Parser');
+goog.require('ol.expr.Call');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Identifier');
+goog.require('ol.expr.Parser');
 goog.require('ol.extent');
 goog.require('ol.geom.GeometryType');
 
 
 /**
  * Evaluate an expression with a feature.  The feature attributes will be used
- * as the evaluation scope.  The `ol.expression.lib` functions will be used as
+ * as the evaluation scope.  The `ol.expr.lib` functions will be used as
  * function scope.  The feature itself will be used as the `this` argument.
  *
- * @param {ol.expression.Expression} expr The expression.
+ * @param {ol.expr.Expression} expr The expression.
  * @param {ol.Feature=} opt_feature The feature.
  * @return {*} The result of the expression.
  */
-ol.expression.evaluateFeature = function(expr, opt_feature) {
+ol.expr.evaluateFeature = function(expr, opt_feature) {
   var result;
   if (goog.isDef(opt_feature)) {
     result = expr.evaluate(
-        opt_feature.getAttributes(), ol.expression.lib, opt_feature);
+        opt_feature.getAttributes(), ol.expr.lib, opt_feature);
   } else {
     result = expr.evaluate();
   }
@@ -34,11 +34,11 @@ ol.expression.evaluateFeature = function(expr, opt_feature) {
 /**
  * Parse an expression.
  * @param {string} source The expression source (e.g. `'foo + 2'`).
- * @return {ol.expression.Expression} An expression instance that can be
+ * @return {ol.expr.Expression} An expression instance that can be
  *     evaluated within some scope to provide a value.
  */
-ol.expression.parse = function(source) {
-  var parser = new ol.expression.Parser();
+ol.expr.parse = function(source) {
+  var parser = new ol.expr.Parser();
   return parser.parse(source);
 };
 
@@ -50,27 +50,27 @@ ol.expression.parse = function(source) {
  *     expression.  This function will be called with a feature as the `this`
  *     argument when the expression is evaluated in the context of a features.
  */
-ol.expression.register = function(name, func) {
-  ol.expression.lib[name] = func;
+ol.expr.register = function(name, func) {
+  ol.expr.lib[name] = func;
 };
 
 
 /**
  * Determines whether an expression is a call expression that calls one of the
- * `ol.expression.lib` functions.
+ * `ol.expr.lib` functions.
  *
- * @param {ol.expression.Expression} expr The candidate expression.
+ * @param {ol.expr.Expression} expr The candidate expression.
  * @return {string|undefined} If the candidate expression is a call to a lib
  * function, the return will be the function name.  If not, the return will be
  * `undefined`.
  */
-ol.expression.isLibCall = function(expr) {
+ol.expr.isLibCall = function(expr) {
   var name;
-  if (expr instanceof ol.expression.Call) {
+  if (expr instanceof ol.expr.Call) {
     var callee = expr.getCallee();
-    if (callee instanceof ol.expression.Identifier) {
+    if (callee instanceof ol.expr.Identifier) {
       name = callee.getName();
-      if (!ol.expression.lib.hasOwnProperty(name)) {
+      if (!ol.expr.lib.hasOwnProperty(name)) {
         name = undefined;
       }
     }
@@ -81,11 +81,11 @@ ol.expression.isLibCall = function(expr) {
 
 /**
  * Library of well-known functions.  These are available to expressions parsed
- * with `ol.expression.parse`.
+ * with `ol.expr.parse`.
  *
  * @type {Object}
  */
-ol.expression.lib = {
+ol.expr.lib = {
 
   /**
    * Determine if a feature's extent intersects the provided extent.
diff --git a/src/ol/expression/expressions.js b/src/ol/expr/expressions.js
similarity index 54%
rename from src/ol/expression/expressions.js
rename to src/ol/expr/expressions.js
index a37ade846d..0b1d716f3c 100644
--- a/src/ol/expression/expressions.js
+++ b/src/ol/expr/expressions.js
@@ -1,20 +1,20 @@
-goog.provide('ol.expression.Call');
-goog.provide('ol.expression.Comparison');
-goog.provide('ol.expression.ComparisonOp');
-goog.provide('ol.expression.Expression');
-goog.provide('ol.expression.Identifier');
-goog.provide('ol.expression.Literal');
-goog.provide('ol.expression.Logical');
-goog.provide('ol.expression.LogicalOp');
-goog.provide('ol.expression.Math');
-goog.provide('ol.expression.MathOp');
-goog.provide('ol.expression.Member');
-goog.provide('ol.expression.Not');
+goog.provide('ol.expr.Call');
+goog.provide('ol.expr.Comparison');
+goog.provide('ol.expr.ComparisonOp');
+goog.provide('ol.expr.Expression');
+goog.provide('ol.expr.Identifier');
+goog.provide('ol.expr.Literal');
+goog.provide('ol.expr.Logical');
+goog.provide('ol.expr.LogicalOp');
+goog.provide('ol.expr.Math');
+goog.provide('ol.expr.MathOp');
+goog.provide('ol.expr.Member');
+goog.provide('ol.expr.Not');
 
 
 
 /**
- * Base class for all expressions.  Instances of ol.expression.Expression
+ * Base class for all expressions.  Instances of ol.expr.Expression
  * correspond to a limited set of ECMAScript 5.1 expressions.
  * http://www.ecma-international.org/ecma-262/5.1/#sec-11
  *
@@ -23,7 +23,7 @@ goog.provide('ol.expression.Not');
  *
  * @constructor
  */
-ol.expression.Expression = function() {};
+ol.expr.Expression = function() {};
 
 
 /**
@@ -38,7 +38,7 @@ ol.expression.Expression = function() {};
  *     expressions.  If not provided, `this` will resolve to a new object.
  * @return {*} Result of the expression.
  */
-ol.expression.Expression.prototype.evaluate = goog.abstractMethod;
+ol.expr.Expression.prototype.evaluate = goog.abstractMethod;
 
 
 
@@ -46,33 +46,33 @@ ol.expression.Expression.prototype.evaluate = goog.abstractMethod;
  * A call expression (e.g. `foo(bar)`).
  *
  * @constructor
- * @extends {ol.expression.Expression}
- * @param {ol.expression.Expression} callee An expression that resolves to a
+ * @extends {ol.expr.Expression}
+ * @param {ol.expr.Expression} callee An expression that resolves to a
  *     function.
- * @param {Array.<ol.expression.Expression>} args Arguments.
+ * @param {Array.<ol.expr.Expression>} args Arguments.
  */
-ol.expression.Call = function(callee, args) {
+ol.expr.Call = function(callee, args) {
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.callee_ = callee;
 
   /**
-   * @type {Array.<ol.expression.Expression>}
+   * @type {Array.<ol.expr.Expression>}
    * @private
    */
   this.args_ = args;
 
 };
-goog.inherits(ol.expression.Call, ol.expression.Expression);
+goog.inherits(ol.expr.Call, ol.expr.Expression);
 
 
 /**
  * @inheritDoc
  */
-ol.expression.Call.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
+ol.expr.Call.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
   var fnScope = goog.isDefAndNotNull(opt_fns) ? opt_fns : opt_scope;
   var fn = this.callee_.evaluate(fnScope);
   if (!fn || !goog.isFunction(fn)) {
@@ -91,18 +91,18 @@ ol.expression.Call.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
 
 /**
  * Get the argument list.
- * @return {Array.<ol.expression.Expression>} The argument.
+ * @return {Array.<ol.expr.Expression>} The argument.
  */
-ol.expression.Call.prototype.getArgs = function() {
+ol.expr.Call.prototype.getArgs = function() {
   return this.args_;
 };
 
 
 /**
  * Get the callee expression.
- * @return {ol.expression.Expression} The callee expression.
+ * @return {ol.expr.Expression} The callee expression.
  */
-ol.expression.Call.prototype.getCallee = function() {
+ol.expr.Call.prototype.getCallee = function() {
   return this.callee_;
 };
 
@@ -110,7 +110,7 @@ ol.expression.Call.prototype.getCallee = function() {
 /**
  * @enum {string}
  */
-ol.expression.ComparisonOp = {
+ol.expr.ComparisonOp = {
   EQ: '==',
   NEQ: '!=',
   STRICT_EQ: '===',
@@ -127,33 +127,33 @@ ol.expression.ComparisonOp = {
  * A comparison expression (e.g. `foo >= 42`, `bar != "chicken"`).
  *
  * @constructor
- * @extends {ol.expression.Expression}
- * @param {ol.expression.ComparisonOp} operator Comparison operator.
- * @param {ol.expression.Expression} left Left expression.
- * @param {ol.expression.Expression} right Right expression.
+ * @extends {ol.expr.Expression}
+ * @param {ol.expr.ComparisonOp} operator Comparison operator.
+ * @param {ol.expr.Expression} left Left expression.
+ * @param {ol.expr.Expression} right Right expression.
  */
-ol.expression.Comparison = function(operator, left, right) {
+ol.expr.Comparison = function(operator, left, right) {
 
   /**
-   * @type {ol.expression.ComparisonOp}
+   * @type {ol.expr.ComparisonOp}
    * @private
    */
   this.operator_ = operator;
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.left_ = left;
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.right_ = right;
 
 };
-goog.inherits(ol.expression.Comparison, ol.expression.Expression);
+goog.inherits(ol.expr.Comparison, ol.expr.Expression);
 
 
 /**
@@ -161,10 +161,10 @@ goog.inherits(ol.expression.Comparison, ol.expression.Expression);
  * @param {string} candidate Operator to test.
  * @return {boolean} The operator is valid.
  */
-ol.expression.Comparison.isValidOp = (function() {
+ol.expr.Comparison.isValidOp = (function() {
   var valid = {};
-  for (var key in ol.expression.ComparisonOp) {
-    valid[ol.expression.ComparisonOp[key]] = true;
+  for (var key in ol.expr.ComparisonOp) {
+    valid[ol.expr.ComparisonOp[key]] = true;
   }
   return function isValidOp(candidate) {
     return !!valid[candidate];
@@ -175,35 +175,35 @@ ol.expression.Comparison.isValidOp = (function() {
 /**
  * @inheritDoc
  */
-ol.expression.Comparison.prototype.evaluate = function(opt_scope, opt_fns,
+ol.expr.Comparison.prototype.evaluate = function(opt_scope, opt_fns,
     opt_this) {
   var result;
   var rightVal = this.right_.evaluate(opt_scope, opt_fns, opt_this);
   var leftVal = this.left_.evaluate(opt_scope, opt_fns, opt_this);
 
   switch (this.operator_) {
-    case ol.expression.ComparisonOp.EQ:
+    case ol.expr.ComparisonOp.EQ:
       result = leftVal == rightVal;
       break;
-    case ol.expression.ComparisonOp.NEQ:
+    case ol.expr.ComparisonOp.NEQ:
       result = leftVal != rightVal;
       break;
-    case ol.expression.ComparisonOp.STRICT_EQ:
+    case ol.expr.ComparisonOp.STRICT_EQ:
       result = leftVal === rightVal;
       break;
-    case ol.expression.ComparisonOp.STRICT_NEQ:
+    case ol.expr.ComparisonOp.STRICT_NEQ:
       result = leftVal !== rightVal;
       break;
-    case ol.expression.ComparisonOp.GT:
+    case ol.expr.ComparisonOp.GT:
       result = leftVal > rightVal;
       break;
-    case ol.expression.ComparisonOp.LT:
+    case ol.expr.ComparisonOp.LT:
       result = leftVal < rightVal;
       break;
-    case ol.expression.ComparisonOp.GTE:
+    case ol.expr.ComparisonOp.GTE:
       result = leftVal >= rightVal;
       break;
-    case ol.expression.ComparisonOp.LTE:
+    case ol.expr.ComparisonOp.LTE:
       result = leftVal <= rightVal;
       break;
     default:
@@ -217,25 +217,25 @@ ol.expression.Comparison.prototype.evaluate = function(opt_scope, opt_fns,
  * Get the comparison operator.
  * @return {string} The comparison operator.
  */
-ol.expression.Comparison.prototype.getOperator = function() {
+ol.expr.Comparison.prototype.getOperator = function() {
   return this.operator_;
 };
 
 
 /**
  * Get the left expression.
- * @return {ol.expression.Expression} The left expression.
+ * @return {ol.expr.Expression} The left expression.
  */
-ol.expression.Comparison.prototype.getLeft = function() {
+ol.expr.Comparison.prototype.getLeft = function() {
   return this.left_;
 };
 
 
 /**
  * Get the right expression.
- * @return {ol.expression.Expression} The right expression.
+ * @return {ol.expr.Expression} The right expression.
  */
-ol.expression.Comparison.prototype.getRight = function() {
+ol.expr.Comparison.prototype.getRight = function() {
   return this.right_;
 };
 
@@ -245,10 +245,10 @@ ol.expression.Comparison.prototype.getRight = function() {
  * An identifier expression (e.g. `foo`).
  *
  * @constructor
- * @extends {ol.expression.Expression}
+ * @extends {ol.expr.Expression}
  * @param {string} name An identifier name.
  */
-ol.expression.Identifier = function(name) {
+ol.expr.Identifier = function(name) {
 
   /**
    * @type {string}
@@ -257,13 +257,13 @@ ol.expression.Identifier = function(name) {
   this.name_ = name;
 
 };
-goog.inherits(ol.expression.Identifier, ol.expression.Expression);
+goog.inherits(ol.expr.Identifier, ol.expr.Expression);
 
 
 /**
  * @inheritDoc
  */
-ol.expression.Identifier.prototype.evaluate = function(opt_scope) {
+ol.expr.Identifier.prototype.evaluate = function(opt_scope) {
   if (!goog.isDefAndNotNull(opt_scope)) {
     throw new Error('Attempt to evaluate identifier with no scope');
   }
@@ -275,7 +275,7 @@ ol.expression.Identifier.prototype.evaluate = function(opt_scope) {
  * Get the identifier name.
  * @return {string} The identifier name.
  */
-ol.expression.Identifier.prototype.getName = function() {
+ol.expr.Identifier.prototype.getName = function() {
   return this.name_;
 };
 
@@ -285,10 +285,10 @@ ol.expression.Identifier.prototype.getName = function() {
  * A literal expression (e.g. `"chicken"`, `42`, `true`, `null`).
  *
  * @constructor
- * @extends {ol.expression.Expression}
+ * @extends {ol.expr.Expression}
  * @param {string|number|boolean|null} value A literal value.
  */
-ol.expression.Literal = function(value) {
+ol.expr.Literal = function(value) {
 
   /**
    * @type {string|number|boolean|null}
@@ -297,13 +297,13 @@ ol.expression.Literal = function(value) {
   this.value_ = value;
 
 };
-goog.inherits(ol.expression.Literal, ol.expression.Expression);
+goog.inherits(ol.expr.Literal, ol.expr.Expression);
 
 
 /**
  * @inheritDoc
  */
-ol.expression.Literal.prototype.evaluate = function() {
+ol.expr.Literal.prototype.evaluate = function() {
   return this.value_;
 };
 
@@ -312,7 +312,7 @@ ol.expression.Literal.prototype.evaluate = function() {
  * Get the literal value.
  * @return {string|number|boolean|null} The literal value.
  */
-ol.expression.Literal.prototype.getValue = function() {
+ol.expr.Literal.prototype.getValue = function() {
   return this.value_;
 };
 
@@ -320,7 +320,7 @@ ol.expression.Literal.prototype.getValue = function() {
 /**
  * @enum {string}
  */
-ol.expression.LogicalOp = {
+ol.expr.LogicalOp = {
   AND: '&&',
   OR: '||'
 };
@@ -331,33 +331,33 @@ ol.expression.LogicalOp = {
  * A binary logical expression (e.g. `foo && bar`, `bar || "chicken"`).
  *
  * @constructor
- * @extends {ol.expression.Expression}
- * @param {ol.expression.LogicalOp} operator Logical operator.
- * @param {ol.expression.Expression} left Left expression.
- * @param {ol.expression.Expression} right Right expression.
+ * @extends {ol.expr.Expression}
+ * @param {ol.expr.LogicalOp} operator Logical operator.
+ * @param {ol.expr.Expression} left Left expression.
+ * @param {ol.expr.Expression} right Right expression.
  */
-ol.expression.Logical = function(operator, left, right) {
+ol.expr.Logical = function(operator, left, right) {
 
   /**
-   * @type {ol.expression.LogicalOp}
+   * @type {ol.expr.LogicalOp}
    * @private
    */
   this.operator_ = operator;
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.left_ = left;
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.right_ = right;
 
 };
-goog.inherits(ol.expression.Logical, ol.expression.Expression);
+goog.inherits(ol.expr.Logical, ol.expr.Expression);
 
 
 /**
@@ -365,10 +365,10 @@ goog.inherits(ol.expression.Logical, ol.expression.Expression);
  * @param {string} candidate Operator to test.
  * @return {boolean} The operator is valid.
  */
-ol.expression.Logical.isValidOp = (function() {
+ol.expr.Logical.isValidOp = (function() {
   var valid = {};
-  for (var key in ol.expression.LogicalOp) {
-    valid[ol.expression.LogicalOp[key]] = true;
+  for (var key in ol.expr.LogicalOp) {
+    valid[ol.expr.LogicalOp[key]] = true;
   }
   return function isValidOp(candidate) {
     return !!valid[candidate];
@@ -379,15 +379,15 @@ ol.expression.Logical.isValidOp = (function() {
 /**
  * @inheritDoc
  */
-ol.expression.Logical.prototype.evaluate = function(opt_scope, opt_fns,
+ol.expr.Logical.prototype.evaluate = function(opt_scope, opt_fns,
     opt_this) {
   var result;
   var rightVal = this.right_.evaluate(opt_scope, opt_fns, opt_this);
   var leftVal = this.left_.evaluate(opt_scope, opt_fns, opt_this);
 
-  if (this.operator_ === ol.expression.LogicalOp.AND) {
+  if (this.operator_ === ol.expr.LogicalOp.AND) {
     result = leftVal && rightVal;
-  } else if (this.operator_ === ol.expression.LogicalOp.OR) {
+  } else if (this.operator_ === ol.expr.LogicalOp.OR) {
     result = leftVal || rightVal;
   } else {
     throw new Error('Unsupported logical operator: ' + this.operator_);
@@ -400,25 +400,25 @@ ol.expression.Logical.prototype.evaluate = function(opt_scope, opt_fns,
  * Get the logical operator.
  * @return {string} The logical operator.
  */
-ol.expression.Logical.prototype.getOperator = function() {
+ol.expr.Logical.prototype.getOperator = function() {
   return this.operator_;
 };
 
 
 /**
  * Get the left expression.
- * @return {ol.expression.Expression} The left expression.
+ * @return {ol.expr.Expression} The left expression.
  */
-ol.expression.Logical.prototype.getLeft = function() {
+ol.expr.Logical.prototype.getLeft = function() {
   return this.left_;
 };
 
 
 /**
  * Get the right expression.
- * @return {ol.expression.Expression} The right expression.
+ * @return {ol.expr.Expression} The right expression.
  */
-ol.expression.Logical.prototype.getRight = function() {
+ol.expr.Logical.prototype.getRight = function() {
   return this.right_;
 };
 
@@ -426,7 +426,7 @@ ol.expression.Logical.prototype.getRight = function() {
 /**
  * @enum {string}
  */
-ol.expression.MathOp = {
+ol.expr.MathOp = {
   ADD: '+',
   SUBTRACT: '-',
   MULTIPLY: '*',
@@ -440,33 +440,33 @@ ol.expression.MathOp = {
  * A math expression (e.g. `foo + 42`, `bar % 10`).
  *
  * @constructor
- * @extends {ol.expression.Expression}
- * @param {ol.expression.MathOp} operator Math operator.
- * @param {ol.expression.Expression} left Left expression.
- * @param {ol.expression.Expression} right Right expression.
+ * @extends {ol.expr.Expression}
+ * @param {ol.expr.MathOp} operator Math operator.
+ * @param {ol.expr.Expression} left Left expression.
+ * @param {ol.expr.Expression} right Right expression.
  */
-ol.expression.Math = function(operator, left, right) {
+ol.expr.Math = function(operator, left, right) {
 
   /**
-   * @type {ol.expression.MathOp}
+   * @type {ol.expr.MathOp}
    * @private
    */
   this.operator_ = operator;
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.left_ = left;
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.right_ = right;
 
 };
-goog.inherits(ol.expression.Math, ol.expression.Expression);
+goog.inherits(ol.expr.Math, ol.expr.Expression);
 
 
 /**
@@ -474,10 +474,10 @@ goog.inherits(ol.expression.Math, ol.expression.Expression);
  * @param {string} candidate Operator to test.
  * @return {boolean} The operator is valid.
  */
-ol.expression.Math.isValidOp = (function() {
+ol.expr.Math.isValidOp = (function() {
   var valid = {};
-  for (var key in ol.expression.MathOp) {
-    valid[ol.expression.MathOp[key]] = true;
+  for (var key in ol.expr.MathOp) {
+    valid[ol.expr.MathOp[key]] = true;
   }
   return function isValidOp(candidate) {
     return !!valid[candidate];
@@ -488,7 +488,7 @@ ol.expression.Math.isValidOp = (function() {
 /**
  * @inheritDoc
  */
-ol.expression.Math.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
+ol.expr.Math.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
   var result;
   var rightVal = this.right_.evaluate(opt_scope, opt_fns, opt_this);
   var leftVal = this.left_.evaluate(opt_scope, opt_fns, opt_this);
@@ -499,19 +499,19 @@ ol.expression.Math.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
    */
 
   switch (this.operator_) {
-    case ol.expression.MathOp.ADD:
+    case ol.expr.MathOp.ADD:
       result = leftVal + rightVal;
       break;
-    case ol.expression.MathOp.SUBTRACT:
+    case ol.expr.MathOp.SUBTRACT:
       result = Number(leftVal) - Number(rightVal);
       break;
-    case ol.expression.MathOp.MULTIPLY:
+    case ol.expr.MathOp.MULTIPLY:
       result = Number(leftVal) * Number(rightVal);
       break;
-    case ol.expression.MathOp.DIVIDE:
+    case ol.expr.MathOp.DIVIDE:
       result = Number(leftVal) / Number(rightVal);
       break;
-    case ol.expression.MathOp.MOD:
+    case ol.expr.MathOp.MOD:
       result = Number(leftVal) % Number(rightVal);
       break;
     default:
@@ -525,25 +525,25 @@ ol.expression.Math.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
  * Get the math operator.
  * @return {string} The math operator.
  */
-ol.expression.Math.prototype.getOperator = function() {
+ol.expr.Math.prototype.getOperator = function() {
   return this.operator_;
 };
 
 
 /**
  * Get the left expression.
- * @return {ol.expression.Expression} The left expression.
+ * @return {ol.expr.Expression} The left expression.
  */
-ol.expression.Math.prototype.getLeft = function() {
+ol.expr.Math.prototype.getLeft = function() {
   return this.left_;
 };
 
 
 /**
  * Get the right expression.
- * @return {ol.expression.Expression} The right expression.
+ * @return {ol.expr.Expression} The right expression.
  */
-ol.expression.Math.prototype.getRight = function() {
+ol.expr.Math.prototype.getRight = function() {
   return this.right_;
 };
 
@@ -553,33 +553,33 @@ ol.expression.Math.prototype.getRight = function() {
  * A member expression (e.g. `foo.bar`).
  *
  * @constructor
- * @extends {ol.expression.Expression}
- * @param {ol.expression.Expression} object An expression that resolves to an
+ * @extends {ol.expr.Expression}
+ * @param {ol.expr.Expression} object An expression that resolves to an
  *     object.
- * @param {ol.expression.Identifier} property Identifier with name of property.
+ * @param {ol.expr.Identifier} property Identifier with name of property.
  */
-ol.expression.Member = function(object, property) {
+ol.expr.Member = function(object, property) {
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.object_ = object;
 
   /**
-   * @type {ol.expression.Identifier}
+   * @type {ol.expr.Identifier}
    * @private
    */
   this.property_ = property;
 
 };
-goog.inherits(ol.expression.Member, ol.expression.Expression);
+goog.inherits(ol.expr.Member, ol.expr.Expression);
 
 
 /**
  * @inheritDoc
  */
-ol.expression.Member.prototype.evaluate = function(opt_scope, opt_fns,
+ol.expr.Member.prototype.evaluate = function(opt_scope, opt_fns,
     opt_this) {
   var obj = this.object_.evaluate(opt_scope, opt_fns, opt_this);
   if (!goog.isObject(obj)) {
@@ -592,18 +592,18 @@ ol.expression.Member.prototype.evaluate = function(opt_scope, opt_fns,
 
 /**
  * Get the object expression.
- * @return {ol.expression.Expression} The object.
+ * @return {ol.expr.Expression} The object.
  */
-ol.expression.Member.prototype.getObject = function() {
+ol.expr.Member.prototype.getObject = function() {
   return this.object_;
 };
 
 
 /**
  * Get the property expression.
- * @return {ol.expression.Identifier} The property.
+ * @return {ol.expr.Identifier} The property.
  */
-ol.expression.Member.prototype.getProperty = function() {
+ol.expr.Member.prototype.getProperty = function() {
   return this.property_;
 };
 
@@ -613,33 +613,33 @@ ol.expression.Member.prototype.getProperty = function() {
  * A logical not expression (e.g. `!foo`).
  *
  * @constructor
- * @extends {ol.expression.Expression}
- * @param {ol.expression.Expression} argument Expression to negate.
+ * @extends {ol.expr.Expression}
+ * @param {ol.expr.Expression} argument Expression to negate.
  */
-ol.expression.Not = function(argument) {
+ol.expr.Not = function(argument) {
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.argument_ = argument;
 
 };
-goog.inherits(ol.expression.Not, ol.expression.Expression);
+goog.inherits(ol.expr.Not, ol.expr.Expression);
 
 
 /**
  * @inheritDoc
  */
-ol.expression.Not.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
+ol.expr.Not.prototype.evaluate = function(opt_scope, opt_fns, opt_this) {
   return !this.argument_.evaluate(opt_scope, opt_fns, opt_this);
 };
 
 
 /**
  * Get the argument (the negated expression).
- * @return {ol.expression.Expression} The argument.
+ * @return {ol.expr.Expression} The argument.
  */
-ol.expression.Not.prototype.getArgument = function() {
+ol.expr.Not.prototype.getArgument = function() {
   return this.argument_;
 };
diff --git a/src/ol/expression/lexer.js b/src/ol/expr/lexer.js
similarity index 67%
rename from src/ol/expression/lexer.js
rename to src/ol/expr/lexer.js
index 4389997290..c1af520c34 100644
--- a/src/ol/expression/lexer.js
+++ b/src/ol/expr/lexer.js
@@ -13,11 +13,11 @@
  * Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
  */
 
-goog.provide('ol.expression.Char'); // TODO: remove this - see #785
-goog.provide('ol.expression.Lexer');
-goog.provide('ol.expression.Token');
-goog.provide('ol.expression.TokenType');
-goog.provide('ol.expression.UnexpectedToken');
+goog.provide('ol.expr.Char'); // TODO: remove this - see #785
+goog.provide('ol.expr.Lexer');
+goog.provide('ol.expr.Token');
+goog.provide('ol.expr.TokenType');
+goog.provide('ol.expr.UnexpectedToken');
 
 goog.require('goog.asserts');
 goog.require('goog.debug.Error');
@@ -26,7 +26,7 @@ goog.require('goog.debug.Error');
 /**
  * @enum {number}
  */
-ol.expression.Char = {
+ol.expr.Char = {
   AMPERSAND: 38,
   BACKSLASH: 92,
   BANG: 33, // !
@@ -76,7 +76,7 @@ ol.expression.Char = {
 /**
  * @enum {string}
  */
-ol.expression.TokenType = {
+ol.expr.TokenType = {
   BOOLEAN_LITERAL: 'Boolean',
   EOF: '<end>',
   IDENTIFIER: 'Identifier',
@@ -90,11 +90,11 @@ ol.expression.TokenType = {
 
 
 /**
- * @typedef {{type: (ol.expression.TokenType),
+ * @typedef {{type: (ol.expr.TokenType),
  *            value: (string|number|boolean|null),
  *            index: (number)}}
  */
-ol.expression.Token;
+ol.expr.Token;
 
 
 
@@ -105,7 +105,7 @@ ol.expression.Token;
  * @constructor
  * @param {string} source Source code.
  */
-ol.expression.Lexer = function(source) {
+ol.expr.Lexer = function(source) {
 
   /**
    * Source code.
@@ -142,11 +142,11 @@ ol.expression.Lexer = function(source) {
  * Scan the next token and throw if it isn't a punctuator that matches input.
  * @param {string} value Token value.
  */
-ol.expression.Lexer.prototype.expect = function(value) {
+ol.expr.Lexer.prototype.expect = function(value) {
   var match = this.match(value);
   if (!match) {
-    throw new ol.expression.UnexpectedToken({
-      type: ol.expression.TokenType.UNKNOWN,
+    throw new ol.expr.UnexpectedToken({
+      type: ol.expr.TokenType.UNKNOWN,
       value: this.getCurrentChar_(),
       index: this.index_
     });
@@ -161,7 +161,7 @@ ol.expression.Lexer.prototype.expect = function(value) {
  * @param {number} delta Delta by which the index is advanced.
  * @private
  */
-ol.expression.Lexer.prototype.increment_ = function(delta) {
+ol.expr.Lexer.prototype.increment_ = function(delta) {
   this.index_ += delta;
 };
 
@@ -173,10 +173,10 @@ ol.expression.Lexer.prototype.increment_ = function(delta) {
  * @return {boolean} The character is a decimal digit.
  * @private
  */
-ol.expression.Lexer.prototype.isDecimalDigit_ = function(code) {
+ol.expr.Lexer.prototype.isDecimalDigit_ = function(code) {
   return (
-      code >= ol.expression.Char.DIGIT_0 &&
-      code <= ol.expression.Char.DIGIT_9);
+      code >= ol.expr.Char.DIGIT_0 &&
+      code <= ol.expr.Char.DIGIT_9);
 };
 
 
@@ -187,7 +187,7 @@ ol.expression.Lexer.prototype.isDecimalDigit_ = function(code) {
  * @return {boolean} The identifier is a future reserved word.
  * @private
  */
-ol.expression.Lexer.prototype.isFutureReservedWord_ = function(id) {
+ol.expr.Lexer.prototype.isFutureReservedWord_ = function(id) {
   return (
       id === 'class' ||
       id === 'enum' ||
@@ -205,12 +205,12 @@ ol.expression.Lexer.prototype.isFutureReservedWord_ = function(id) {
  * @return {boolean} The character is a hex digit.
  * @private
  */
-ol.expression.Lexer.prototype.isHexDigit_ = function(code) {
+ol.expr.Lexer.prototype.isHexDigit_ = function(code) {
   return this.isDecimalDigit_(code) ||
-      (code >= ol.expression.Char.LOWER_A &&
-          code <= ol.expression.Char.LOWER_F) ||
-      (code >= ol.expression.Char.UPPER_A &&
-          code <= ol.expression.Char.UPPER_F);
+      (code >= ol.expr.Char.LOWER_A &&
+          code <= ol.expr.Char.LOWER_F) ||
+      (code >= ol.expr.Char.UPPER_A &&
+          code <= ol.expr.Char.UPPER_F);
 };
 
 
@@ -222,10 +222,10 @@ ol.expression.Lexer.prototype.isHexDigit_ = function(code) {
  * @return {boolean} The character is a valid identifier part.
  * @private
  */
-ol.expression.Lexer.prototype.isIdentifierPart_ = function(code) {
+ol.expr.Lexer.prototype.isIdentifierPart_ = function(code) {
   return this.isIdentifierStart_(code) ||
-      (code >= ol.expression.Char.DIGIT_0 &&
-          code <= ol.expression.Char.DIGIT_9);
+      (code >= ol.expr.Char.DIGIT_0 &&
+          code <= ol.expr.Char.DIGIT_9);
 };
 
 
@@ -237,20 +237,20 @@ ol.expression.Lexer.prototype.isIdentifierPart_ = function(code) {
  * @return {boolean} The character is a valid identifier start.
  * @private
  */
-ol.expression.Lexer.prototype.isIdentifierStart_ = function(code) {
-  return (code === ol.expression.Char.DOLLAR) ||
-      (code === ol.expression.Char.UNDERSCORE) ||
-      (code >= ol.expression.Char.UPPER_A &&
-          code <= ol.expression.Char.UPPER_Z) ||
-      (code >= ol.expression.Char.LOWER_A &&
-          code <= ol.expression.Char.LOWER_Z);
+ol.expr.Lexer.prototype.isIdentifierStart_ = function(code) {
+  return (code === ol.expr.Char.DOLLAR) ||
+      (code === ol.expr.Char.UNDERSCORE) ||
+      (code >= ol.expr.Char.UPPER_A &&
+          code <= ol.expr.Char.UPPER_Z) ||
+      (code >= ol.expr.Char.LOWER_A &&
+          code <= ol.expr.Char.LOWER_Z);
 };
 
 
 /**
  * Determine if the given identifier is an ECMAScript keyword.  These cannot
  * be used as identifiers in programs.  There is no real reason these could not
- * be used in ol expressions - but they are reserved for future use.
+ * be used in ol.exprs - but they are reserved for future use.
  *
  * http://www.ecma-international.org/ecma-262/5.1/#sec-7.6.1.1
  *
@@ -258,7 +258,7 @@ ol.expression.Lexer.prototype.isIdentifierStart_ = function(code) {
  * @return {boolean} The identifier is a keyword.
  * @private
  */
-ol.expression.Lexer.prototype.isKeyword_ = function(id) {
+ol.expr.Lexer.prototype.isKeyword_ = function(id) {
   return (
       id === 'break' ||
       id === 'case' ||
@@ -296,11 +296,11 @@ ol.expression.Lexer.prototype.isKeyword_ = function(id) {
  * @return {boolean} The character is a line terminator.
  * @private
  */
-ol.expression.Lexer.prototype.isLineTerminator_ = function(code) {
-  return (code === ol.expression.Char.LINE_FEED) ||
-      (code === ol.expression.Char.CARRIAGE_RETURN) ||
-      (code === ol.expression.Char.LINE_SEPARATOR) ||
-      (code === ol.expression.Char.PARAGRAPH_SEPARATOR);
+ol.expr.Lexer.prototype.isLineTerminator_ = function(code) {
+  return (code === ol.expr.Char.LINE_FEED) ||
+      (code === ol.expr.Char.CARRIAGE_RETURN) ||
+      (code === ol.expr.Char.LINE_SEPARATOR) ||
+      (code === ol.expr.Char.PARAGRAPH_SEPARATOR);
 };
 
 
@@ -311,10 +311,10 @@ ol.expression.Lexer.prototype.isLineTerminator_ = function(code) {
  * @return {boolean} The character is an octal digit.
  * @private
  */
-ol.expression.Lexer.prototype.isOctalDigit_ = function(code) {
+ol.expr.Lexer.prototype.isOctalDigit_ = function(code) {
   return (
-      code >= ol.expression.Char.DIGIT_0 &&
-      code <= ol.expression.Char.DIGIT_7);
+      code >= ol.expr.Char.DIGIT_0 &&
+      code <= ol.expr.Char.DIGIT_7);
 };
 
 
@@ -325,12 +325,12 @@ ol.expression.Lexer.prototype.isOctalDigit_ = function(code) {
  * @return {boolean} The character is whitespace.
  * @private
  */
-ol.expression.Lexer.prototype.isWhitespace_ = function(code) {
-  return (code === ol.expression.Char.SPACE) ||
-      (code === ol.expression.Char.TAB) ||
-      (code === ol.expression.Char.VERTICAL_TAB) ||
-      (code === ol.expression.Char.FORM_FEED) ||
-      (code === ol.expression.Char.NONBREAKING_SPACE) ||
+ol.expr.Lexer.prototype.isWhitespace_ = function(code) {
+  return (code === ol.expr.Char.SPACE) ||
+      (code === ol.expr.Char.TAB) ||
+      (code === ol.expr.Char.VERTICAL_TAB) ||
+      (code === ol.expr.Char.FORM_FEED) ||
+      (code === ol.expr.Char.NONBREAKING_SPACE) ||
       (code >= 0x1680 && '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005' +
           '\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF'
           .indexOf(String.fromCharCode(code)) > 0);
@@ -344,7 +344,7 @@ ol.expression.Lexer.prototype.isWhitespace_ = function(code) {
  * @return {number} The character code.
  * @private
  */
-ol.expression.Lexer.prototype.getCharCode_ = function(delta) {
+ol.expr.Lexer.prototype.getCharCode_ = function(delta) {
   return this.source_.charCodeAt(this.index_ + delta);
 };
 
@@ -355,7 +355,7 @@ ol.expression.Lexer.prototype.getCharCode_ = function(delta) {
  * @return {string} The current character.
  * @private
  */
-ol.expression.Lexer.prototype.getCurrentChar_ = function() {
+ol.expr.Lexer.prototype.getCurrentChar_ = function() {
   return this.source_[this.index_];
 };
 
@@ -366,7 +366,7 @@ ol.expression.Lexer.prototype.getCurrentChar_ = function() {
  * @return {number} The current character code.
  * @private
  */
-ol.expression.Lexer.prototype.getCurrentCharCode_ = function() {
+ol.expr.Lexer.prototype.getCurrentCharCode_ = function() {
   return this.getCharCode_(0);
 };
 
@@ -376,10 +376,10 @@ ol.expression.Lexer.prototype.getCurrentCharCode_ = function() {
  * @param {string} value Punctuator value.
  * @return {boolean} The token matches.
  */
-ol.expression.Lexer.prototype.match = function(value) {
+ol.expr.Lexer.prototype.match = function(value) {
   var token = this.peek();
   return (
-      token.type === ol.expression.TokenType.PUNCTUATOR &&
+      token.type === ol.expr.TokenType.PUNCTUATOR &&
       token.value === value);
 };
 
@@ -387,28 +387,28 @@ ol.expression.Lexer.prototype.match = function(value) {
 /**
  * Scan the next token.
  *
- * @return {ol.expression.Token} Next token.
+ * @return {ol.expr.Token} Next token.
  */
-ol.expression.Lexer.prototype.next = function() {
+ol.expr.Lexer.prototype.next = function() {
   var code = this.skipWhitespace_();
 
   if (this.index_ >= this.length_) {
     return {
-      type: ol.expression.TokenType.EOF,
+      type: ol.expr.TokenType.EOF,
       value: null,
       index: this.index_
     };
   }
 
   // check for common punctuation
-  if (code === ol.expression.Char.LEFT_PAREN ||
-      code === ol.expression.Char.RIGHT_PAREN) {
+  if (code === ol.expr.Char.LEFT_PAREN ||
+      code === ol.expr.Char.RIGHT_PAREN) {
     return this.scanPunctuator_(code);
   }
 
   // check for string literal
-  if (code === ol.expression.Char.SINGLE_QUOTE ||
-      code === ol.expression.Char.DOUBLE_QUOTE) {
+  if (code === ol.expr.Char.SINGLE_QUOTE ||
+      code === ol.expr.Char.DOUBLE_QUOTE) {
     return this.scanStringLiteral_(code);
   }
 
@@ -418,7 +418,7 @@ ol.expression.Lexer.prototype.next = function() {
   }
 
   // check dot punctuation or decimal
-  if (code === ol.expression.Char.DOT) {
+  if (code === ol.expr.Char.DOT) {
     if (this.isDecimalDigit_(this.getCharCode_(1))) {
       return this.scanNumericLiteral_(code);
     }
@@ -438,9 +438,9 @@ ol.expression.Lexer.prototype.next = function() {
 /**
  * Peek at the next token, but don't advance the index.
  *
- * @return {ol.expression.Token} The upcoming token.
+ * @return {ol.expr.Token} The upcoming token.
  */
-ol.expression.Lexer.prototype.peek = function() {
+ol.expr.Lexer.prototype.peek = function() {
   var currentIndex = this.index_;
   var token = this.next();
   this.nextIndex_ = this.index_;
@@ -453,10 +453,10 @@ ol.expression.Lexer.prototype.peek = function() {
  * Scan hex literal as numeric token.
  *
  * @param {number} code The current character code.
- * @return {ol.expression.Token} Numeric literal token.
+ * @return {ol.expr.Token} Numeric literal token.
  * @private
  */
-ol.expression.Lexer.prototype.scanHexLiteral_ = function(code) {
+ol.expr.Lexer.prototype.scanHexLiteral_ = function(code) {
   var str = '';
   var start = this.index_ - 2;
 
@@ -470,8 +470,8 @@ ol.expression.Lexer.prototype.scanHexLiteral_ = function(code) {
   }
 
   if (str.length === 0 || this.isIdentifierStart_(code)) {
-    throw new ol.expression.UnexpectedToken({
-      type: ol.expression.TokenType.UNKNOWN,
+    throw new ol.expr.UnexpectedToken({
+      type: ol.expr.TokenType.UNKNOWN,
       value: String.fromCharCode(code),
       index: this.index_
     });
@@ -480,7 +480,7 @@ ol.expression.Lexer.prototype.scanHexLiteral_ = function(code) {
   goog.asserts.assert(!isNaN(parseInt('0x' + str, 16)), 'Valid hex: ' + str);
 
   return {
-    type: ol.expression.TokenType.NUMERIC_LITERAL,
+    type: ol.expr.TokenType.NUMERIC_LITERAL,
     value: parseInt('0x' + str, 16),
     index: start
   };
@@ -491,10 +491,10 @@ ol.expression.Lexer.prototype.scanHexLiteral_ = function(code) {
  * Scan identifier token.
  *
  * @param {number} code The current character code.
- * @return {ol.expression.Token} Identifier token.
+ * @return {ol.expr.Token} Identifier token.
  * @private
  */
-ol.expression.Lexer.prototype.scanIdentifier_ = function(code) {
+ol.expr.Lexer.prototype.scanIdentifier_ = function(code) {
   goog.asserts.assert(this.isIdentifierStart_(code),
       'Must be called with a valid identifier');
 
@@ -513,15 +513,15 @@ ol.expression.Lexer.prototype.scanIdentifier_ = function(code) {
 
   var type;
   if (id.length === 1) {
-    type = ol.expression.TokenType.IDENTIFIER;
+    type = ol.expr.TokenType.IDENTIFIER;
   } else if (this.isKeyword_(id)) {
-    type = ol.expression.TokenType.KEYWORD;
+    type = ol.expr.TokenType.KEYWORD;
   } else if (id === 'null') {
-    type = ol.expression.TokenType.NULL_LITERAL;
+    type = ol.expr.TokenType.NULL_LITERAL;
   } else if (id === 'true' || id === 'false') {
-    type = ol.expression.TokenType.BOOLEAN_LITERAL;
+    type = ol.expr.TokenType.BOOLEAN_LITERAL;
   } else {
-    type = ol.expression.TokenType.IDENTIFIER;
+    type = ol.expr.TokenType.IDENTIFIER;
   }
 
   return {
@@ -537,26 +537,26 @@ ol.expression.Lexer.prototype.scanIdentifier_ = function(code) {
  * http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.3
  *
  * @param {number} code The current character code.
- * @return {ol.expression.Token} Numeric literal token.
+ * @return {ol.expr.Token} Numeric literal token.
  * @private
  */
-ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
+ol.expr.Lexer.prototype.scanNumericLiteral_ = function(code) {
   goog.asserts.assert(
-      code === ol.expression.Char.DOT || this.isDecimalDigit_(code),
+      code === ol.expr.Char.DOT || this.isDecimalDigit_(code),
       'Valid start for numeric literal: ' + String.fromCharCode(code));
 
   // start assembling numeric string
   var str = '';
   var start = this.index_;
 
-  if (code !== ol.expression.Char.DOT) {
+  if (code !== ol.expr.Char.DOT) {
 
-    if (code === ol.expression.Char.DIGIT_0) {
+    if (code === ol.expr.Char.DIGIT_0) {
       var nextCode = this.getCharCode_(1);
 
       // hex literals start with 0X or 0x
-      if (nextCode === ol.expression.Char.UPPER_X ||
-          nextCode === ol.expression.Char.LOWER_X) {
+      if (nextCode === ol.expr.Char.UPPER_X ||
+          nextCode === ol.expr.Char.LOWER_X) {
         this.increment_(2);
         return this.scanHexLiteral_(this.getCurrentCharCode_());
       }
@@ -569,8 +569,8 @@ ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
 
       // numbers like 09 not allowed
       if (this.isDecimalDigit_(nextCode)) {
-        throw new ol.expression.UnexpectedToken({
-          type: ol.expression.TokenType.UNKNOWN,
+        throw new ol.expr.UnexpectedToken({
+          type: ol.expr.TokenType.UNKNOWN,
           value: String.fromCharCode(nextCode),
           index: this.index_
         });
@@ -586,7 +586,7 @@ ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
   }
 
   // scan fractional part
-  if (code === ol.expression.Char.DOT) {
+  if (code === ol.expr.Char.DOT) {
     str += String.fromCharCode(code);
     this.increment_(1);
     code = this.getCurrentCharCode_();
@@ -600,22 +600,22 @@ ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
   }
 
   // scan exponent
-  if (code === ol.expression.Char.UPPER_E ||
-      code === ol.expression.Char.LOWER_E) {
+  if (code === ol.expr.Char.UPPER_E ||
+      code === ol.expr.Char.LOWER_E) {
     str += 'E';
     this.increment_(1);
 
     code = this.getCurrentCharCode_();
-    if (code === ol.expression.Char.PLUS ||
-        code === ol.expression.Char.MINUS) {
+    if (code === ol.expr.Char.PLUS ||
+        code === ol.expr.Char.MINUS) {
       str += String.fromCharCode(code);
       this.increment_(1);
       code = this.getCurrentCharCode_();
     }
 
     if (!this.isDecimalDigit_(code)) {
-      throw new ol.expression.UnexpectedToken({
-        type: ol.expression.TokenType.UNKNOWN,
+      throw new ol.expr.UnexpectedToken({
+        type: ol.expr.TokenType.UNKNOWN,
         value: String.fromCharCode(code),
         index: this.index_
       });
@@ -630,8 +630,8 @@ ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
   }
 
   if (this.isIdentifierStart_(code)) {
-    throw new ol.expression.UnexpectedToken({
-      type: ol.expression.TokenType.UNKNOWN,
+    throw new ol.expr.UnexpectedToken({
+      type: ol.expr.TokenType.UNKNOWN,
       value: String.fromCharCode(code),
       index: this.index_
     });
@@ -640,7 +640,7 @@ ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
   goog.asserts.assert(!isNaN(parseFloat(str)), 'Valid number: ' + str);
 
   return {
-    type: ol.expression.TokenType.NUMERIC_LITERAL,
+    type: ol.expr.TokenType.NUMERIC_LITERAL,
     value: parseFloat(str),
     index: start
   };
@@ -652,10 +652,10 @@ ol.expression.Lexer.prototype.scanNumericLiteral_ = function(code) {
  * Scan octal literal as numeric token.
  *
  * @param {number} code The current character code.
- * @return {ol.expression.Token} Numeric literal token.
+ * @return {ol.expr.Token} Numeric literal token.
  * @private
  */
-ol.expression.Lexer.prototype.scanOctalLiteral_ = function(code) {
+ol.expr.Lexer.prototype.scanOctalLiteral_ = function(code) {
   goog.asserts.assert(this.isOctalDigit_(code));
 
   var str = '0' + String.fromCharCode(code);
@@ -674,8 +674,8 @@ ol.expression.Lexer.prototype.scanOctalLiteral_ = function(code) {
   code = this.getCurrentCharCode_();
   if (this.isIdentifierStart_(code) ||
       this.isDecimalDigit_(code)) {
-    throw new ol.expression.UnexpectedToken({
-      type: ol.expression.TokenType.UNKNOWN,
+    throw new ol.expr.UnexpectedToken({
+      type: ol.expr.TokenType.UNKNOWN,
       value: String.fromCharCode(code),
       index: this.index_
     });
@@ -684,7 +684,7 @@ ol.expression.Lexer.prototype.scanOctalLiteral_ = function(code) {
   goog.asserts.assert(!isNaN(parseInt(str, 8)), 'Valid octal: ' + str);
 
   return {
-    type: ol.expression.TokenType.NUMERIC_LITERAL,
+    type: ol.expr.TokenType.NUMERIC_LITERAL,
     value: parseInt(str, 8),
     index: start
   };
@@ -695,28 +695,28 @@ ol.expression.Lexer.prototype.scanOctalLiteral_ = function(code) {
  * Scan punctuator token (a subset of allowed tokens in 7.7).
  *
  * @param {number} code The current character code.
- * @return {ol.expression.Token} Punctuator token.
+ * @return {ol.expr.Token} Punctuator token.
  * @private
  */
-ol.expression.Lexer.prototype.scanPunctuator_ = function(code) {
+ol.expr.Lexer.prototype.scanPunctuator_ = function(code) {
   var start = this.index_;
 
   // single char punctuation that also doesn't start longer punctuation
   // (we disallow assignment, so no += etc.)
-  if (code === ol.expression.Char.DOT ||
-      code === ol.expression.Char.LEFT_PAREN ||
-      code === ol.expression.Char.RIGHT_PAREN ||
-      code === ol.expression.Char.COMMA ||
-      code === ol.expression.Char.PLUS ||
-      code === ol.expression.Char.MINUS ||
-      code === ol.expression.Char.STAR ||
-      code === ol.expression.Char.SLASH ||
-      code === ol.expression.Char.PERCENT ||
-      code === ol.expression.Char.TILDE) {
+  if (code === ol.expr.Char.DOT ||
+      code === ol.expr.Char.LEFT_PAREN ||
+      code === ol.expr.Char.RIGHT_PAREN ||
+      code === ol.expr.Char.COMMA ||
+      code === ol.expr.Char.PLUS ||
+      code === ol.expr.Char.MINUS ||
+      code === ol.expr.Char.STAR ||
+      code === ol.expr.Char.SLASH ||
+      code === ol.expr.Char.PERCENT ||
+      code === ol.expr.Char.TILDE) {
 
     this.increment_(1);
     return {
-      type: ol.expression.TokenType.PUNCTUATOR,
+      type: ol.expr.TokenType.PUNCTUATOR,
       value: String.fromCharCode(code),
       index: start
     };
@@ -726,34 +726,34 @@ ol.expression.Lexer.prototype.scanPunctuator_ = function(code) {
   var nextCode = this.getCharCode_(1);
 
   // assignment or comparison (and we don't allow assignment)
-  if (nextCode === ol.expression.Char.EQUAL) {
-    if (code === ol.expression.Char.BANG || code === ol.expression.Char.EQUAL) {
+  if (nextCode === ol.expr.Char.EQUAL) {
+    if (code === ol.expr.Char.BANG || code === ol.expr.Char.EQUAL) {
       // we're looking at !=, ==, !==, or ===
       this.increment_(2);
 
       // check for triple
-      if (this.getCurrentCharCode_() === ol.expression.Char.EQUAL) {
+      if (this.getCurrentCharCode_() === ol.expr.Char.EQUAL) {
         this.increment_(1);
         return {
-          type: ol.expression.TokenType.PUNCTUATOR,
+          type: ol.expr.TokenType.PUNCTUATOR,
           value: String.fromCharCode(code) + '==',
           index: start
         };
       } else {
         // != or ==
         return {
-          type: ol.expression.TokenType.PUNCTUATOR,
+          type: ol.expr.TokenType.PUNCTUATOR,
           value: String.fromCharCode(code) + '=',
           index: start
         };
       }
     }
 
-    if (code === ol.expression.Char.GREATER ||
-        code === ol.expression.Char.LESS) {
+    if (code === ol.expr.Char.GREATER ||
+        code === ol.expr.Char.LESS) {
       this.increment_(2);
       return {
-        type: ol.expression.TokenType.PUNCTUATOR,
+        type: ol.expr.TokenType.PUNCTUATOR,
         value: String.fromCharCode(code) + '=',
         index: start
       };
@@ -762,13 +762,13 @@ ol.expression.Lexer.prototype.scanPunctuator_ = function(code) {
 
   // remaining 2-charcter punctuators are || and &&
   if (code === nextCode &&
-      (code === ol.expression.Char.PIPE ||
-          code === ol.expression.Char.AMPERSAND)) {
+      (code === ol.expr.Char.PIPE ||
+          code === ol.expr.Char.AMPERSAND)) {
 
     this.increment_(2);
     var str = String.fromCharCode(code);
     return {
-      type: ol.expression.TokenType.PUNCTUATOR,
+      type: ol.expr.TokenType.PUNCTUATOR,
       value: str + str,
       index: start
     };
@@ -778,22 +778,22 @@ ol.expression.Lexer.prototype.scanPunctuator_ = function(code) {
   // and the allowed 3-character punctuators (!==, ===) are already consumed
 
   // other single character punctuators
-  if (code === ol.expression.Char.GREATER ||
-      code === ol.expression.Char.LESS ||
-      code === ol.expression.Char.BANG ||
-      code === ol.expression.Char.AMPERSAND ||
-      code === ol.expression.Char.PIPE) {
+  if (code === ol.expr.Char.GREATER ||
+      code === ol.expr.Char.LESS ||
+      code === ol.expr.Char.BANG ||
+      code === ol.expr.Char.AMPERSAND ||
+      code === ol.expr.Char.PIPE) {
 
     this.increment_(1);
     return {
-      type: ol.expression.TokenType.PUNCTUATOR,
+      type: ol.expr.TokenType.PUNCTUATOR,
       value: String.fromCharCode(code),
       index: start
     };
   }
 
-  throw new ol.expression.UnexpectedToken({
-    type: ol.expression.TokenType.UNKNOWN,
+  throw new ol.expr.UnexpectedToken({
+    type: ol.expr.TokenType.UNKNOWN,
     value: String.fromCharCode(code),
     index: this.index_
   });
@@ -804,12 +804,12 @@ ol.expression.Lexer.prototype.scanPunctuator_ = function(code) {
  * Scan string literal token.
  *
  * @param {number} quote The current character code.
- * @return {ol.expression.Token} String literal token.
+ * @return {ol.expr.Token} String literal token.
  * @private
  */
-ol.expression.Lexer.prototype.scanStringLiteral_ = function(quote) {
-  goog.asserts.assert(quote === ol.expression.Char.SINGLE_QUOTE ||
-      quote === ol.expression.Char.DOUBLE_QUOTE,
+ol.expr.Lexer.prototype.scanStringLiteral_ = function(quote) {
+  goog.asserts.assert(quote === ol.expr.Char.SINGLE_QUOTE ||
+      quote === ol.expr.Char.DOUBLE_QUOTE,
       'Strings must start with a quote: ' + String.fromCharCode(quote));
 
   var start = this.index_;
@@ -825,7 +825,7 @@ ol.expression.Lexer.prototype.scanStringLiteral_ = function(quote) {
       break;
     }
     // look for escaped quote or backslash
-    if (code === ol.expression.Char.BACKSLASH) {
+    if (code === ol.expr.Char.BACKSLASH) {
       str += this.getCurrentChar_();
       this.increment_(1);
     } else {
@@ -835,11 +835,11 @@ ol.expression.Lexer.prototype.scanStringLiteral_ = function(quote) {
 
   if (quote !== 0) {
     // unterminated string literal
-    throw new ol.expression.UnexpectedToken(this.peek());
+    throw new ol.expr.UnexpectedToken(this.peek());
   }
 
   return {
-    type: ol.expression.TokenType.STRING_LITERAL,
+    type: ol.expr.TokenType.STRING_LITERAL,
     value: str,
     index: start
   };
@@ -849,7 +849,7 @@ ol.expression.Lexer.prototype.scanStringLiteral_ = function(quote) {
 /**
  * After peeking, skip may be called to advance the cursor without re-scanning.
  */
-ol.expression.Lexer.prototype.skip = function() {
+ol.expr.Lexer.prototype.skip = function() {
   this.index_ = this.nextIndex_;
 };
 
@@ -859,7 +859,7 @@ ol.expression.Lexer.prototype.skip = function() {
  * @return {number} The character code of the first non-whitespace character.
  * @private
  */
-ol.expression.Lexer.prototype.skipWhitespace_ = function() {
+ol.expr.Lexer.prototype.skipWhitespace_ = function() {
   var code = NaN;
   while (this.index_ < this.length_) {
     code = this.getCurrentCharCode_();
@@ -876,25 +876,25 @@ ol.expression.Lexer.prototype.skipWhitespace_ = function() {
 
 /**
  * Error object for unexpected tokens.
- * @param {ol.expression.Token} token The unexpected token.
+ * @param {ol.expr.Token} token The unexpected token.
  * @param {string=} opt_message Custom error message.
  * @constructor
  * @extends {goog.debug.Error}
  */
-ol.expression.UnexpectedToken = function(token, opt_message) {
+ol.expr.UnexpectedToken = function(token, opt_message) {
   var message = goog.isDef(opt_message) ? opt_message :
       'Unexpected token ' + token.value + ' at index ' + token.index;
 
   goog.debug.Error.call(this, message);
 
   /**
-   * @type {ol.expression.Token}
+   * @type {ol.expr.Token}
    */
   this.token = token;
 
 };
-goog.inherits(ol.expression.UnexpectedToken, goog.debug.Error);
+goog.inherits(ol.expr.UnexpectedToken, goog.debug.Error);
 
 
 /** @override */
-ol.expression.UnexpectedToken.prototype.name = 'UnexpectedToken';
+ol.expr.UnexpectedToken.prototype.name = 'UnexpectedToken';
diff --git a/src/ol/expression/parser.js b/src/ol/expr/parser.js
similarity index 57%
rename from src/ol/expression/parser.js
rename to src/ol/expr/parser.js
index 5b1544d496..042a5fc82f 100644
--- a/src/ol/expression/parser.js
+++ b/src/ol/expr/parser.js
@@ -13,31 +13,31 @@
  * Copyright (C) 2011 Ariya Hidayat <ariya.hidayat@gmail.com>
  */
 
-goog.provide('ol.expression.Parser');
+goog.provide('ol.expr.Parser');
 
 goog.require('goog.asserts');
 
-goog.require('ol.expression.Call');
-goog.require('ol.expression.Comparison');
-goog.require('ol.expression.ComparisonOp');
-goog.require('ol.expression.Expression');
-goog.require('ol.expression.Identifier');
-goog.require('ol.expression.Lexer');
-goog.require('ol.expression.Literal');
-goog.require('ol.expression.Logical');
-goog.require('ol.expression.LogicalOp');
-goog.require('ol.expression.Math');
-goog.require('ol.expression.MathOp');
-goog.require('ol.expression.Member');
-goog.require('ol.expression.Not');
-goog.require('ol.expression.Token');
-goog.require('ol.expression.TokenType');
-goog.require('ol.expression.UnexpectedToken');
+goog.require('ol.expr.Call');
+goog.require('ol.expr.Comparison');
+goog.require('ol.expr.ComparisonOp');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Identifier');
+goog.require('ol.expr.Lexer');
+goog.require('ol.expr.Literal');
+goog.require('ol.expr.Logical');
+goog.require('ol.expr.LogicalOp');
+goog.require('ol.expr.Math');
+goog.require('ol.expr.MathOp');
+goog.require('ol.expr.Member');
+goog.require('ol.expr.Not');
+goog.require('ol.expr.Token');
+goog.require('ol.expr.TokenType');
+goog.require('ol.expr.UnexpectedToken');
 
 
 
 /**
- * Instances of ol.expression.Parser parse a very limited set of ECMAScript
+ * Instances of ol.expr.Parser parse a very limited set of ECMAScript
  * expressions (http://www.ecma-international.org/ecma-262/5.1/#sec-11).
  *
  * - Primary Expression (11.1):
@@ -60,50 +60,50 @@ goog.require('ol.expression.UnexpectedToken');
  *
  * @constructor
  */
-ol.expression.Parser = function() {
+ol.expr.Parser = function() {
 };
 
 
 /**
  * Determine the precedence for the given token.
  *
- * @param {ol.expression.Token} token A token.
+ * @param {ol.expr.Token} token A token.
  * @return {number} The precedence for the given token.  Higher gets more
  *     precedence.
  * @private
  */
-ol.expression.Parser.prototype.binaryPrecedence_ = function(token) {
+ol.expr.Parser.prototype.binaryPrecedence_ = function(token) {
   var precedence = 0;
-  if (token.type !== ol.expression.TokenType.PUNCTUATOR) {
+  if (token.type !== ol.expr.TokenType.PUNCTUATOR) {
     return precedence;
   }
 
   switch (token.value) {
-    case ol.expression.LogicalOp.OR:
+    case ol.expr.LogicalOp.OR:
       precedence = 1;
       break;
-    case ol.expression.LogicalOp.AND:
+    case ol.expr.LogicalOp.AND:
       precedence = 2;
       break;
-    case ol.expression.ComparisonOp.EQ:
-    case ol.expression.ComparisonOp.NEQ:
-    case ol.expression.ComparisonOp.STRICT_EQ:
-    case ol.expression.ComparisonOp.STRICT_NEQ:
+    case ol.expr.ComparisonOp.EQ:
+    case ol.expr.ComparisonOp.NEQ:
+    case ol.expr.ComparisonOp.STRICT_EQ:
+    case ol.expr.ComparisonOp.STRICT_NEQ:
       precedence = 3;
       break;
-    case ol.expression.ComparisonOp.GT:
-    case ol.expression.ComparisonOp.LT:
-    case ol.expression.ComparisonOp.GTE:
-    case ol.expression.ComparisonOp.LTE:
+    case ol.expr.ComparisonOp.GT:
+    case ol.expr.ComparisonOp.LT:
+    case ol.expr.ComparisonOp.GTE:
+    case ol.expr.ComparisonOp.LTE:
       precedence = 4;
       break;
-    case ol.expression.MathOp.ADD:
-    case ol.expression.MathOp.SUBTRACT:
+    case ol.expr.MathOp.ADD:
+    case ol.expr.MathOp.SUBTRACT:
       precedence = 5;
       break;
-    case ol.expression.MathOp.MULTIPLY:
-    case ol.expression.MathOp.DIVIDE:
-    case ol.expression.MathOp.MOD:
+    case ol.expr.MathOp.MULTIPLY:
+    case ol.expr.MathOp.DIVIDE:
+    case ol.expr.MathOp.MOD:
       precedence = 6;
       break;
     default:
@@ -119,25 +119,25 @@ ol.expression.Parser.prototype.binaryPrecedence_ = function(token) {
  * Create a binary expression.
  *
  * @param {string} operator Operator.
- * @param {ol.expression.Expression} left Left expression.
- * @param {ol.expression.Expression} right Right expression.
- * @return {ol.expression.Expression} The expression.
+ * @param {ol.expr.Expression} left Left expression.
+ * @param {ol.expr.Expression} right Right expression.
+ * @return {ol.expr.Expression} The expression.
  * @private
  */
-ol.expression.Parser.prototype.createBinaryExpression_ = function(operator,
+ol.expr.Parser.prototype.createBinaryExpression_ = function(operator,
     left, right) {
   var expr;
-  if (ol.expression.Comparison.isValidOp(operator)) {
-    expr = new ol.expression.Comparison(
-        /** @type {ol.expression.ComparisonOp.<string>} */ (operator),
+  if (ol.expr.Comparison.isValidOp(operator)) {
+    expr = new ol.expr.Comparison(
+        /** @type {ol.expr.ComparisonOp.<string>} */ (operator),
         left, right);
-  } else if (ol.expression.Logical.isValidOp(operator)) {
-    expr = new ol.expression.Logical(
-        /** @type {ol.expression.LogicalOp.<string>} */ (operator),
+  } else if (ol.expr.Logical.isValidOp(operator)) {
+    expr = new ol.expr.Logical(
+        /** @type {ol.expr.LogicalOp.<string>} */ (operator),
         left, right);
-  } else if (ol.expression.Math.isValidOp(operator)) {
-    expr = new ol.expression.Math(
-        /** @type {ol.expression.MathOp.<string>} */ (operator),
+  } else if (ol.expr.Math.isValidOp(operator)) {
+    expr = new ol.expr.Math(
+        /** @type {ol.expr.MathOp.<string>} */ (operator),
         left, right);
   } else {
     throw new Error('Unsupported binary operator: ' + operator);
@@ -149,13 +149,13 @@ ol.expression.Parser.prototype.createBinaryExpression_ = function(operator,
 /**
  * Create a call expression.
  *
- * @param {ol.expression.Expression} callee Expression for function.
- * @param {Array.<ol.expression.Expression>} args Arguments array.
- * @return {ol.expression.Call} Call expression.
+ * @param {ol.expr.Expression} callee Expression for function.
+ * @param {Array.<ol.expr.Expression>} args Arguments array.
+ * @return {ol.expr.Call} Call expression.
  * @private
  */
-ol.expression.Parser.prototype.createCallExpression_ = function(callee, args) {
-  return new ol.expression.Call(callee, args);
+ol.expr.Parser.prototype.createCallExpression_ = function(callee, args) {
+  return new ol.expr.Call(callee, args);
 };
 
 
@@ -163,11 +163,11 @@ ol.expression.Parser.prototype.createCallExpression_ = function(callee, args) {
  * Create an identifier expression.
  *
  * @param {string} name Identifier name.
- * @return {ol.expression.Identifier} Identifier expression.
+ * @return {ol.expr.Identifier} Identifier expression.
  * @private
  */
-ol.expression.Parser.prototype.createIdentifier_ = function(name) {
-  return new ol.expression.Identifier(name);
+ol.expr.Parser.prototype.createIdentifier_ = function(name) {
+  return new ol.expr.Identifier(name);
 };
 
 
@@ -175,26 +175,26 @@ ol.expression.Parser.prototype.createIdentifier_ = function(name) {
  * Create a literal expression.
  *
  * @param {string|number|boolean|null} value Literal value.
- * @return {ol.expression.Literal} The literal expression.
+ * @return {ol.expr.Literal} The literal expression.
  * @private
  */
-ol.expression.Parser.prototype.createLiteral_ = function(value) {
-  return new ol.expression.Literal(value);
+ol.expr.Parser.prototype.createLiteral_ = function(value) {
+  return new ol.expr.Literal(value);
 };
 
 
 /**
  * Create a member expression.
  *
- * // TODO: make exp {ol.expression.Member|ol.expression.Identifier}
- * @param {ol.expression.Expression} object Expression.
- * @param {ol.expression.Identifier} property Member name.
- * @return {ol.expression.Member} The member expression.
+ * // TODO: make exp {ol.expr.Member|ol.expr.Identifier}
+ * @param {ol.expr.Expression} object Expression.
+ * @param {ol.expr.Identifier} property Member name.
+ * @return {ol.expr.Member} The member expression.
  * @private
  */
-ol.expression.Parser.prototype.createMemberExpression_ = function(object,
+ol.expr.Parser.prototype.createMemberExpression_ = function(object,
     property) {
-  return new ol.expression.Member(object, property);
+  return new ol.expr.Member(object, property);
 };
 
 
@@ -203,18 +203,18 @@ ol.expression.Parser.prototype.createMemberExpression_ = function(object,
  * "!".  For +/-, we apply the operator to literal expressions and return
  * another literal.
  *
- * @param {ol.expression.Token} op Operator.
- * @param {ol.expression.Expression} argument Expression.
- * @return {ol.expression.Expression} The unary expression.
+ * @param {ol.expr.Token} op Operator.
+ * @param {ol.expr.Expression} argument Expression.
+ * @return {ol.expr.Expression} The unary expression.
  * @private
  */
-ol.expression.Parser.prototype.createUnaryExpression_ = function(op, argument) {
+ol.expr.Parser.prototype.createUnaryExpression_ = function(op, argument) {
   goog.asserts.assert(op.value === '!' || op.value === '+' || op.value === '-');
   var expr;
   if (op.value === '!') {
-    expr = new ol.expression.Not(argument);
-  } else if (!(argument instanceof ol.expression.Literal)) {
-    throw new ol.expression.UnexpectedToken(op);
+    expr = new ol.expr.Not(argument);
+  } else if (!(argument instanceof ol.expr.Literal)) {
+    throw new ol.expr.UnexpectedToken(op);
   } else {
     // we've got +/- literal
     if (op.value === '+') {
@@ -233,14 +233,14 @@ ol.expression.Parser.prototype.createUnaryExpression_ = function(op, argument) {
  * Parse an expression.
  *
  * @param {string} source Expression source.
- * @return {ol.expression.Expression} Expression.
+ * @return {ol.expr.Expression} Expression.
  */
-ol.expression.Parser.prototype.parse = function(source) {
-  var lexer = new ol.expression.Lexer(source);
+ol.expr.Parser.prototype.parse = function(source) {
+  var lexer = new ol.expr.Lexer(source);
   var expr = this.parseExpression_(lexer);
   var token = lexer.peek();
-  if (token.type !== ol.expression.TokenType.EOF) {
-    throw new ol.expression.UnexpectedToken(token);
+  if (token.type !== ol.expr.TokenType.EOF) {
+    throw new ol.expr.UnexpectedToken(token);
   }
   return expr;
 };
@@ -250,11 +250,11 @@ ol.expression.Parser.prototype.parse = function(source) {
  * Parse call arguments
  * http://www.ecma-international.org/ecma-262/5.1/#sec-11.2.4
  *
- * @param {ol.expression.Lexer} lexer Lexer.
- * @return {Array.<ol.expression.Expression>} Arguments.
+ * @param {ol.expr.Lexer} lexer Lexer.
+ * @return {Array.<ol.expr.Expression>} Arguments.
  * @private
  */
-ol.expression.Parser.prototype.parseArguments_ = function(lexer) {
+ol.expr.Parser.prototype.parseArguments_ = function(lexer) {
   var args = [];
 
   lexer.expect('(');
@@ -292,11 +292,11 @@ ol.expression.Parser.prototype.parseArguments_ = function(lexer) {
  *  - Binary Logical Operators (`&&`, `||`)
  *    http://www.ecma-international.org/ecma-262/5.1/#sec-11.11
  *
- * @param {ol.expression.Lexer} lexer Lexer.
- * @return {ol.expression.Expression} Expression.
+ * @param {ol.expr.Lexer} lexer Lexer.
+ * @return {ol.expr.Expression} Expression.
  * @private
  */
-ol.expression.Parser.prototype.parseBinaryExpression_ = function(lexer) {
+ol.expr.Parser.prototype.parseBinaryExpression_ = function(lexer) {
   var left = this.parseUnaryExpression_(lexer);
 
   var operator = lexer.peek();
@@ -343,11 +343,11 @@ ol.expression.Parser.prototype.parseBinaryExpression_ = function(lexer) {
  * Parse a group expression.
  * http://www.ecma-international.org/ecma-262/5.1/#sec-11.1.6
  *
- * @param {ol.expression.Lexer} lexer Lexer.
- * @return {ol.expression.Expression} Expression.
+ * @param {ol.expr.Lexer} lexer Lexer.
+ * @return {ol.expr.Expression} Expression.
  * @private
  */
-ol.expression.Parser.prototype.parseGroupExpression_ = function(lexer) {
+ol.expr.Parser.prototype.parseGroupExpression_ = function(lexer) {
   lexer.expect('(');
   var expr = this.parseExpression_(lexer);
   lexer.expect(')');
@@ -360,18 +360,18 @@ ol.expression.Parser.prototype.parseGroupExpression_ = function(lexer) {
  * and Call Expressions.
  * http://www.ecma-international.org/ecma-262/5.1/#sec-11.2
  *
- * @param {ol.expression.Lexer} lexer Lexer.
- * @return {ol.expression.Expression} Expression.
+ * @param {ol.expr.Lexer} lexer Lexer.
+ * @return {ol.expr.Expression} Expression.
  * @private
  */
-ol.expression.Parser.prototype.parseLeftHandSideExpression_ = function(lexer) {
+ol.expr.Parser.prototype.parseLeftHandSideExpression_ = function(lexer) {
   var expr = this.parsePrimaryExpression_(lexer);
   var token = lexer.peek();
   if (token.value === '(') {
     // only allow calls on identifiers (e.g. `foo()` not `foo.bar()`)
-    if (!(expr instanceof ol.expression.Identifier)) {
+    if (!(expr instanceof ol.expr.Identifier)) {
       // TODO: more helpful error messages for restricted syntax
-      throw new ol.expression.UnexpectedToken(token);
+      throw new ol.expr.UnexpectedToken(token);
     }
     var args = this.parseArguments_(lexer);
     expr = this.createCallExpression_(expr, args);
@@ -391,19 +391,19 @@ ol.expression.Parser.prototype.parseLeftHandSideExpression_ = function(lexer) {
  * Parse non-computed member.
  * http://www.ecma-international.org/ecma-262/5.1/#sec-11.2
  *
- * @param {ol.expression.Lexer} lexer Lexer.
- * @return {ol.expression.Identifier} Expression.
+ * @param {ol.expr.Lexer} lexer Lexer.
+ * @return {ol.expr.Identifier} Expression.
  * @private
  */
-ol.expression.Parser.prototype.parseNonComputedMember_ = function(lexer) {
+ol.expr.Parser.prototype.parseNonComputedMember_ = function(lexer) {
   lexer.expect('.');
 
   var token = lexer.next();
-  if (token.type !== ol.expression.TokenType.IDENTIFIER &&
-      token.type !== ol.expression.TokenType.KEYWORD &&
-      token.type !== ol.expression.TokenType.BOOLEAN_LITERAL &&
-      token.type !== ol.expression.TokenType.NULL_LITERAL) {
-    throw new ol.expression.UnexpectedToken(token);
+  if (token.type !== ol.expr.TokenType.IDENTIFIER &&
+      token.type !== ol.expr.TokenType.KEYWORD &&
+      token.type !== ol.expr.TokenType.BOOLEAN_LITERAL &&
+      token.type !== ol.expr.TokenType.NULL_LITERAL) {
+    throw new ol.expr.UnexpectedToken(token);
   }
 
   return this.createIdentifier_(String(token.value));
@@ -414,11 +414,11 @@ ol.expression.Parser.prototype.parseNonComputedMember_ = function(lexer) {
  * Parse primary expression.
  * http://www.ecma-international.org/ecma-262/5.1/#sec-11.1
  *
- * @param {ol.expression.Lexer} lexer Lexer.
- * @return {ol.expression.Expression} Expression.
+ * @param {ol.expr.Lexer} lexer Lexer.
+ * @return {ol.expr.Expression} Expression.
  * @private
  */
-ol.expression.Parser.prototype.parsePrimaryExpression_ = function(lexer) {
+ol.expr.Parser.prototype.parsePrimaryExpression_ = function(lexer) {
   var token = lexer.peek();
   if (token.value === '(') {
     return this.parseGroupExpression_(lexer);
@@ -426,19 +426,19 @@ ol.expression.Parser.prototype.parsePrimaryExpression_ = function(lexer) {
   lexer.skip();
   var expr;
   var type = token.type;
-  if (type === ol.expression.TokenType.IDENTIFIER) {
+  if (type === ol.expr.TokenType.IDENTIFIER) {
     expr = this.createIdentifier_(/** @type {string} */ (token.value));
-  } else if (type === ol.expression.TokenType.STRING_LITERAL ||
-      type === ol.expression.TokenType.NUMERIC_LITERAL) {
+  } else if (type === ol.expr.TokenType.STRING_LITERAL ||
+      type === ol.expr.TokenType.NUMERIC_LITERAL) {
     // numeric and string literals are already the correct type
     expr = this.createLiteral_(token.value);
-  } else if (type === ol.expression.TokenType.BOOLEAN_LITERAL) {
+  } else if (type === ol.expr.TokenType.BOOLEAN_LITERAL) {
     // because booleans are valid member properties, tokens are still string
     expr = this.createLiteral_(token.value === 'true');
-  } else if (type === ol.expression.TokenType.NULL_LITERAL) {
+  } else if (type === ol.expr.TokenType.NULL_LITERAL) {
     expr = this.createLiteral_(null);
   } else {
-    throw new ol.expression.UnexpectedToken(token);
+    throw new ol.expr.UnexpectedToken(token);
   }
   return expr;
 };
@@ -448,14 +448,14 @@ ol.expression.Parser.prototype.parsePrimaryExpression_ = function(lexer) {
  * Parse expression with a unary operator.  Limited to logical not operator.
  * http://www.ecma-international.org/ecma-262/5.1/#sec-11.4
  *
- * @param {ol.expression.Lexer} lexer Lexer.
- * @return {ol.expression.Expression} Expression.
+ * @param {ol.expr.Lexer} lexer Lexer.
+ * @return {ol.expr.Expression} Expression.
  * @private
  */
-ol.expression.Parser.prototype.parseUnaryExpression_ = function(lexer) {
+ol.expr.Parser.prototype.parseUnaryExpression_ = function(lexer) {
   var expr;
   var operator = lexer.peek();
-  if (operator.type !== ol.expression.TokenType.PUNCTUATOR) {
+  if (operator.type !== ol.expr.TokenType.PUNCTUATOR) {
     expr = this.parseLeftHandSideExpression_(lexer);
   } else if (operator.value === '!' || operator.value === '-' ||
       operator.value === '+') {
@@ -472,10 +472,10 @@ ol.expression.Parser.prototype.parseUnaryExpression_ = function(lexer) {
 /**
  * Parse an expression.
  *
- * @param {ol.expression.Lexer} lexer Lexer.
- * @return {ol.expression.Expression} Expression.
+ * @param {ol.expr.Lexer} lexer Lexer.
+ * @return {ol.expr.Expression} Expression.
  * @private
  */
-ol.expression.Parser.prototype.parseExpression_ = function(lexer) {
+ol.expr.Parser.prototype.parseExpression_ = function(lexer) {
   return this.parseBinaryExpression_(lexer);
 };
diff --git a/src/ol/expression.jsdoc b/src/ol/expression.jsdoc
deleted file mode 100644
index 93f3016f63..0000000000
--- a/src/ol/expression.jsdoc
+++ /dev/null
@@ -1,3 +0,0 @@
-/**
- * @namespace ol.expression
- */
diff --git a/src/ol/expression/expression.exports b/src/ol/expression/expression.exports
deleted file mode 100644
index e3702d1e8b..0000000000
--- a/src/ol/expression/expression.exports
+++ /dev/null
@@ -1,2 +0,0 @@
-@exportSymbol ol.expression.parse
-@exportSymbol ol.expression.register
diff --git a/src/ol/layer/vectorlayer.js b/src/ol/layer/vectorlayer.js
index 261fd23f1d..3487f187d8 100644
--- a/src/ol/layer/vectorlayer.js
+++ b/src/ol/layer/vectorlayer.js
@@ -5,10 +5,10 @@ goog.require('goog.asserts');
 goog.require('goog.events.EventType');
 goog.require('goog.object');
 goog.require('ol.Feature');
-goog.require('ol.expression');
-goog.require('ol.expression.Literal');
-goog.require('ol.expression.Logical');
-goog.require('ol.expression.LogicalOp');
+goog.require('ol.expr');
+goog.require('ol.expr.Literal');
+goog.require('ol.expr.Logical');
+goog.require('ol.expr.LogicalOp');
 goog.require('ol.geom.GeometryType');
 goog.require('ol.geom.SharedVertices');
 goog.require('ol.layer.Layer');
@@ -83,7 +83,7 @@ ol.layer.FeatureCache.prototype.add = function(feature) {
 
 
 /**
- * @param {ol.expression.Expression=} opt_expr Expression for filtering.
+ * @param {ol.expr.Expression=} opt_expr Expression for filtering.
  * @return {Object.<string, ol.Feature>} Object of features, keyed by id.
  */
 ol.layer.FeatureCache.prototype.getFeaturesObject = function(opt_expr) {
@@ -92,48 +92,48 @@ ol.layer.FeatureCache.prototype.getFeaturesObject = function(opt_expr) {
     features = this.idLookup_;
   } else {
     // check for geometryType or extent expression
-    var name = ol.expression.isLibCall(opt_expr);
+    var name = ol.expr.isLibCall(opt_expr);
     if (name === 'geometryType') {
-      var args = /** @type {ol.expression.Call} */ (opt_expr).getArgs();
+      var args = /** @type {ol.expr.Call} */ (opt_expr).getArgs();
       goog.asserts.assert(args.length === 1);
-      goog.asserts.assert(args[0] instanceof ol.expression.Literal);
-      var type = /** @type {ol.expression.Literal } */ (args[0]).evaluate();
+      goog.asserts.assert(args[0] instanceof ol.expr.Literal);
+      var type = /** @type {ol.expr.Literal } */ (args[0]).evaluate();
       goog.asserts.assertString(type);
       features = this.geometryTypeIndex_[type];
     } else if (name === 'extent') {
-      var args = /** @type {ol.expression.Call} */ (opt_expr).getArgs();
+      var args = /** @type {ol.expr.Call} */ (opt_expr).getArgs();
       goog.asserts.assert(args.length === 4);
       var extent = [];
       for (var i = 0; i < 4; ++i) {
-        goog.asserts.assert(args[i] instanceof ol.expression.Literal);
-        extent[i] = /** @type {ol.expression.Literal} */ (args[i]).evaluate();
+        goog.asserts.assert(args[i] instanceof ol.expr.Literal);
+        extent[i] = /** @type {ol.expr.Literal} */ (args[i]).evaluate();
         goog.asserts.assertNumber(extent[i]);
       }
       features = this.rTree_.searchReturningObject(extent);
     } else {
       // not a call expression, check logical
-      if (opt_expr instanceof ol.expression.Logical) {
-        var op = /** @type {ol.expression.Logical} */ (opt_expr).getOperator();
-        if (op === ol.expression.LogicalOp.AND) {
+      if (opt_expr instanceof ol.expr.Logical) {
+        var op = /** @type {ol.expr.Logical} */ (opt_expr).getOperator();
+        if (op === ol.expr.LogicalOp.AND) {
           var expressions = [opt_expr.getLeft(), opt_expr.getRight()];
           var expr, args, type, extent;
           for (var i = 0; i <= 1; ++i) {
             expr = expressions[i];
-            name = ol.expression.isLibCall(expr);
+            name = ol.expr.isLibCall(expr);
             if (name === 'geometryType') {
-              args = /** @type {ol.expression.Call} */ (expr).getArgs();
+              args = /** @type {ol.expr.Call} */ (expr).getArgs();
               goog.asserts.assert(args.length === 1);
-              goog.asserts.assert(args[0] instanceof ol.expression.Literal);
-              type = /** @type {ol.expression.Literal } */ (args[0]).evaluate();
+              goog.asserts.assert(args[0] instanceof ol.expr.Literal);
+              type = /** @type {ol.expr.Literal } */ (args[0]).evaluate();
               goog.asserts.assertString(type);
             } else if (name === 'extent') {
-              args = /** @type {ol.expression.Call} */ (expr).getArgs();
+              args = /** @type {ol.expr.Call} */ (expr).getArgs();
               goog.asserts.assert(args.length === 4);
               extent = [];
               for (var j = 0; j < 4; ++j) {
-                goog.asserts.assert(args[j] instanceof ol.expression.Literal);
+                goog.asserts.assert(args[j] instanceof ol.expr.Literal);
                 extent[j] =
-                    /** @type {ol.expression.Literal} */ (args[j]).evaluate();
+                    /** @type {ol.expr.Literal} */ (args[j]).evaluate();
                 goog.asserts.assertNumber(extent[j]);
               }
             }
@@ -152,7 +152,7 @@ ol.layer.FeatureCache.prototype.getFeaturesObject = function(opt_expr) {
       features = {};
       for (i in candidates) {
         feature = candidates[i];
-        if (ol.expression.evaluateFeature(opt_expr, feature)) {
+        if (ol.expr.evaluateFeature(opt_expr, feature)) {
           features[i] = feature;
         }
       }
@@ -278,7 +278,7 @@ ol.layer.Vector.prototype.getVectorSource = function() {
 
 
 /**
- * @param {ol.expression.Expression=} opt_expr Expression for filtering.
+ * @param {ol.expr.Expression=} opt_expr Expression for filtering.
  * @return {Array.<ol.Feature>} Array of features.
  */
 ol.layer.Vector.prototype.getFeatures = function(opt_expr) {
@@ -288,7 +288,7 @@ ol.layer.Vector.prototype.getFeatures = function(opt_expr) {
 
 
 /**
- * @param {ol.expression.Expression=} opt_expr Expression for filtering.
+ * @param {ol.expr.Expression=} opt_expr Expression for filtering.
  * @return {Object.<string, ol.Feature>} Features.
  */
 ol.layer.Vector.prototype.getFeaturesObject = function(opt_expr) {
diff --git a/src/ol/style/icon.js b/src/ol/style/icon.js
index f4116b6c79..9be3af41a8 100644
--- a/src/ol/style/icon.js
+++ b/src/ol/style/icon.js
@@ -3,9 +3,9 @@ goog.provide('ol.style.IconLiteral');
 goog.provide('ol.style.IconType');
 
 goog.require('goog.asserts');
-goog.require('ol.expression');
-goog.require('ol.expression.Expression');
-goog.require('ol.expression.Literal');
+goog.require('ol.expr');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Literal');
 goog.require('ol.style.Point');
 goog.require('ol.style.PointLiteral');
 
@@ -70,47 +70,47 @@ ol.style.Icon = function(options) {
   goog.asserts.assert(options.url, 'url must be set');
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
-  this.url_ = (options.url instanceof ol.expression.Expression) ?
-          options.url : new ol.expression.Literal(options.url);
+  this.url_ = (options.url instanceof ol.expr.Expression) ?
+          options.url : new ol.expr.Literal(options.url);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.width_ = !goog.isDef(options.width) ?
       null :
-      (options.width instanceof ol.expression.Expression) ?
-          options.width : new ol.expression.Literal(options.width);
+      (options.width instanceof ol.expr.Expression) ?
+          options.width : new ol.expr.Literal(options.width);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.height_ = !goog.isDef(options.height) ?
       null :
-      (options.height instanceof ol.expression.Expression) ?
-          options.height : new ol.expression.Literal(options.height);
+      (options.height instanceof ol.expr.Expression) ?
+          options.height : new ol.expr.Literal(options.height);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.opacity_ = !goog.isDef(options.opacity) ?
-      new ol.expression.Literal(ol.style.IconDefaults.opacity) :
-      (options.opacity instanceof ol.expression.Expression) ?
-          options.opacity : new ol.expression.Literal(options.opacity);
+      new ol.expr.Literal(ol.style.IconDefaults.opacity) :
+      (options.opacity instanceof ol.expr.Expression) ?
+          options.opacity : new ol.expr.Literal(options.opacity);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.rotation_ = !goog.isDef(options.rotation) ?
-      new ol.expression.Literal(ol.style.IconDefaults.rotation) :
-      (options.rotation instanceof ol.expression.Expression) ?
-          options.rotation : new ol.expression.Literal(options.rotation);
+      new ol.expr.Literal(ol.style.IconDefaults.rotation) :
+      (options.rotation instanceof ol.expr.Expression) ?
+          options.rotation : new ol.expr.Literal(options.rotation);
 
 };
 
@@ -121,26 +121,26 @@ ol.style.Icon = function(options) {
  */
 ol.style.Icon.prototype.createLiteral = function(opt_feature) {
 
-  var url = ol.expression.evaluateFeature(this.url_, opt_feature);
+  var url = ol.expr.evaluateFeature(this.url_, opt_feature);
   goog.asserts.assertString(url, 'url must be a string');
   goog.asserts.assert(url != '#', 'url must not be "#"');
 
   var width;
   if (!goog.isNull(this.width_)) {
-    width = ol.expression.evaluateFeature(this.width_, opt_feature);
+    width = ol.expr.evaluateFeature(this.width_, opt_feature);
     goog.asserts.assertNumber(width, 'width must be a number');
   }
 
   var height;
   if (!goog.isNull(this.height_)) {
-    height = ol.expression.evaluateFeature(this.height_, opt_feature);
+    height = ol.expr.evaluateFeature(this.height_, opt_feature);
     goog.asserts.assertNumber(height, 'height must be a number');
   }
 
-  var opacity = ol.expression.evaluateFeature(this.opacity_, opt_feature);
+  var opacity = ol.expr.evaluateFeature(this.opacity_, opt_feature);
   goog.asserts.assertNumber(opacity, 'opacity must be a number');
 
-  var rotation = ol.expression.evaluateFeature(this.rotation_, opt_feature);
+  var rotation = ol.expr.evaluateFeature(this.rotation_, opt_feature);
   goog.asserts.assertNumber(rotation, 'rotation must be a number');
 
   return new ol.style.IconLiteral({
diff --git a/src/ol/style/line.js b/src/ol/style/line.js
index 5c9e249580..5fc17a2e7a 100644
--- a/src/ol/style/line.js
+++ b/src/ol/style/line.js
@@ -2,9 +2,9 @@ goog.provide('ol.style.Line');
 goog.provide('ol.style.LineLiteral');
 
 goog.require('goog.asserts');
-goog.require('ol.expression');
-goog.require('ol.expression.Expression');
-goog.require('ol.expression.Literal');
+goog.require('ol.expr');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Literal');
 goog.require('ol.style.Symbolizer');
 goog.require('ol.style.SymbolizerLiteral');
 
@@ -64,31 +64,31 @@ ol.style.Line = function(options) {
   goog.base(this);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.strokeColor_ = !goog.isDef(options.strokeColor) ?
-      new ol.expression.Literal(ol.style.LineDefaults.strokeColor) :
-      (options.strokeColor instanceof ol.expression.Expression) ?
-          options.strokeColor : new ol.expression.Literal(options.strokeColor);
+      new ol.expr.Literal(ol.style.LineDefaults.strokeColor) :
+      (options.strokeColor instanceof ol.expr.Expression) ?
+          options.strokeColor : new ol.expr.Literal(options.strokeColor);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.strokeWidth_ = !goog.isDef(options.strokeWidth) ?
-      new ol.expression.Literal(ol.style.LineDefaults.strokeWidth) :
-      (options.strokeWidth instanceof ol.expression.Expression) ?
-          options.strokeWidth : new ol.expression.Literal(options.strokeWidth);
+      new ol.expr.Literal(ol.style.LineDefaults.strokeWidth) :
+      (options.strokeWidth instanceof ol.expr.Expression) ?
+          options.strokeWidth : new ol.expr.Literal(options.strokeWidth);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.opacity_ = !goog.isDef(options.opacity) ?
-      new ol.expression.Literal(ol.style.LineDefaults.opacity) :
-      (options.opacity instanceof ol.expression.Expression) ?
-          options.opacity : new ol.expression.Literal(options.opacity);
+      new ol.expr.Literal(ol.style.LineDefaults.opacity) :
+      (options.opacity instanceof ol.expr.Expression) ?
+          options.opacity : new ol.expr.Literal(options.opacity);
 
 };
 goog.inherits(ol.style.Line, ol.style.Symbolizer);
@@ -100,15 +100,15 @@ goog.inherits(ol.style.Line, ol.style.Symbolizer);
  */
 ol.style.Line.prototype.createLiteral = function(opt_feature) {
 
-  var strokeColor = ol.expression.evaluateFeature(
+  var strokeColor = ol.expr.evaluateFeature(
       this.strokeColor_, opt_feature);
   goog.asserts.assertString(strokeColor, 'strokeColor must be a string');
 
-  var strokeWidth = ol.expression.evaluateFeature(
+  var strokeWidth = ol.expr.evaluateFeature(
       this.strokeWidth_, opt_feature);
   goog.asserts.assertNumber(strokeWidth, 'strokeWidth must be a number');
 
-  var opacity = ol.expression.evaluateFeature(this.opacity_, opt_feature);
+  var opacity = ol.expr.evaluateFeature(this.opacity_, opt_feature);
   goog.asserts.assertNumber(opacity, 'opacity must be a number');
 
   return new ol.style.LineLiteral({
diff --git a/src/ol/style/polygon.js b/src/ol/style/polygon.js
index df683438a6..57fa4afb6b 100644
--- a/src/ol/style/polygon.js
+++ b/src/ol/style/polygon.js
@@ -2,9 +2,9 @@ goog.provide('ol.style.Polygon');
 goog.provide('ol.style.PolygonLiteral');
 
 goog.require('goog.asserts');
-goog.require('ol.expression');
-goog.require('ol.expression.Expression');
-goog.require('ol.expression.Literal');
+goog.require('ol.expr');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Literal');
 goog.require('ol.style.Symbolizer');
 goog.require('ol.style.SymbolizerLiteral');
 
@@ -81,13 +81,13 @@ ol.style.Polygon = function(options) {
   goog.base(this);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.fillColor_ = !goog.isDefAndNotNull(options.fillColor) ?
       null :
-      (options.fillColor instanceof ol.expression.Expression) ?
-          options.fillColor : new ol.expression.Literal(options.fillColor);
+      (options.fillColor instanceof ol.expr.Expression) ?
+          options.fillColor : new ol.expr.Literal(options.fillColor);
 
   // stroke handling - if any stroke property is supplied, use defaults
   var strokeColor = null,
@@ -97,32 +97,32 @@ ol.style.Polygon = function(options) {
       goog.isDefAndNotNull(options.strokeWidth)) {
 
     if (goog.isDefAndNotNull(options.strokeColor)) {
-      strokeColor = (options.strokeColor instanceof ol.expression.Expression) ?
+      strokeColor = (options.strokeColor instanceof ol.expr.Expression) ?
           options.strokeColor :
-          new ol.expression.Literal(options.strokeColor);
+          new ol.expr.Literal(options.strokeColor);
     } else {
-      strokeColor = new ol.expression.Literal(
+      strokeColor = new ol.expr.Literal(
           /** @type {string} */ (ol.style.PolygonDefaults.strokeColor));
     }
 
     if (goog.isDefAndNotNull(options.strokeWidth)) {
-      strokeWidth = (options.strokeWidth instanceof ol.expression.Expression) ?
+      strokeWidth = (options.strokeWidth instanceof ol.expr.Expression) ?
           options.strokeWidth :
-          new ol.expression.Literal(options.strokeWidth);
+          new ol.expr.Literal(options.strokeWidth);
     } else {
-      strokeWidth = new ol.expression.Literal(
+      strokeWidth = new ol.expr.Literal(
           /** @type {number} */ (ol.style.PolygonDefaults.strokeWidth));
     }
   }
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.strokeColor_ = strokeColor;
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.strokeWidth_ = strokeWidth;
@@ -133,13 +133,13 @@ ol.style.Polygon = function(options) {
       'Stroke or fill properties must be provided');
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.opacity_ = !goog.isDef(options.opacity) ?
-      new ol.expression.Literal(ol.style.PolygonDefaults.opacity) :
-      (options.opacity instanceof ol.expression.Expression) ?
-          options.opacity : new ol.expression.Literal(options.opacity);
+      new ol.expr.Literal(ol.style.PolygonDefaults.opacity) :
+      (options.opacity instanceof ol.expr.Expression) ?
+          options.opacity : new ol.expr.Literal(options.opacity);
 
 };
 goog.inherits(ol.style.Polygon, ol.style.Symbolizer);
@@ -153,19 +153,19 @@ ol.style.Polygon.prototype.createLiteral = function(opt_feature) {
 
   var fillColor;
   if (!goog.isNull(this.fillColor_)) {
-    fillColor = ol.expression.evaluateFeature(this.fillColor_, opt_feature);
+    fillColor = ol.expr.evaluateFeature(this.fillColor_, opt_feature);
     goog.asserts.assertString(fillColor, 'fillColor must be a string');
   }
 
   var strokeColor;
   if (!goog.isNull(this.strokeColor_)) {
-    strokeColor = ol.expression.evaluateFeature(this.strokeColor_, opt_feature);
+    strokeColor = ol.expr.evaluateFeature(this.strokeColor_, opt_feature);
     goog.asserts.assertString(strokeColor, 'strokeColor must be a string');
   }
 
   var strokeWidth;
   if (!goog.isNull(this.strokeWidth_)) {
-    strokeWidth = ol.expression.evaluateFeature(this.strokeWidth_, opt_feature);
+    strokeWidth = ol.expr.evaluateFeature(this.strokeWidth_, opt_feature);
     goog.asserts.assertNumber(strokeWidth, 'strokeWidth must be a number');
   }
 
@@ -174,7 +174,7 @@ ol.style.Polygon.prototype.createLiteral = function(opt_feature) {
       (goog.isDef(strokeColor) && goog.isDef(strokeWidth)),
       'either fillColor or strokeColor and strokeWidth must be defined');
 
-  var opacity = ol.expression.evaluateFeature(this.opacity_, opt_feature);
+  var opacity = ol.expr.evaluateFeature(this.opacity_, opt_feature);
   goog.asserts.assertNumber(opacity, 'opacity must be a number');
 
   return new ol.style.PolygonLiteral({
diff --git a/src/ol/style/rule.js b/src/ol/style/rule.js
index 4410fdfc15..97ecb5b84c 100644
--- a/src/ol/style/rule.js
+++ b/src/ol/style/rule.js
@@ -3,8 +3,8 @@ goog.provide('ol.style.Rule');
 goog.require('goog.asserts');
 
 goog.require('ol.Feature');
-goog.require('ol.expression');
-goog.require('ol.expression.Expression');
+goog.require('ol.expr');
+goog.require('ol.expr.Expression');
 goog.require('ol.style.Symbolizer');
 
 
@@ -19,15 +19,15 @@ ol.style.Rule = function(options) {
   var filter = null;
   if (goog.isDef(options.filter)) {
     if (goog.isString(options.filter)) {
-      filter = ol.expression.parse(options.filter);
+      filter = ol.expr.parse(options.filter);
     } else {
-      goog.asserts.assert(options.filter instanceof ol.expression.Expression);
+      goog.asserts.assert(options.filter instanceof ol.expr.Expression);
       filter = options.filter;
     }
   }
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.filter_ = filter;
@@ -48,7 +48,7 @@ ol.style.Rule = function(options) {
  */
 ol.style.Rule.prototype.applies = function(feature) {
   return goog.isNull(this.filter_) ?
-      true : !!ol.expression.evaluateFeature(this.filter_, feature);
+      true : !!ol.expr.evaluateFeature(this.filter_, feature);
 };
 
 
diff --git a/src/ol/style/shape.js b/src/ol/style/shape.js
index 5c8802b47f..751cf66ab2 100644
--- a/src/ol/style/shape.js
+++ b/src/ol/style/shape.js
@@ -3,9 +3,9 @@ goog.provide('ol.style.ShapeLiteral');
 goog.provide('ol.style.ShapeType');
 
 goog.require('goog.asserts');
-goog.require('ol.expression');
-goog.require('ol.expression.Expression');
-goog.require('ol.expression.Literal');
+goog.require('ol.expr');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Literal');
 goog.require('ol.style.Point');
 goog.require('ol.style.PointLiteral');
 
@@ -107,22 +107,22 @@ ol.style.Shape = function(options) {
       options.type : ol.style.ShapeDefaults.type);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.size_ = !goog.isDef(options.size) ?
-      new ol.expression.Literal(ol.style.ShapeDefaults.size) :
-      (options.size instanceof ol.expression.Expression) ?
-          options.size : new ol.expression.Literal(options.size);
+      new ol.expr.Literal(ol.style.ShapeDefaults.size) :
+      (options.size instanceof ol.expr.Expression) ?
+          options.size : new ol.expr.Literal(options.size);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.fillColor_ = !goog.isDefAndNotNull(options.fillColor) ?
       null :
-      (options.fillColor instanceof ol.expression.Expression) ?
-          options.fillColor : new ol.expression.Literal(options.fillColor);
+      (options.fillColor instanceof ol.expr.Expression) ?
+          options.fillColor : new ol.expr.Literal(options.fillColor);
 
   // stroke handling - if any stroke property is supplied, use defaults
   var strokeColor = null,
@@ -132,33 +132,33 @@ ol.style.Shape = function(options) {
       goog.isDefAndNotNull(options.strokeWidth)) {
 
     if (goog.isDefAndNotNull(options.strokeColor)) {
-      strokeColor = (options.strokeColor instanceof ol.expression.Expression) ?
+      strokeColor = (options.strokeColor instanceof ol.expr.Expression) ?
           options.strokeColor :
-          new ol.expression.Literal(options.strokeColor);
+          new ol.expr.Literal(options.strokeColor);
     } else {
-      strokeColor = new ol.expression.Literal(
+      strokeColor = new ol.expr.Literal(
           /** @type {string} */ (ol.style.ShapeDefaults.strokeColor));
     }
 
     if (goog.isDefAndNotNull(options.strokeWidth)) {
-      strokeWidth = (options.strokeWidth instanceof ol.expression.Expression) ?
+      strokeWidth = (options.strokeWidth instanceof ol.expr.Expression) ?
           options.strokeWidth :
-          new ol.expression.Literal(options.strokeWidth);
+          new ol.expr.Literal(options.strokeWidth);
     } else {
-      strokeWidth = new ol.expression.Literal(
+      strokeWidth = new ol.expr.Literal(
           /** @type {number} */ (ol.style.ShapeDefaults.strokeWidth));
     }
 
   }
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.strokeColor_ = strokeColor;
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.strokeWidth_ = strokeWidth;
@@ -169,13 +169,13 @@ ol.style.Shape = function(options) {
       'Stroke or fill properties must be provided');
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.opacity_ = !goog.isDef(options.opacity) ?
-      new ol.expression.Literal(ol.style.ShapeDefaults.opacity) :
-      (options.opacity instanceof ol.expression.Expression) ?
-          options.opacity : new ol.expression.Literal(options.opacity);
+      new ol.expr.Literal(ol.style.ShapeDefaults.opacity) :
+      (options.opacity instanceof ol.expr.Expression) ?
+          options.opacity : new ol.expr.Literal(options.opacity);
 
 };
 
@@ -186,24 +186,24 @@ ol.style.Shape = function(options) {
  */
 ol.style.Shape.prototype.createLiteral = function(opt_feature) {
 
-  var size = ol.expression.evaluateFeature(this.size_, opt_feature);
+  var size = ol.expr.evaluateFeature(this.size_, opt_feature);
   goog.asserts.assertNumber(size, 'size must be a number');
 
   var fillColor;
   if (!goog.isNull(this.fillColor_)) {
-    fillColor = ol.expression.evaluateFeature(this.fillColor_, opt_feature);
+    fillColor = ol.expr.evaluateFeature(this.fillColor_, opt_feature);
     goog.asserts.assertString(fillColor, 'fillColor must be a string');
   }
 
   var strokeColor;
   if (!goog.isNull(this.strokeColor_)) {
-    strokeColor = ol.expression.evaluateFeature(this.strokeColor_, opt_feature);
+    strokeColor = ol.expr.evaluateFeature(this.strokeColor_, opt_feature);
     goog.asserts.assertString(strokeColor, 'strokeColor must be a string');
   }
 
   var strokeWidth;
   if (!goog.isNull(this.strokeWidth_)) {
-    strokeWidth = ol.expression.evaluateFeature(this.strokeWidth_, opt_feature);
+    strokeWidth = ol.expr.evaluateFeature(this.strokeWidth_, opt_feature);
     goog.asserts.assertNumber(strokeWidth, 'strokeWidth must be a number');
   }
 
@@ -212,7 +212,7 @@ ol.style.Shape.prototype.createLiteral = function(opt_feature) {
       (goog.isDef(strokeColor) && goog.isDef(strokeWidth)),
       'either fillColor or strokeColor and strokeWidth must be defined');
 
-  var opacity = ol.expression.evaluateFeature(this.opacity_, opt_feature);
+  var opacity = ol.expr.evaluateFeature(this.opacity_, opt_feature);
   goog.asserts.assertNumber(opacity, 'opacity must be a number');
 
   return new ol.style.ShapeLiteral({
diff --git a/src/ol/style/text.js b/src/ol/style/text.js
index 1c8b4005f9..a1862bc776 100644
--- a/src/ol/style/text.js
+++ b/src/ol/style/text.js
@@ -2,9 +2,9 @@ goog.provide('ol.style.Text');
 goog.provide('ol.style.TextLiteral');
 
 goog.require('goog.asserts');
-goog.require('ol.expression');
-goog.require('ol.expression.Expression');
-goog.require('ol.expression.Literal');
+goog.require('ol.expr');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Literal');
 goog.require('ol.style.Symbolizer');
 goog.require('ol.style.SymbolizerLiteral');
 
@@ -71,47 +71,47 @@ ol.style.TextLiteral.prototype.equals = function(textLiteral) {
 ol.style.Text = function(options) {
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.color_ = !goog.isDef(options.color) ?
-      new ol.expression.Literal(ol.style.TextDefaults.color) :
-      (options.color instanceof ol.expression.Expression) ?
-          options.color : new ol.expression.Literal(options.color);
+      new ol.expr.Literal(ol.style.TextDefaults.color) :
+      (options.color instanceof ol.expr.Expression) ?
+          options.color : new ol.expr.Literal(options.color);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.fontFamily_ = !goog.isDef(options.fontFamily) ?
-      new ol.expression.Literal(ol.style.TextDefaults.fontFamily) :
-      (options.fontFamily instanceof ol.expression.Expression) ?
-          options.fontFamily : new ol.expression.Literal(options.fontFamily);
+      new ol.expr.Literal(ol.style.TextDefaults.fontFamily) :
+      (options.fontFamily instanceof ol.expr.Expression) ?
+          options.fontFamily : new ol.expr.Literal(options.fontFamily);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.fontSize_ = !goog.isDef(options.fontSize) ?
-      new ol.expression.Literal(ol.style.TextDefaults.fontSize) :
-      (options.fontSize instanceof ol.expression.Expression) ?
-          options.fontSize : new ol.expression.Literal(options.fontSize);
+      new ol.expr.Literal(ol.style.TextDefaults.fontSize) :
+      (options.fontSize instanceof ol.expr.Expression) ?
+          options.fontSize : new ol.expr.Literal(options.fontSize);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
-  this.text_ = (options.text instanceof ol.expression.Expression) ?
-      options.text : new ol.expression.Literal(options.text);
+  this.text_ = (options.text instanceof ol.expr.Expression) ?
+      options.text : new ol.expr.Literal(options.text);
 
   /**
-   * @type {ol.expression.Expression}
+   * @type {ol.expr.Expression}
    * @private
    */
   this.opacity_ = !goog.isDef(options.opacity) ?
-      new ol.expression.Literal(ol.style.TextDefaults.opacity) :
-      (options.opacity instanceof ol.expression.Expression) ?
-          options.opacity : new ol.expression.Literal(options.opacity);
+      new ol.expr.Literal(ol.style.TextDefaults.opacity) :
+      (options.opacity instanceof ol.expr.Expression) ?
+          options.opacity : new ol.expr.Literal(options.opacity);
 
 };
 goog.inherits(ol.style.Text, ol.style.Symbolizer);
@@ -123,19 +123,19 @@ goog.inherits(ol.style.Text, ol.style.Symbolizer);
  */
 ol.style.Text.prototype.createLiteral = function(opt_feature) {
 
-  var color = ol.expression.evaluateFeature(this.color_, opt_feature);
+  var color = ol.expr.evaluateFeature(this.color_, opt_feature);
   goog.asserts.assertString(color, 'color must be a string');
 
-  var fontFamily = ol.expression.evaluateFeature(this.fontFamily_, opt_feature);
+  var fontFamily = ol.expr.evaluateFeature(this.fontFamily_, opt_feature);
   goog.asserts.assertString(fontFamily, 'fontFamily must be a string');
 
-  var fontSize = ol.expression.evaluateFeature(this.fontSize_, opt_feature);
+  var fontSize = ol.expr.evaluateFeature(this.fontSize_, opt_feature);
   goog.asserts.assertNumber(fontSize, 'fontSize must be a number');
 
-  var text = ol.expression.evaluateFeature(this.text_, opt_feature);
+  var text = ol.expr.evaluateFeature(this.text_, opt_feature);
   goog.asserts.assertString(text, 'text must be a string');
 
-  var opacity = ol.expression.evaluateFeature(this.opacity_, opt_feature);
+  var opacity = ol.expr.evaluateFeature(this.opacity_, opt_feature);
   goog.asserts.assertNumber(opacity, 'opacity must be a number');
 
   return new ol.style.TextLiteral({
diff --git a/test/spec/ol/expression/expression.test.js b/test/spec/ol/expr/expression.test.js
similarity index 68%
rename from test/spec/ol/expression/expression.test.js
rename to test/spec/ol/expr/expression.test.js
index 7b330b4d1c..6e2946ebd2 100644
--- a/test/spec/ol/expression/expression.test.js
+++ b/test/spec/ol/expr/expression.test.js
@@ -1,33 +1,33 @@
 goog.provide('ol.test.expression');
 
 
-describe('ol.expression.parse()', function() {
+describe('ol.expr.parse()', function() {
 
   it('parses a subset of ECMAScript 5.1 expressions', function() {
-    var expr = ol.expression.parse('foo');
-    expect(expr).to.be.a(ol.expression.Expression);
+    var expr = ol.expr.parse('foo');
+    expect(expr).to.be.a(ol.expr.Expression);
   });
 
   describe('11.1 - primary expressions', function() {
     // http://www.ecma-international.org/ecma-262/5.1/#sec-11.1
 
     it('parses identifier expressions', function() {
-      var expr = ol.expression.parse('foo');
-      expect(expr).to.be.a(ol.expression.Identifier);
+      var expr = ol.expr.parse('foo');
+      expect(expr).to.be.a(ol.expr.Identifier);
       expect(expr.evaluate({foo: 'bar'})).to.be('bar');
     });
 
     it('consumes whitespace as expected', function() {
-      var expr = ol.expression.parse('  foo  ');
-      expect(expr).to.be.a(ol.expression.Identifier);
+      var expr = ol.expr.parse('  foo  ');
+      expect(expr).to.be.a(ol.expr.Identifier);
       expect(expr.evaluate({foo: 'bar'})).to.be('bar');
     });
 
     it('throws on invalid identifier expressions', function() {
       expect(function() {
-        ol.expression.parse('3foo');
+        ol.expr.parse('3foo');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('f');
         expect(token.index).to.be(1);
@@ -35,33 +35,33 @@ describe('ol.expression.parse()', function() {
     });
 
     it('parses string literal expressions', function() {
-      var expr = ol.expression.parse('"foo"');
-      expect(expr).to.be.a(ol.expression.Literal);
+      var expr = ol.expr.parse('"foo"');
+      expect(expr).to.be.a(ol.expr.Literal);
       expect(expr.evaluate()).to.be('foo');
     });
 
     it('throws on unterminated string', function() {
       expect(function() {
-        ol.expression.parse('"foo');
+        ol.expr.parse('"foo');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
-        expect(token.type).to.be(ol.expression.TokenType.EOF);
+        expect(token.type).to.be(ol.expr.TokenType.EOF);
         expect(token.index).to.be(4);
       });
     });
 
     it('parses numeric literal expressions', function() {
-      var expr = ol.expression.parse('.42e+2');
-      expect(expr).to.be.a(ol.expression.Literal);
+      var expr = ol.expr.parse('.42e+2');
+      expect(expr).to.be.a(ol.expr.Literal);
       expect(expr.evaluate()).to.be(42);
     });
 
     it('throws on invalid number', function() {
       expect(function() {
-        ol.expression.parse('.42eX');
+        ol.expr.parse('.42eX');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('X');
         expect(token.index).to.be(4);
@@ -69,14 +69,14 @@ describe('ol.expression.parse()', function() {
     });
 
     it('parses boolean literal expressions', function() {
-      var expr = ol.expression.parse('false');
-      expect(expr).to.be.a(ol.expression.Literal);
+      var expr = ol.expr.parse('false');
+      expect(expr).to.be.a(ol.expr.Literal);
       expect(expr.evaluate()).to.be(false);
     });
 
     it('parses null literal expressions', function() {
-      var expr = ol.expression.parse('null');
-      expect(expr).to.be.a(ol.expression.Literal);
+      var expr = ol.expr.parse('null');
+      expect(expr).to.be.a(ol.expr.Literal);
       expect(expr.evaluate()).to.be(null);
     });
 
@@ -86,24 +86,24 @@ describe('ol.expression.parse()', function() {
     // http://www.ecma-international.org/ecma-262/5.1/#sec-11.2
 
     it('parses member expressions with dot notation', function() {
-      var expr = ol.expression.parse('foo.bar.baz');
-      expect(expr).to.be.a(ol.expression.Member);
+      var expr = ol.expr.parse('foo.bar.baz');
+      expect(expr).to.be.a(ol.expr.Member);
       var scope = {foo: {bar: {baz: 42}}};
       expect(expr.evaluate(scope)).to.be(42);
     });
 
     it('consumes whitespace as expected', function() {
-      var expr = ol.expression.parse(' foo . bar . baz ');
-      expect(expr).to.be.a(ol.expression.Member);
+      var expr = ol.expr.parse(' foo . bar . baz ');
+      expect(expr).to.be.a(ol.expr.Member);
       var scope = {foo: {bar: {baz: 42}}};
       expect(expr.evaluate(scope)).to.be(42);
     });
 
     it('throws on invalid member expression', function() {
       expect(function() {
-        ol.expression.parse('foo.4bar');
+        ol.expr.parse('foo.4bar');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('b');
         expect(token.index).to.be(5);
@@ -111,8 +111,8 @@ describe('ol.expression.parse()', function() {
     });
 
     it('parses call expressions with literal arguments', function() {
-      var expr = ol.expression.parse('foo(42, "bar")');
-      expect(expr).to.be.a(ol.expression.Call);
+      var expr = ol.expr.parse('foo(42, "bar")');
+      expect(expr).to.be.a(ol.expr.Call);
       var scope = {
         foo: function(num, str) {
           expect(num).to.be(42);
@@ -125,9 +125,9 @@ describe('ol.expression.parse()', function() {
 
     it('throws on calls with unterminated arguments', function() {
       expect(function() {
-        ol.expression.parse('foo(42,)');
+        ol.expr.parse('foo(42,)');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be(')');
         expect(token.index).to.be(7);
@@ -146,8 +146,8 @@ describe('ol.expression.parse()', function() {
     // http://www.ecma-international.org/ecma-262/5.1/#sec-11.4
 
     it('parses logical not operator', function() {
-      var expr = ol.expression.parse('!foo');
-      expect(expr).to.be.a(ol.expression.Not);
+      var expr = ol.expr.parse('!foo');
+      expect(expr).to.be.a(ol.expr.Not);
       expect(expr.evaluate({foo: true})).to.be(false);
       expect(expr.evaluate({foo: false})).to.be(true);
       expect(expr.evaluate({foo: ''})).to.be(true);
@@ -155,8 +155,8 @@ describe('ol.expression.parse()', function() {
     });
 
     it('consumes whitespace as expected', function() {
-      var expr = ol.expression.parse(' ! foo');
-      expect(expr).to.be.a(ol.expression.Not);
+      var expr = ol.expr.parse(' ! foo');
+      expect(expr).to.be.a(ol.expr.Not);
       expect(expr.evaluate({foo: true})).to.be(false);
       expect(expr.evaluate({foo: false})).to.be(true);
     });
@@ -167,38 +167,38 @@ describe('ol.expression.parse()', function() {
     // http://www.ecma-international.org/ecma-262/5.1/#sec-11.5
 
     it('parses * operator', function() {
-      var expr = ol.expression.parse('foo*bar');
-      expect(expr).to.be.a(ol.expression.Math);
+      var expr = ol.expr.parse('foo*bar');
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate({foo: 10, bar: 20})).to.be(200);
     });
 
     it('consumes whitespace as expected with *', function() {
-      var expr = ol.expression.parse(' foo * bar ');
-      expect(expr).to.be.a(ol.expression.Math);
+      var expr = ol.expr.parse(' foo * bar ');
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate({foo: 15, bar: 2})).to.be(30);
     });
 
     it('parses / operator', function() {
-      var expr = ol.expression.parse('foo/12');
-      expect(expr).to.be.a(ol.expression.Math);
+      var expr = ol.expr.parse('foo/12');
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate({foo: 10})).to.be(10 / 12);
     });
 
     it('consumes whitespace as expected with /', function() {
-      var expr = ol.expression.parse(' 4 / bar ');
-      expect(expr).to.be.a(ol.expression.Math);
+      var expr = ol.expr.parse(' 4 / bar ');
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate({bar: 3})).to.be(4 / 3);
     });
 
     it('parses % operator', function() {
-      var expr = ol.expression.parse('12%foo');
-      expect(expr).to.be.a(ol.expression.Math);
+      var expr = ol.expr.parse('12%foo');
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate({foo: 10})).to.be(2);
     });
 
     it('consumes whitespace as expected with %', function() {
-      var expr = ol.expression.parse(' 4 %bar ');
-      expect(expr).to.be.a(ol.expression.Math);
+      var expr = ol.expr.parse(' 4 %bar ');
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate({bar: 3})).to.be(1);
     });
 
@@ -208,26 +208,26 @@ describe('ol.expression.parse()', function() {
     // http://www.ecma-international.org/ecma-262/5.1/#sec-11.6
 
     it('parses + operator', function() {
-      var expr = ol.expression.parse('foo+bar');
-      expect(expr).to.be.a(ol.expression.Math);
+      var expr = ol.expr.parse('foo+bar');
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate({foo: 10, bar: 20})).to.be(30);
     });
 
     it('consumes whitespace as expected with +', function() {
-      var expr = ol.expression.parse(' foo +10 ');
-      expect(expr).to.be.a(ol.expression.Math);
+      var expr = ol.expr.parse(' foo +10 ');
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate({foo: 15})).to.be(25);
     });
 
     it('parses - operator', function() {
-      var expr = ol.expression.parse('foo-bar');
-      expect(expr).to.be.a(ol.expression.Math);
+      var expr = ol.expr.parse('foo-bar');
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate({foo: 10, bar: 20})).to.be(-10);
     });
 
     it('consumes whitespace as expected with -', function() {
-      var expr = ol.expression.parse(' foo- 10 ');
-      expect(expr).to.be.a(ol.expression.Math);
+      var expr = ol.expr.parse(' foo- 10 ');
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate({foo: 15})).to.be(5);
     });
 
@@ -242,44 +242,44 @@ describe('ol.expression.parse()', function() {
     // http://www.ecma-international.org/ecma-262/5.1/#sec-11.8
 
     it('parses < operator', function() {
-      var expr = ol.expression.parse('foo<bar');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse('foo<bar');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 10, bar: 20})).to.be(true);
       expect(expr.evaluate({foo: 100, bar: 20})).to.be(false);
     });
 
     it('consumes whitespace as expected with <', function() {
-      var expr = ol.expression.parse(' foo <10 ');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse(' foo <10 ');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 15})).to.be(false);
       expect(expr.evaluate({foo: 5})).to.be(true);
     });
 
     it('parses > operator', function() {
-      var expr = ol.expression.parse('foo>bar');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse('foo>bar');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 10, bar: 20})).to.be(false);
       expect(expr.evaluate({foo: 100, bar: 20})).to.be(true);
     });
 
     it('consumes whitespace as expected with >', function() {
-      var expr = ol.expression.parse(' foo> 10 ');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse(' foo> 10 ');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 15})).to.be(true);
       expect(expr.evaluate({foo: 5})).to.be(false);
     });
 
     it('parses <= operator', function() {
-      var expr = ol.expression.parse('foo<=bar');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse('foo<=bar');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 10, bar: 20})).to.be(true);
       expect(expr.evaluate({foo: 100, bar: 20})).to.be(false);
       expect(expr.evaluate({foo: 20, bar: 20})).to.be(true);
     });
 
     it('consumes whitespace as expected with <=', function() {
-      var expr = ol.expression.parse(' foo<= 10 ');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse(' foo<= 10 ');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 15})).to.be(false);
       expect(expr.evaluate({foo: 5})).to.be(true);
       expect(expr.evaluate({foo: 10})).to.be(true);
@@ -287,9 +287,9 @@ describe('ol.expression.parse()', function() {
 
     it('throws for invalid spacing with <=', function() {
       expect(function() {
-        ol.expression.parse(' foo< = 10 ');
+        ol.expr.parse(' foo< = 10 ');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('=');
         expect(token.index).to.be(6);
@@ -297,16 +297,16 @@ describe('ol.expression.parse()', function() {
     });
 
     it('parses >= operator', function() {
-      var expr = ol.expression.parse('foo>=bar');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse('foo>=bar');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 10, bar: 20})).to.be(false);
       expect(expr.evaluate({foo: 100, bar: 20})).to.be(true);
       expect(expr.evaluate({foo: 20, bar: 20})).to.be(true);
     });
 
     it('consumes whitespace as expected with >=', function() {
-      var expr = ol.expression.parse(' foo >=10 ');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse(' foo >=10 ');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 15})).to.be(true);
       expect(expr.evaluate({foo: 5})).to.be(false);
       expect(expr.evaluate({foo: 10})).to.be(true);
@@ -314,9 +314,9 @@ describe('ol.expression.parse()', function() {
 
     it('throws for invalid spacing with >=', function() {
       expect(function() {
-        ol.expression.parse(' 10 > =foo ');
+        ol.expr.parse(' 10 > =foo ');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('=');
         expect(token.index).to.be(6);
@@ -329,16 +329,16 @@ describe('ol.expression.parse()', function() {
     // http://www.ecma-international.org/ecma-262/5.1/#sec-11.9
 
     it('parses == operator', function() {
-      var expr = ol.expression.parse('foo==42');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse('foo==42');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 42})).to.be(true);
       expect(expr.evaluate({foo: 41})).to.be(false);
       expect(expr.evaluate({foo: '42'})).to.be(true);
     });
 
     it('consumes whitespace as expected with ==', function() {
-      var expr = ol.expression.parse(' 42 ==foo ');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse(' 42 ==foo ');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 42})).to.be(true);
       expect(expr.evaluate({foo: 41})).to.be(false);
       expect(expr.evaluate({foo: '42'})).to.be(true);
@@ -346,9 +346,9 @@ describe('ol.expression.parse()', function() {
 
     it('throws for invalid spacing with ==', function() {
       expect(function() {
-        ol.expression.parse(' 10 = =foo ');
+        ol.expr.parse(' 10 = =foo ');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('=');
         expect(token.index).to.be(4);
@@ -356,16 +356,16 @@ describe('ol.expression.parse()', function() {
     });
 
     it('parses != operator', function() {
-      var expr = ol.expression.parse('foo!=42');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse('foo!=42');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 42})).to.be(false);
       expect(expr.evaluate({foo: 41})).to.be(true);
       expect(expr.evaluate({foo: '42'})).to.be(false);
     });
 
     it('consumes whitespace as expected with !=', function() {
-      var expr = ol.expression.parse(' 42 !=foo ');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse(' 42 !=foo ');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 42})).to.be(false);
       expect(expr.evaluate({foo: 41})).to.be(true);
       expect(expr.evaluate({foo: '42'})).to.be(false);
@@ -373,9 +373,9 @@ describe('ol.expression.parse()', function() {
 
     it('throws for invalid spacing with !=', function() {
       expect(function() {
-        ol.expression.parse(' 10! =foo ');
+        ol.expr.parse(' 10! =foo ');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('!');
         expect(token.index).to.be(3);
@@ -383,16 +383,16 @@ describe('ol.expression.parse()', function() {
     });
 
     it('parses === operator', function() {
-      var expr = ol.expression.parse('42===foo');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse('42===foo');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 42})).to.be(true);
       expect(expr.evaluate({foo: 41})).to.be(false);
       expect(expr.evaluate({foo: '42'})).to.be(false);
     });
 
     it('consumes whitespace as expected with ===', function() {
-      var expr = ol.expression.parse(' foo ===42 ');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse(' foo ===42 ');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 42})).to.be(true);
       expect(expr.evaluate({foo: 41})).to.be(false);
       expect(expr.evaluate({foo: '42'})).to.be(false);
@@ -400,9 +400,9 @@ describe('ol.expression.parse()', function() {
 
     it('throws for invalid spacing with ===', function() {
       expect(function() {
-        ol.expression.parse(' 10 = == foo ');
+        ol.expr.parse(' 10 = == foo ');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('=');
         expect(token.index).to.be(4);
@@ -410,16 +410,16 @@ describe('ol.expression.parse()', function() {
     });
 
     it('parses !== operator', function() {
-      var expr = ol.expression.parse('foo!==42');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse('foo!==42');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 42})).to.be(false);
       expect(expr.evaluate({foo: 41})).to.be(true);
       expect(expr.evaluate({foo: '42'})).to.be(true);
     });
 
     it('consumes whitespace as expected with !==', function() {
-      var expr = ol.expression.parse(' 42 !== foo ');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      var expr = ol.expr.parse(' 42 !== foo ');
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate({foo: 42})).to.be(false);
       expect(expr.evaluate({foo: 41})).to.be(true);
       expect(expr.evaluate({foo: '42'})).to.be(true);
@@ -427,9 +427,9 @@ describe('ol.expression.parse()', function() {
 
     it('throws for invalid spacing with !==', function() {
       expect(function() {
-        ol.expression.parse(' 10 != = foo ');
+        ol.expr.parse(' 10 != = foo ');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('=');
         expect(token.index).to.be(7);
@@ -446,8 +446,8 @@ describe('ol.expression.parse()', function() {
     // http://www.ecma-international.org/ecma-262/5.1/#sec-11.11
 
     it('parses && operator', function() {
-      var expr = ol.expression.parse('foo&&bar');
-      expect(expr).to.be.a(ol.expression.Logical);
+      var expr = ol.expr.parse('foo&&bar');
+      expect(expr).to.be.a(ol.expr.Logical);
       expect(expr.evaluate({foo: true, bar: true})).to.be(true);
       expect(expr.evaluate({foo: true, bar: false})).to.be(false);
       expect(expr.evaluate({foo: false, bar: true})).to.be(false);
@@ -455,8 +455,8 @@ describe('ol.expression.parse()', function() {
     });
 
     it('consumes space as expected with &&', function() {
-      var expr = ol.expression.parse(' foo && bar ');
-      expect(expr).to.be.a(ol.expression.Logical);
+      var expr = ol.expr.parse(' foo && bar ');
+      expect(expr).to.be.a(ol.expr.Logical);
       expect(expr.evaluate({foo: true, bar: true})).to.be(true);
       expect(expr.evaluate({foo: true, bar: false})).to.be(false);
       expect(expr.evaluate({foo: false, bar: true})).to.be(false);
@@ -465,9 +465,9 @@ describe('ol.expression.parse()', function() {
 
     it('throws for invalid spacing with &&', function() {
       expect(function() {
-        ol.expression.parse('true & & false');
+        ol.expr.parse('true & & false');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('&');
         expect(token.index).to.be(5);
@@ -475,8 +475,8 @@ describe('ol.expression.parse()', function() {
     });
 
     it('parses || operator', function() {
-      var expr = ol.expression.parse('foo||bar');
-      expect(expr).to.be.a(ol.expression.Logical);
+      var expr = ol.expr.parse('foo||bar');
+      expect(expr).to.be.a(ol.expr.Logical);
       expect(expr.evaluate({foo: true, bar: true})).to.be(true);
       expect(expr.evaluate({foo: true, bar: false})).to.be(true);
       expect(expr.evaluate({foo: false, bar: true})).to.be(true);
@@ -484,8 +484,8 @@ describe('ol.expression.parse()', function() {
     });
 
     it('consumes space as expected with ||', function() {
-      var expr = ol.expression.parse(' foo || bar ');
-      expect(expr).to.be.a(ol.expression.Logical);
+      var expr = ol.expr.parse(' foo || bar ');
+      expect(expr).to.be.a(ol.expr.Logical);
       expect(expr.evaluate({foo: true, bar: true})).to.be(true);
       expect(expr.evaluate({foo: true, bar: false})).to.be(true);
       expect(expr.evaluate({foo: false, bar: true})).to.be(true);
@@ -494,9 +494,9 @@ describe('ol.expression.parse()', function() {
 
     it('throws for invalid spacing with ||', function() {
       expect(function() {
-        ol.expression.parse('true | | false');
+        ol.expr.parse('true | | false');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('|');
         expect(token.index).to.be(5);
@@ -522,10 +522,10 @@ describe('ol.expression.parse()', function() {
 
 });
 
-describe('ol.expression.lib', function() {
+describe('ol.expr.lib', function() {
 
-  var parse = ol.expression.parse;
-  var evaluate = ol.expression.evaluateFeature;
+  var parse = ol.expr.parse;
+  var evaluate = ol.expr.evaluateFeature;
 
   describe('extent()', function() {
 
@@ -611,48 +611,50 @@ describe('ol.expression.lib', function() {
 
 });
 
-describe('ol.expression.register()', function() {
+describe('ol.expr.register()', function() {
 
   var spy;
   beforeEach(function() {
     spy = sinon.spy();
   });
 
-  it('registers custom functions in ol.expression.lib', function() {
-    ol.expression.register('someFunc', spy);
-    expect(ol.expression.lib.someFunc).to.be(spy);
+  it('registers custom functions in ol.expr.lib', function() {
+    ol.expr.register('someFunc', spy);
+    expect(ol.expr.lib.someFunc).to.be(spy);
   });
 
   it('allows custom functions to be called', function() {
-    ol.expression.register('myFunc', spy);
-    var expr = ol.expression.parse('myFunc(42)');
-    expr.evaluate(null, ol.expression.lib);
+    ol.expr.register('myFunc', spy);
+    var expr = ol.expr.parse('myFunc(42)');
+    expr.evaluate(null, ol.expr.lib);
     expect(spy.calledOnce);
     expect(spy.calledWithExactly(42));
   });
 
   it('allows custom functions to be called with identifiers', function() {
-    ol.expression.register('myFunc', spy);
-    var expr = ol.expression.parse('myFunc(foo, 42)');
-    expr.evaluate({foo: 'bar'}, ol.expression.lib);
+    ol.expr.register('myFunc', spy);
+    var expr = ol.expr.parse('myFunc(foo, 42)');
+    expr.evaluate({foo: 'bar'}, ol.expr.lib);
     expect(spy.calledOnce);
     expect(spy.calledWithExactly('bar', 42));
   });
 
   it('allows custom functions to be called with custom this obj', function() {
-    ol.expression.register('myFunc', spy);
-    var expr = ol.expression.parse('myFunc(foo, 42)');
+    ol.expr.register('myFunc', spy);
+    var expr = ol.expr.parse('myFunc(foo, 42)');
     var that = {};
-    expr.evaluate({foo: 'bar'}, ol.expression.lib, that);
+    expr.evaluate({foo: 'bar'}, ol.expr.lib, that);
     expect(spy.calledOnce);
     expect(spy.calledWithExactly('bar', 42));
     expect(spy.calledOn(that));
   });
 
-  it('allows overriding existing ol.expression.lib functions', function() {
-    expect(ol.expression.lib.extent).not.to.be(spy);
-    ol.expression.register('extent', spy);
-    expect(ol.expression.lib.extent).to.be(spy);
+  it('allows overriding existing ol.expr.lib functions', function() {
+    var orig = ol.expr.lib.extent;
+    expect(orig).not.to.be(spy);
+    ol.expr.register('extent', spy);
+    expect(ol.expr.lib.extent).to.be(spy);
+    ol.expr.lib.extent = orig;
   });
 
 });
@@ -660,18 +662,18 @@ describe('ol.expression.register()', function() {
 
 
 goog.require('ol.Feature');
-goog.require('ol.expression');
-goog.require('ol.expression.Call');
-goog.require('ol.expression.Comparison');
-goog.require('ol.expression.Expression');
-goog.require('ol.expression.Identifier');
-goog.require('ol.expression.Literal');
-goog.require('ol.expression.Logical');
-goog.require('ol.expression.Math');
-goog.require('ol.expression.Member');
-goog.require('ol.expression.Not');
-goog.require('ol.expression.TokenType');
-goog.require('ol.expression.UnexpectedToken');
+goog.require('ol.expr');
+goog.require('ol.expr.Call');
+goog.require('ol.expr.Comparison');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Identifier');
+goog.require('ol.expr.Literal');
+goog.require('ol.expr.Logical');
+goog.require('ol.expr.Math');
+goog.require('ol.expr.Member');
+goog.require('ol.expr.Not');
+goog.require('ol.expr.TokenType');
+goog.require('ol.expr.UnexpectedToken');
 goog.require('ol.geom.LineString');
 goog.require('ol.geom.Point');
 goog.require('ol.geom.Polygon');
diff --git a/test/spec/ol/expr/expressions.test.js b/test/spec/ol/expr/expressions.test.js
new file mode 100644
index 0000000000..c64ea7cd52
--- /dev/null
+++ b/test/spec/ol/expr/expressions.test.js
@@ -0,0 +1,638 @@
+goog.provide('ol.test.expression.Expression');
+
+
+describe('ol.expr.Call', function() {
+
+  describe('constructor', function() {
+    it('creates a new expression', function() {
+      var expr = new ol.expr.Call(
+          new ol.expr.Identifier('sqrt'),
+          [new ol.expr.Literal(42)]);
+      expect(expr).to.be.a(ol.expr.Expression);
+      expect(expr).to.be.a(ol.expr.Call);
+    });
+  });
+
+  describe('#evaluate()', function() {
+    var fns = {
+      sqrt: function(value) {
+        return Math.sqrt(value);
+      },
+      strConcat: function() {
+        return Array.prototype.join.call(arguments, '');
+      },
+      discouraged: function() {
+        return this.message;
+      }
+    };
+
+    it('calls method on scope with literal args', function() {
+      var expr = new ol.expr.Call(
+          new ol.expr.Identifier('sqrt'),
+          [new ol.expr.Literal(42)]);
+      expect(expr.evaluate(fns)).to.be(Math.sqrt(42));
+    });
+
+    it('accepts a separate scope for functions', function() {
+      var expr = new ol.expr.Call(
+          new ol.expr.Identifier('sqrt'),
+          [new ol.expr.Identifier('foo')]);
+      expect(expr.evaluate({foo: 42}, fns)).to.be(Math.sqrt(42));
+    });
+
+    it('accepts multiple expression arguments', function() {
+      var expr = new ol.expr.Call(
+          new ol.expr.Identifier('strConcat'),
+          [
+            new ol.expr.Identifier('foo'),
+            new ol.expr.Literal(' comes after '),
+            new ol.expr.Math(
+                ol.expr.MathOp.SUBTRACT,
+                new ol.expr.Identifier('foo'),
+                new ol.expr.Literal(1))
+          ]);
+      expect(expr.evaluate({foo: 42}, fns)).to.be('42 comes after 41');
+    });
+
+    it('accepts optional this arg', function() {
+      var expr = new ol.expr.Call(
+          new ol.expr.Identifier('discouraged'), []);
+
+      var thisArg = {
+        message: 'avoid this'
+      };
+
+      expect(expr.evaluate(fns, null, thisArg)).to.be('avoid this');
+    });
+
+  });
+
+  var callee = new ol.expr.Identifier('sqrt');
+  var args = [new ol.expr.Literal(42)];
+  var expr = new ol.expr.Call(callee, args);
+
+  describe('#getArgs()', function() {
+    it('gets the callee expression', function() {
+      expect(expr.getArgs()).to.be(args);
+    });
+  });
+
+  describe('#getCallee()', function() {
+    it('gets the callee expression', function() {
+      expect(expr.getCallee()).to.be(callee);
+    });
+  });
+
+});
+
+
+describe('ol.expr.Comparison', function() {
+
+  describe('constructor', function() {
+    it('creates a new expression', function() {
+      var expr = new ol.expr.Comparison(
+          ol.expr.ComparisonOp.EQ,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(42));
+      expect(expr).to.be.a(ol.expr.Expression);
+      expect(expr).to.be.a(ol.expr.Comparison);
+    });
+  });
+
+  describe('#evaluate()', function() {
+    it('compares with ==', function() {
+      var expr = new ol.expr.Comparison(
+          ol.expr.ComparisonOp.EQ,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(42));
+
+      expect(expr.evaluate({foo: 42})).to.be(true);
+      expect(expr.evaluate({foo: '42'})).to.be(true);
+      expect(expr.evaluate({foo: true})).to.be(false);
+      expect(expr.evaluate({bar: true})).to.be(false);
+    });
+
+    it('compares with !=', function() {
+      var expr = new ol.expr.Comparison(
+          ol.expr.ComparisonOp.NEQ,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(42));
+
+      expect(expr.evaluate({foo: 42})).to.be(false);
+      expect(expr.evaluate({foo: '42'})).to.be(false);
+      expect(expr.evaluate({foo: true})).to.be(true);
+      expect(expr.evaluate({bar: true})).to.be(true);
+    });
+
+    it('compares with ===', function() {
+      var expr = new ol.expr.Comparison(
+          ol.expr.ComparisonOp.STRICT_EQ,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(42));
+
+      expect(expr.evaluate({foo: 42})).to.be(true);
+      expect(expr.evaluate({foo: '42'})).to.be(false);
+      expect(expr.evaluate({foo: true})).to.be(false);
+      expect(expr.evaluate({bar: true})).to.be(false);
+    });
+
+    it('compares with !==', function() {
+      var expr = new ol.expr.Comparison(
+          ol.expr.ComparisonOp.STRICT_NEQ,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(42));
+
+      expect(expr.evaluate({foo: 42})).to.be(false);
+      expect(expr.evaluate({foo: '42'})).to.be(true);
+      expect(expr.evaluate({foo: true})).to.be(true);
+      expect(expr.evaluate({bar: true})).to.be(true);
+    });
+
+    it('compares with >', function() {
+      var expr = new ol.expr.Comparison(
+          ol.expr.ComparisonOp.GT,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(42));
+
+      expect(expr.evaluate({foo: 42})).to.be(false);
+      expect(expr.evaluate({foo: 41})).to.be(false);
+      expect(expr.evaluate({foo: 43})).to.be(true);
+    });
+
+    it('compares with <', function() {
+      var expr = new ol.expr.Comparison(
+          ol.expr.ComparisonOp.LT,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(42));
+
+      expect(expr.evaluate({foo: 42})).to.be(false);
+      expect(expr.evaluate({foo: 41})).to.be(true);
+      expect(expr.evaluate({foo: 43})).to.be(false);
+    });
+
+    it('compares with >=', function() {
+      var expr = new ol.expr.Comparison(
+          ol.expr.ComparisonOp.GTE,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(42));
+
+      expect(expr.evaluate({foo: 42})).to.be(true);
+      expect(expr.evaluate({foo: 41})).to.be(false);
+      expect(expr.evaluate({foo: 43})).to.be(true);
+    });
+
+    it('compares with <=', function() {
+      var expr = new ol.expr.Comparison(
+          ol.expr.ComparisonOp.LTE,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(42));
+
+      expect(expr.evaluate({foo: 42})).to.be(true);
+      expect(expr.evaluate({foo: 41})).to.be(true);
+      expect(expr.evaluate({foo: 43})).to.be(false);
+    });
+  });
+
+  describe('#isValidOp()', function() {
+    it('determines if a string is a valid operator', function() {
+      expect(ol.expr.Comparison.isValidOp('<')).to.be(true);
+      expect(ol.expr.Comparison.isValidOp('<')).to.be(true);
+      expect(ol.expr.Comparison.isValidOp('<=')).to.be(true);
+      expect(ol.expr.Comparison.isValidOp('<=')).to.be(true);
+      expect(ol.expr.Comparison.isValidOp('==')).to.be(true);
+      expect(ol.expr.Comparison.isValidOp('!=')).to.be(true);
+      expect(ol.expr.Comparison.isValidOp('===')).to.be(true);
+      expect(ol.expr.Comparison.isValidOp('!==')).to.be(true);
+
+      expect(ol.expr.Comparison.isValidOp('')).to.be(false);
+      expect(ol.expr.Comparison.isValidOp('+')).to.be(false);
+      expect(ol.expr.Comparison.isValidOp('-')).to.be(false);
+      expect(ol.expr.Comparison.isValidOp('&&')).to.be(false);
+    });
+  });
+
+  var op = ol.expr.ComparisonOp.LTE;
+  var left = new ol.expr.Identifier('foo');
+  var right = new ol.expr.Literal(42);
+  var expr = new ol.expr.Comparison(op, left, right);
+
+  describe('#getOperator()', function() {
+    it('gets the operator', function() {
+      expect(expr.getOperator()).to.be(op);
+    });
+  });
+
+  describe('#getLeft()', function() {
+    it('gets the left expression', function() {
+      expect(expr.getLeft()).to.be(left);
+    });
+  });
+
+  describe('#getRight()', function() {
+    it('gets the right expression', function() {
+      expect(expr.getRight()).to.be(right);
+    });
+  });
+
+});
+
+describe('ol.expr.Identifier', function() {
+
+  describe('constructor', function() {
+    it('creates a new expression', function() {
+      var expr = new ol.expr.Identifier('foo');
+      expect(expr).to.be.a(ol.expr.Expression);
+      expect(expr).to.be.a(ol.expr.Identifier);
+    });
+  });
+
+  describe('#evaluate()', function() {
+    it('returns a number from the scope', function() {
+      var expr = new ol.expr.Identifier('foo');
+      expect(expr.evaluate({foo: 42})).to.be(42);
+    });
+
+    it('returns a string from the scope', function() {
+      var expr = new ol.expr.Identifier('foo');
+      expect(expr.evaluate({foo: 'chicken'})).to.be('chicken');
+    });
+
+    it('returns a boolean from the scope', function() {
+      var expr = new ol.expr.Identifier('bar');
+      expect(expr.evaluate({bar: false})).to.be(false);
+      expect(expr.evaluate({bar: true})).to.be(true);
+    });
+
+    it('returns a null from the scope', function() {
+      var expr = new ol.expr.Identifier('nada');
+      expect(expr.evaluate({nada: null})).to.be(null);
+    });
+
+    it('works for unicode identifiers', function() {
+      var expr = new ol.expr.Identifier('\u03c0');
+      expect(expr.evaluate({'\u03c0': Math.PI})).to.be(Math.PI);
+    });
+  });
+
+  describe('#getName()', function() {
+    var expr = new ol.expr.Identifier('asdf');
+    expect(expr.getName()).to.be('asdf');
+  });
+
+});
+
+describe('ol.expr.Literal', function() {
+
+  describe('constructor', function() {
+    it('creates a new expression', function() {
+      var expr = new ol.expr.Literal(true);
+      expect(expr).to.be.a(ol.expr.Expression);
+      expect(expr).to.be.a(ol.expr.Literal);
+    });
+  });
+
+  describe('#evaluate()', function() {
+    it('works for numeric literal', function() {
+      var expr = new ol.expr.Literal(42e-11);
+      expect(expr.evaluate()).to.be(4.2e-10);
+    });
+
+    it('works for string literal', function() {
+      var expr = new ol.expr.Literal('asdf');
+      expect(expr.evaluate()).to.be('asdf');
+    });
+
+    it('works for boolean literal', function() {
+      var expr = new ol.expr.Literal(true);
+      expect(expr.evaluate()).to.be(true);
+    });
+
+    it('works for null literal', function() {
+      var expr = new ol.expr.Literal(null);
+      expect(expr.evaluate()).to.be(null);
+    });
+  });
+
+  describe('#getValue()', function() {
+    var expr = new ol.expr.Literal('asdf');
+    expect(expr.getValue()).to.be('asdf');
+  });
+
+});
+
+
+describe('ol.expr.Logical', function() {
+
+  describe('constructor', function() {
+    it('creates a new expression', function() {
+      var expr = new ol.expr.Logical(
+          ol.expr.LogicalOp.OR,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Identifier('bar'));
+      expect(expr).to.be.a(ol.expr.Expression);
+      expect(expr).to.be.a(ol.expr.Logical);
+    });
+  });
+
+  describe('#evaluate()', function() {
+    it('applies || to resolved identifiers', function() {
+      var expr = new ol.expr.Logical(
+          ol.expr.LogicalOp.OR,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Identifier('bar'));
+
+      expect(expr.evaluate({foo: true, bar: true})).to.be(true);
+      expect(expr.evaluate({foo: true, bar: false})).to.be(true);
+      expect(expr.evaluate({foo: false, bar: true})).to.be(true);
+      expect(expr.evaluate({foo: false, bar: false})).to.be(false);
+    });
+
+    it('applies && to resolved identifiers', function() {
+      var expr = new ol.expr.Logical(
+          ol.expr.LogicalOp.AND,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Identifier('bar'));
+
+      expect(expr.evaluate({foo: true, bar: true})).to.be(true);
+      expect(expr.evaluate({foo: true, bar: false})).to.be(false);
+      expect(expr.evaluate({foo: false, bar: true})).to.be(false);
+      expect(expr.evaluate({foo: false, bar: false})).to.be(false);
+    });
+  });
+
+  describe('#isValidOp()', function() {
+    it('determines if a string is a valid operator', function() {
+      expect(ol.expr.Logical.isValidOp('||')).to.be(true);
+      expect(ol.expr.Logical.isValidOp('&&')).to.be(true);
+
+      expect(ol.expr.Logical.isValidOp('')).to.be(false);
+      expect(ol.expr.Logical.isValidOp('+')).to.be(false);
+      expect(ol.expr.Logical.isValidOp('<')).to.be(false);
+      expect(ol.expr.Logical.isValidOp('|')).to.be(false);
+    });
+  });
+
+  var op = ol.expr.LogicalOp.AND;
+  var left = new ol.expr.Identifier('foo');
+  var right = new ol.expr.Literal(false);
+  var expr = new ol.expr.Logical(op, left, right);
+
+  describe('#getOperator()', function() {
+    it('gets the operator', function() {
+      expect(expr.getOperator()).to.be(op);
+    });
+  });
+
+  describe('#getLeft()', function() {
+    it('gets the left expression', function() {
+      expect(expr.getLeft()).to.be(left);
+    });
+  });
+
+  describe('#getRight()', function() {
+    it('gets the right expression', function() {
+      expect(expr.getRight()).to.be(right);
+    });
+  });
+
+});
+
+describe('ol.expr.Math', function() {
+
+  describe('constructor', function() {
+    it('creates a new expression', function() {
+      var expr = new ol.expr.Math(
+          ol.expr.MathOp.ADD,
+          new ol.expr.Literal(40),
+          new ol.expr.Literal(2));
+      expect(expr).to.be.a(ol.expr.Expression);
+      expect(expr).to.be.a(ol.expr.Math);
+    });
+  });
+
+  describe('#evaluate()', function() {
+    it('does + with numeric literal', function() {
+      var expr = new ol.expr.Math(
+          ol.expr.MathOp.ADD,
+          new ol.expr.Literal(40),
+          new ol.expr.Literal(2));
+
+      expect(expr.evaluate()).to.be(42);
+    });
+
+    it('does + with string literal (note: subject to change)', function() {
+      var expr = new ol.expr.Math(
+          ol.expr.MathOp.ADD,
+          new ol.expr.Literal('foo'),
+          new ol.expr.Literal('bar'));
+
+      expect(expr.evaluate()).to.be('foobar');
+    });
+
+    it('does + with identifiers', function() {
+      var expr = new ol.expr.Math(
+          ol.expr.MathOp.ADD,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Identifier('bar'));
+
+      expect(expr.evaluate({foo: 40, bar: 2})).to.be(42);
+    });
+
+    it('does - with identifiers', function() {
+      var expr = new ol.expr.Math(
+          ol.expr.MathOp.SUBTRACT,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(2));
+
+      expect(expr.evaluate({foo: 40})).to.be(38);
+    });
+
+    it('casts to number with - (note: this may throw later)', function() {
+      var expr = new ol.expr.Math(
+          ol.expr.MathOp.SUBTRACT,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(2));
+
+      expect(expr.evaluate({foo: '40'})).to.be(38);
+    });
+
+    it('does * with identifiers', function() {
+      var expr = new ol.expr.Math(
+          ol.expr.MathOp.MULTIPLY,
+          new ol.expr.Literal(2),
+          new ol.expr.Identifier('foo'));
+
+      expect(expr.evaluate({foo: 21})).to.be(42);
+    });
+
+    it('casts to number with * (note: this may throw later)', function() {
+      var expr = new ol.expr.Math(
+          ol.expr.MathOp.MULTIPLY,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(2));
+
+      expect(expr.evaluate({foo: '21'})).to.be(42);
+    });
+
+    it('does % with identifiers', function() {
+      var expr = new ol.expr.Math(
+          ol.expr.MathOp.MOD,
+          new ol.expr.Literal(97),
+          new ol.expr.Identifier('foo'));
+
+      expect(expr.evaluate({foo: 55})).to.be(42);
+    });
+
+    it('casts to number with % (note: this may throw later)', function() {
+      var expr = new ol.expr.Math(
+          ol.expr.MathOp.MOD,
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Literal(100));
+
+      expect(expr.evaluate({foo: '150'})).to.be(50);
+    });
+  });
+
+  describe('#isValidOp()', function() {
+    it('determines if a string is a valid operator', function() {
+      expect(ol.expr.Math.isValidOp('+')).to.be(true);
+      expect(ol.expr.Math.isValidOp('-')).to.be(true);
+      expect(ol.expr.Math.isValidOp('*')).to.be(true);
+      expect(ol.expr.Math.isValidOp('/')).to.be(true);
+      expect(ol.expr.Math.isValidOp('%')).to.be(true);
+
+      expect(ol.expr.Math.isValidOp('')).to.be(false);
+      expect(ol.expr.Math.isValidOp('|')).to.be(false);
+      expect(ol.expr.Math.isValidOp('&')).to.be(false);
+      expect(ol.expr.Math.isValidOp('<')).to.be(false);
+      expect(ol.expr.Math.isValidOp('||')).to.be(false);
+      expect(ol.expr.Math.isValidOp('.')).to.be(false);
+    });
+  });
+
+  var op = ol.expr.MathOp.MOD;
+  var left = new ol.expr.Identifier('foo');
+  var right = new ol.expr.Literal(20);
+  var expr = new ol.expr.Math(op, left, right);
+
+  describe('#getOperator()', function() {
+    it('gets the operator', function() {
+      expect(expr.getOperator()).to.be(op);
+    });
+  });
+
+  describe('#getLeft()', function() {
+    it('gets the left expression', function() {
+      expect(expr.getLeft()).to.be(left);
+    });
+  });
+
+  describe('#getRight()', function() {
+    it('gets the right expression', function() {
+      expect(expr.getRight()).to.be(right);
+    });
+  });
+
+});
+
+describe('ol.expr.Member', function() {
+  describe('constructor', function() {
+    it('creates a new expression', function() {
+      var expr = new ol.expr.Member(
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Identifier('bar'));
+
+      expect(expr).to.be.a(ol.expr.Expression);
+      expect(expr).to.be.a(ol.expr.Member);
+    });
+  });
+
+  describe('#evaluate()', function() {
+    it('accesses an object property', function() {
+
+      var expr = new ol.expr.Member(
+          new ol.expr.Identifier('foo'),
+          new ol.expr.Identifier('bar'));
+
+      var scope = {foo: {bar: 42}};
+      expect(expr.evaluate(scope)).to.be(42);
+    });
+  });
+
+  var object = new ol.expr.Identifier('foo');
+  var property = new ol.expr.Identifier('bar');
+  var expr = new ol.expr.Member(object, property);
+
+  describe('#getObject()', function() {
+    expect(expr.getObject()).to.be(object);
+  });
+
+  describe('#getProperty()', function() {
+    expect(expr.getProperty()).to.be(property);
+  });
+
+});
+
+
+describe('ol.expr.Not', function() {
+
+  describe('constructor', function() {
+    it('creates a new expression', function() {
+      var expr = new ol.expr.Not(
+          new ol.expr.Literal(true));
+      expect(expr).to.be.a(ol.expr.Expression);
+      expect(expr).to.be.a(ol.expr.Not);
+    });
+  });
+
+  describe('#evaluate()', function() {
+    it('returns the logical complement', function() {
+      var expr = new ol.expr.Not(new ol.expr.Literal(true));
+      expect(expr.evaluate()).to.be(false);
+
+      expr = new ol.expr.Not(new ol.expr.Literal(false));
+      expect(expr.evaluate()).to.be(true);
+    });
+
+    it('negates a truthy string', function() {
+      var expr = new ol.expr.Not(new ol.expr.Literal('asdf'));
+      expect(expr.evaluate()).to.be(false);
+    });
+
+    it('negates a falsy string', function() {
+      var expr = new ol.expr.Not(new ol.expr.Literal(''));
+      expect(expr.evaluate()).to.be(true);
+    });
+
+    it('negates a truthy number', function() {
+      var expr = new ol.expr.Not(new ol.expr.Literal(42));
+      expect(expr.evaluate()).to.be(false);
+    });
+
+    it('negates a falsy number', function() {
+      var expr = new ol.expr.Not(new ol.expr.Literal(NaN));
+      expect(expr.evaluate()).to.be(true);
+    });
+  });
+
+  describe('#getArgument()', function() {
+    var argument = new ol.expr.Literal(true);
+    var expr = new ol.expr.Not(argument);
+    expect(expr.getArgument()).to.be(argument);
+  });
+
+});
+
+
+goog.require('ol.expr.Call');
+goog.require('ol.expr.Comparison');
+goog.require('ol.expr.ComparisonOp');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Identifier');
+goog.require('ol.expr.Literal');
+goog.require('ol.expr.Logical');
+goog.require('ol.expr.LogicalOp');
+goog.require('ol.expr.Math');
+goog.require('ol.expr.MathOp');
+goog.require('ol.expr.Member');
+goog.require('ol.expr.Not');
diff --git a/test/spec/ol/expression/lexer.test.js b/test/spec/ol/expr/lexer.test.js
similarity index 67%
rename from test/spec/ol/expression/lexer.test.js
rename to test/spec/ol/expr/lexer.test.js
index 828a58726c..2bf0b86b76 100644
--- a/test/spec/ol/expression/lexer.test.js
+++ b/test/spec/ol/expr/lexer.test.js
@@ -1,11 +1,11 @@
 goog.provide('ol.test.expression.Lexer');
 
-describe('ol.expression.Lexer', function() {
+describe('ol.expr.Lexer', function() {
 
   describe('constructor', function() {
     it('creates a new lexer', function() {
-      var lexer = new ol.expression.Lexer('foo');
-      expect(lexer).to.be.a(ol.expression.Lexer);
+      var lexer = new ol.expr.Lexer('foo');
+      expect(lexer).to.be.a(ol.expr.Lexer);
     });
   });
 
@@ -13,30 +13,30 @@ describe('ol.expression.Lexer', function() {
 
     it('returns one token at a time', function() {
       var source = 'foo === "bar"';
-      var lexer = new ol.expression.Lexer(source);
+      var lexer = new ol.expr.Lexer(source);
 
       // scan first token
       var token = lexer.next();
-      expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+      expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
       expect(token.value).to.be('foo');
 
       // scan second token
       token = lexer.next();
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
       expect(token.value).to.be('===');
 
       // scan third token
       token = lexer.next();
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
       expect(token.value).to.be('bar');
 
       // scan again
       token = lexer.next();
-      expect(token.type).to.be(ol.expression.TokenType.EOF);
+      expect(token.type).to.be(ol.expr.TokenType.EOF);
 
       // and again
       token = lexer.next();
-      expect(token.type).to.be(ol.expression.TokenType.EOF);
+      expect(token.type).to.be(ol.expr.TokenType.EOF);
     });
 
   });
@@ -45,45 +45,45 @@ describe('ol.expression.Lexer', function() {
 
     var lexer;
     beforeEach(function() {
-      lexer = new ol.expression.Lexer('foo > 42 && bar == "chicken"');
+      lexer = new ol.expr.Lexer('foo > 42 && bar == "chicken"');
     });
 
     it('looks ahead without consuming token', function() {
       var token = lexer.peek();
-      expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+      expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
       expect(token.value).to.be('foo');
 
       token = lexer.next();
-      expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+      expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
       expect(token.value).to.be('foo');
     });
 
     it('works after a couple scans', function() {
       var token = lexer.next();
-      expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+      expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
       expect(token.value).to.be('foo');
 
       token = lexer.next();
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
       expect(token.value).to.be('>');
 
       token = lexer.peek();
-      expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
       expect(token.value).to.be(42);
 
       token = lexer.next();
-      expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
       expect(token.value).to.be(42);
     });
 
     it('returns the same thing when called multiple times', function() {
       var token = lexer.peek();
-      expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+      expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
       expect(token.value).to.be('foo');
 
       for (var i = 0; i < 10; ++i) {
         token = lexer.peek();
-        expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+        expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
         expect(token.value).to.be('foo');
       }
     });
@@ -94,11 +94,11 @@ describe('ol.expression.Lexer', function() {
   describe('#scanIdentifier_()', function() {
 
     function scan(source, part) {
-      var lexer = new ol.expression.Lexer(source);
+      var lexer = new ol.expr.Lexer(source);
       var token = lexer.scanIdentifier_(lexer.getCurrentCharCode_());
       if (!part) {
         expect(token.index).to.be(0);
-        expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
+        expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
       }
       return token;
     }
@@ -106,61 +106,61 @@ describe('ol.expression.Lexer', function() {
     it('works for short identifiers', function() {
       var token = scan('a');
       expect(token.value).to.be('a');
-      expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+      expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
     });
 
     it('works for longer identifiers', function() {
       var token = scan('foo');
       expect(token.value).to.be('foo');
-      expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+      expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
     });
 
     it('works for $ anywhere', function() {
       var token = scan('$foo$bar$');
       expect(token.value).to.be('$foo$bar$');
-      expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+      expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
     });
 
     it('works for _ anywhere', function() {
       var token = scan('_foo_bar_');
       expect(token.value).to.be('_foo_bar_');
-      expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+      expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
     });
 
     it('works for keywords', function() {
       var token = scan('delete');
       expect(token.value).to.be('delete');
-      expect(token.type).to.be(ol.expression.TokenType.KEYWORD);
+      expect(token.type).to.be(ol.expr.TokenType.KEYWORD);
     });
 
     it('works for null', function() {
       var token = scan('null');
       expect(token.value).to.be('null');
-      expect(token.type).to.be(ol.expression.TokenType.NULL_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.NULL_LITERAL);
     });
 
     it('works for boolean true', function() {
       var token = scan('true');
       expect(token.value).to.be('true');
-      expect(token.type).to.be(ol.expression.TokenType.BOOLEAN_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.BOOLEAN_LITERAL);
     });
 
     it('works for boolean false', function() {
       var token = scan('false');
       expect(token.value).to.be('false');
-      expect(token.type).to.be(ol.expression.TokenType.BOOLEAN_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.BOOLEAN_LITERAL);
     });
 
     it('works with unicode escape sequences', function() {
       var token = scan('\u006f\u006c\u0033');
       expect(token.value).to.be('ol3');
-      expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+      expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
     });
 
     it('works with hex escape sequences', function() {
       var token = scan('\x6f\x6c\x33');
       expect(token.value).to.be('ol3');
-      expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+      expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
     });
 
     it('throws for identifiers starting with a number', function() {
@@ -178,7 +178,7 @@ describe('ol.expression.Lexer', function() {
     it('only scans valid identifier part', function() {
       var token = scan('foo>bar', true);
       expect(token.value).to.be('foo');
-      expect(token.type).to.be(ol.expression.TokenType.IDENTIFIER);
+      expect(token.type).to.be(ol.expr.TokenType.IDENTIFIER);
     });
 
   });
@@ -186,24 +186,24 @@ describe('ol.expression.Lexer', function() {
   describe('#scanNumericLiteral_()', function() {
 
     function scan(source) {
-      var lexer = new ol.expression.Lexer(source);
+      var lexer = new ol.expr.Lexer(source);
       var token = lexer.scanNumericLiteral_(lexer.getCurrentCharCode_());
       expect(token.index).to.be(0);
-      expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
+      expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
       return token;
     }
 
     it('works for integers', function() {
       var token = scan('123');
       expect(token.value).to.be(123);
-      expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
     });
 
     it('throws for bogus integer', function() {
       expect(function() {
         scan('123z');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('z');
         expect(token.index).to.be(3);
@@ -213,14 +213,14 @@ describe('ol.expression.Lexer', function() {
     it('works for float', function() {
       var token = scan('123.456');
       expect(token.value).to.be(123.456);
-      expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
     });
 
     it('throws for bogus float', function() {
       expect(function() {
         scan('123.4x4');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('x');
         expect(token.index).to.be(5);
@@ -230,26 +230,26 @@ describe('ol.expression.Lexer', function() {
     it('works with exponent', function() {
       var token = scan('1.234e5');
       expect(token.value).to.be(1.234e5);
-      expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
     });
 
     it('works with explicit positive exponent', function() {
       var token = scan('1.234e+5');
       expect(token.value).to.be(1.234e5);
-      expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
     });
 
     it('works with negative exponent', function() {
       var token = scan('1.234e-5');
       expect(token.value).to.be(1.234e-5);
-      expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
     });
 
     it('throws for bogus float', function() {
       expect(function() {
         scan('1.234eo4');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('o');
         expect(token.index).to.be(6);
@@ -259,7 +259,7 @@ describe('ol.expression.Lexer', function() {
     it('works with octals', function() {
       var token = scan('02322');
       expect(token.value).to.be(1234);
-      expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
     });
 
     it('throws for bogus octal', function() {
@@ -267,7 +267,7 @@ describe('ol.expression.Lexer', function() {
       expect(function() {
         scan('02392');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('9');
         expect(token.index).to.be(3);
@@ -277,7 +277,7 @@ describe('ol.expression.Lexer', function() {
     it('works with hex', function() {
       var token = scan('0x4d2');
       expect(token.value).to.be(1234);
-      expect(token.type).to.be(ol.expression.TokenType.NUMERIC_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.NUMERIC_LITERAL);
     });
 
     it('throws for bogus hex', function() {
@@ -285,7 +285,7 @@ describe('ol.expression.Lexer', function() {
       expect(function() {
         scan('0x4G');
       }).throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
         expect(token.value).to.be('G');
         expect(token.index).to.be(3);
@@ -297,89 +297,89 @@ describe('ol.expression.Lexer', function() {
   describe('#scanPunctuator_()', function() {
 
     function scan(source) {
-      var lexer = new ol.expression.Lexer(source);
+      var lexer = new ol.expr.Lexer(source);
       var token = lexer.scanPunctuator_(lexer.getCurrentCharCode_());
       expect(token.index).to.be(0);
-      expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
+      expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
       return token;
     }
 
     it('works for dot', function() {
       var token = scan('.');
       expect(token.value).to.be('.');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
     it('works for bang', function() {
       var token = scan('!');
       expect(token.value).to.be('!');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
     it('works for double equal', function() {
       var token = scan('==');
       expect(token.value).to.be('==');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
     it('works for triple equal', function() {
       var token = scan('===');
       expect(token.value).to.be('===');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
     it('works for not double equal', function() {
       var token = scan('!=');
       expect(token.value).to.be('!=');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
     it('works for not triple equal', function() {
       var token = scan('!==');
       expect(token.value).to.be('!==');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
     it('works for logical or', function() {
       var token = scan('||');
       expect(token.value).to.be('||');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
     it('works for logical and', function() {
       var token = scan('&&');
       expect(token.value).to.be('&&');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
     it('works for plus', function() {
       var token = scan('+');
       expect(token.value).to.be('+');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
     it('works for minus', function() {
       var token = scan('-');
       expect(token.value).to.be('-');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
     it('works for star', function() {
       var token = scan('*');
       expect(token.value).to.be('*');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
     it('works for slash', function() {
       var token = scan('/');
       expect(token.value).to.be('/');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
     it('works for percent', function() {
       var token = scan('%');
       expect(token.value).to.be('%');
-      expect(token.type).to.be(ol.expression.TokenType.PUNCTUATOR);
+      expect(token.type).to.be(ol.expr.TokenType.PUNCTUATOR);
     });
 
   });
@@ -387,62 +387,62 @@ describe('ol.expression.Lexer', function() {
   describe('#scanStringLiteral_()', function() {
 
     function scan(source) {
-      var lexer = new ol.expression.Lexer(source);
+      var lexer = new ol.expr.Lexer(source);
       var token = lexer.scanStringLiteral_(lexer.getCurrentCharCode_());
       expect(token.index).to.be(0);
-      expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
+      expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
       return token;
     }
 
     it('parses double quoted string', function() {
       var token = scan('"my string"');
       expect(token.value).to.be('my string');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('parses double quoted string with internal single quotes', function() {
       var token = scan('"my \'quoted\' string"');
       expect(token.value).to.be('my \'quoted\' string');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('parses double quoted string with escaped double quotes', function() {
       var token = scan('"my \\"quoted\\" string"');
       expect(token.value).to.be('my "quoted" string');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('parses double quoted string with escaped backslash', function() {
       var token = scan('"my \\\ string"');
       expect(token.value).to.be('my \ string');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('parses double quoted string with unicode escape sequences', function() {
       var token = scan('"\u006f\u006c\u0033"');
       expect(token.value).to.be('ol3');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('parses double quoted string with hex escape sequences', function() {
       var token = scan('"\x6f\x6c\x33"');
       expect(token.value).to.be('ol3');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('parses double quoted string with tab', function() {
       var token = scan('"a\ttab"');
       expect(token.value).to.be('a\ttab');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('throws on unterminated double quote', function() {
       expect(function() {
         scan('"never \'ending\' string');
       }).to.throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
-        expect(token.type).to.be(ol.expression.TokenType.EOF);
+        expect(token.type).to.be(ol.expr.TokenType.EOF);
         expect(token.index).to.be(22);
       });
     });
@@ -450,52 +450,52 @@ describe('ol.expression.Lexer', function() {
     it('parses single quoted string', function() {
       var token = scan('\'my string\'');
       expect(token.value).to.be('my string');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('parses single quoted string with internal double quotes', function() {
       var token = scan('\'my "quoted" string\'');
       expect(token.value).to.be('my "quoted" string');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('parses single quoted string with escaped single quotes', function() {
       var token = scan('\'my \\\'quoted\\\' string\'');
       expect(token.value).to.be('my \'quoted\' string');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('parses single quoted string with escaped backslash', function() {
       var token = scan('\'my \\\ string\'');
       expect(token.value).to.be('my \ string');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('parses single quoted string with unicode escape sequences', function() {
       var token = scan('\'\u006f\u006c\u0033\'');
       expect(token.value).to.be('ol3');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('parses single quoted string with hex escape sequences', function() {
       var token = scan('\'\x6f\x6c\x33\'');
       expect(token.value).to.be('ol3');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('parses single quoted string with tab', function() {
       var token = scan('\'a\ttab\'');
       expect(token.value).to.be('a\ttab');
-      expect(token.type).to.be(ol.expression.TokenType.STRING_LITERAL);
+      expect(token.type).to.be(ol.expr.TokenType.STRING_LITERAL);
     });
 
     it('throws on unterminated single quote', function() {
       expect(function() {
         scan('\'never "ending" string');
       }).to.throwException(function(err) {
-        expect(err).to.be.an(ol.expression.UnexpectedToken);
+        expect(err).to.be.an(ol.expr.UnexpectedToken);
         var token = err.token;
-        expect(token.type).to.be(ol.expression.TokenType.EOF);
+        expect(token.type).to.be(ol.expr.TokenType.EOF);
         expect(token.index).to.be(22);
       });
     });
@@ -504,6 +504,6 @@ describe('ol.expression.Lexer', function() {
 
 });
 
-goog.require('ol.expression.Lexer');
-goog.require('ol.expression.TokenType');
-goog.require('ol.expression.UnexpectedToken');
+goog.require('ol.expr.Lexer');
+goog.require('ol.expr.TokenType');
+goog.require('ol.expr.UnexpectedToken');
diff --git a/test/spec/ol/expression/parser.test.js b/test/spec/ol/expr/parser.test.js
similarity index 68%
rename from test/spec/ol/expression/parser.test.js
rename to test/spec/ol/expr/parser.test.js
index d832dd60e6..ac0f640a46 100644
--- a/test/spec/ol/expression/parser.test.js
+++ b/test/spec/ol/expr/parser.test.js
@@ -1,21 +1,21 @@
 goog.provide('ol.test.expression.Parser');
 
-describe('ol.expression.Parser', function() {
+describe('ol.expr.Parser', function() {
 
   describe('constructor', function() {
     it('creates a new expression parser', function() {
-      var parser = new ol.expression.Parser();
-      expect(parser).to.be.a(ol.expression.Parser);
+      var parser = new ol.expr.Parser();
+      expect(parser).to.be.a(ol.expr.Parser);
     });
   });
 
   describe('#parseArguments_()', function() {
 
     function parse(source) {
-      var lexer = new ol.expression.Lexer(source);
-      var parser = new ol.expression.Parser();
+      var lexer = new ol.expr.Lexer(source);
+      var parser = new ol.expr.Parser();
       var expr = parser.parseArguments_(lexer);
-      expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
+      expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
       return expr;
     }
 
@@ -23,13 +23,13 @@ describe('ol.expression.Parser', function() {
       var args = parse('(1/3, "foo", true)');
       expect(args).length(3);
 
-      expect(args[0]).to.be.a(ol.expression.Math);
+      expect(args[0]).to.be.a(ol.expr.Math);
       expect(args[0].evaluate()).to.be(1 / 3);
 
-      expect(args[1]).to.be.a(ol.expression.Literal);
+      expect(args[1]).to.be.a(ol.expr.Literal);
       expect(args[1].evaluate()).to.be('foo');
 
-      expect(args[2]).to.be.a(ol.expression.Literal);
+      expect(args[2]).to.be.a(ol.expr.Literal);
       expect(args[2].evaluate()).to.be(true);
     });
 
@@ -50,16 +50,16 @@ describe('ol.expression.Parser', function() {
   describe('#parseBinaryExpression_()', function() {
 
     function parse(source) {
-      var lexer = new ol.expression.Lexer(source);
-      var parser = new ol.expression.Parser();
+      var lexer = new ol.expr.Lexer(source);
+      var parser = new ol.expr.Parser();
       var expr = parser.parseBinaryExpression_(lexer);
-      expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
+      expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
       return expr;
     }
 
     it('works with multiplicitave operators', function() {
       var expr = parse('4 * 1e4');
-      expect(expr).to.be.a(ol.expression.Math);
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate()).to.be(40000);
 
       expect(parse('10/3').evaluate()).to.be(10 / 3);
@@ -67,7 +67,7 @@ describe('ol.expression.Parser', function() {
 
     it('works with additive operators', function() {
       var expr = parse('4 +1e4');
-      expect(expr).to.be.a(ol.expression.Math);
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate()).to.be(10004);
 
       expect(parse('10-3').evaluate()).to.be(7);
@@ -75,7 +75,7 @@ describe('ol.expression.Parser', function() {
 
     it('works with relational operators', function() {
       var expr = parse('4 < 1e4');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate()).to.be(true);
 
       expect(parse('10<3').evaluate()).to.be(false);
@@ -86,7 +86,7 @@ describe('ol.expression.Parser', function() {
 
     it('works with equality operators', function() {
       var expr = parse('4 == 1e4');
-      expect(expr).to.be.a(ol.expression.Comparison);
+      expect(expr).to.be.a(ol.expr.Comparison);
       expect(expr.evaluate()).to.be(false);
 
       expect(parse('10!=3').evaluate()).to.be(true);
@@ -97,7 +97,7 @@ describe('ol.expression.Parser', function() {
 
     it('works with binary logical operators', function() {
       var expr = parse('true && false');
-      expect(expr).to.be.a(ol.expression.Logical);
+      expect(expr).to.be.a(ol.expr.Logical);
       expect(expr.evaluate()).to.be(false);
 
       expect(parse('false||true').evaluate()).to.be(true);
@@ -125,16 +125,16 @@ describe('ol.expression.Parser', function() {
   describe('#parseGroupExpression_()', function() {
 
     function parse(source) {
-      var lexer = new ol.expression.Lexer(source);
-      var parser = new ol.expression.Parser();
+      var lexer = new ol.expr.Lexer(source);
+      var parser = new ol.expr.Parser();
       var expr = parser.parseGroupExpression_(lexer);
-      expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
+      expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
       return expr;
     }
 
     it('parses grouped expressions', function() {
       var expr = parse('(3 * (foo + 2))');
-      expect(expr).to.be.a(ol.expression.Math);
+      expect(expr).to.be.a(ol.expr.Math);
       expect(expr.evaluate({foo: 3})).to.be(15);
     });
 
@@ -143,16 +143,16 @@ describe('ol.expression.Parser', function() {
   describe('#parseLeftHandSideExpression_()', function() {
 
     function parse(source) {
-      var lexer = new ol.expression.Lexer(source);
-      var parser = new ol.expression.Parser();
+      var lexer = new ol.expr.Lexer(source);
+      var parser = new ol.expr.Parser();
       var expr = parser.parseLeftHandSideExpression_(lexer);
-      expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
+      expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
       return expr;
     }
 
     it('parses member expressions', function() {
       var expr = parse('foo.bar.bam');
-      expect(expr).to.be.a(ol.expression.Member);
+      expect(expr).to.be.a(ol.expr.Member);
     });
 
     it('throws on invalid member expression', function() {
@@ -163,7 +163,7 @@ describe('ol.expression.Parser', function() {
 
     it('parses call expressions', function() {
       var expr = parse('foo(bar)');
-      expect(expr).to.be.a(ol.expression.Call);
+      expect(expr).to.be.a(ol.expr.Call);
       var fns = {
         foo: function(arg) {
           expect(arguments).length(1);
@@ -189,34 +189,34 @@ describe('ol.expression.Parser', function() {
   describe('#parsePrimaryExpression_()', function() {
 
     function parse(source) {
-      var lexer = new ol.expression.Lexer(source);
-      var parser = new ol.expression.Parser();
+      var lexer = new ol.expr.Lexer(source);
+      var parser = new ol.expr.Parser();
       var expr = parser.parsePrimaryExpression_(lexer);
-      expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
+      expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
       return expr;
     }
 
     it('parses string literal', function() {
       var expr = parse('"foo"');
-      expect(expr).to.be.a(ol.expression.Literal);
+      expect(expr).to.be.a(ol.expr.Literal);
       expect(expr.evaluate()).to.be('foo');
     });
 
     it('parses numeric literal', function() {
       var expr = parse('.42e2');
-      expect(expr).to.be.a(ol.expression.Literal);
+      expect(expr).to.be.a(ol.expr.Literal);
       expect(expr.evaluate()).to.be(42);
     });
 
     it('parses boolean literal', function() {
       var expr = parse('.42e2');
-      expect(expr).to.be.a(ol.expression.Literal);
+      expect(expr).to.be.a(ol.expr.Literal);
       expect(expr.evaluate()).to.be(42);
     });
 
     it('parses null literal', function() {
       var expr = parse('null');
-      expect(expr).to.be.a(ol.expression.Literal);
+      expect(expr).to.be.a(ol.expr.Literal);
       expect(expr.evaluate()).to.be(null);
     });
 
@@ -225,34 +225,34 @@ describe('ol.expression.Parser', function() {
   describe('#parseUnaryExpression_()', function() {
 
     function parse(source) {
-      var lexer = new ol.expression.Lexer(source);
-      var parser = new ol.expression.Parser();
+      var lexer = new ol.expr.Lexer(source);
+      var parser = new ol.expr.Parser();
       var expr = parser.parseUnaryExpression_(lexer);
-      expect(lexer.peek().type).to.be(ol.expression.TokenType.EOF);
+      expect(lexer.peek().type).to.be(ol.expr.TokenType.EOF);
       return expr;
     }
 
     it('parses logical not', function() {
       var expr = parse('!foo');
-      expect(expr).to.be.a(ol.expression.Not);
+      expect(expr).to.be.a(ol.expr.Not);
       expect(expr.evaluate({foo: true})).to.be(false);
     });
 
     it('works with string literal', function() {
       var expr = parse('!"foo"');
-      expect(expr).to.be.a(ol.expression.Not);
+      expect(expr).to.be.a(ol.expr.Not);
       expect(expr.evaluate()).to.be(false);
     });
 
     it('works with empty string', function() {
       var expr = parse('!""');
-      expect(expr).to.be.a(ol.expression.Not);
+      expect(expr).to.be.a(ol.expr.Not);
       expect(expr.evaluate()).to.be(true);
     });
 
     it('works with null', function() {
       var expr = parse('!null');
-      expect(expr).to.be.a(ol.expression.Not);
+      expect(expr).to.be.a(ol.expr.Not);
       expect(expr.evaluate()).to.be(true);
     });
 
@@ -262,14 +262,14 @@ describe('ol.expression.Parser', function() {
 });
 
 
-goog.require('ol.expression.Expression');
-goog.require('ol.expression.Call');
-goog.require('ol.expression.Comparison');
-goog.require('ol.expression.Lexer');
-goog.require('ol.expression.Literal');
-goog.require('ol.expression.Logical');
-goog.require('ol.expression.Math');
-goog.require('ol.expression.Member');
-goog.require('ol.expression.Not');
-goog.require('ol.expression.Parser');
-goog.require('ol.expression.TokenType');
+goog.require('ol.expr.Expression');
+goog.require('ol.expr.Call');
+goog.require('ol.expr.Comparison');
+goog.require('ol.expr.Lexer');
+goog.require('ol.expr.Literal');
+goog.require('ol.expr.Logical');
+goog.require('ol.expr.Math');
+goog.require('ol.expr.Member');
+goog.require('ol.expr.Not');
+goog.require('ol.expr.Parser');
+goog.require('ol.expr.TokenType');
diff --git a/test/spec/ol/expression/expressions.test.js b/test/spec/ol/expression/expressions.test.js
deleted file mode 100644
index fa49ec31a4..0000000000
--- a/test/spec/ol/expression/expressions.test.js
+++ /dev/null
@@ -1,638 +0,0 @@
-goog.provide('ol.test.expression.Expression');
-
-
-describe('ol.expression.Call', function() {
-
-  describe('constructor', function() {
-    it('creates a new expression', function() {
-      var expr = new ol.expression.Call(
-          new ol.expression.Identifier('sqrt'),
-          [new ol.expression.Literal(42)]);
-      expect(expr).to.be.a(ol.expression.Expression);
-      expect(expr).to.be.a(ol.expression.Call);
-    });
-  });
-
-  describe('#evaluate()', function() {
-    var fns = {
-      sqrt: function(value) {
-        return Math.sqrt(value);
-      },
-      strConcat: function() {
-        return Array.prototype.join.call(arguments, '');
-      },
-      discouraged: function() {
-        return this.message;
-      }
-    };
-
-    it('calls method on scope with literal args', function() {
-      var expr = new ol.expression.Call(
-          new ol.expression.Identifier('sqrt'),
-          [new ol.expression.Literal(42)]);
-      expect(expr.evaluate(fns)).to.be(Math.sqrt(42));
-    });
-
-    it('accepts a separate scope for functions', function() {
-      var expr = new ol.expression.Call(
-          new ol.expression.Identifier('sqrt'),
-          [new ol.expression.Identifier('foo')]);
-      expect(expr.evaluate({foo: 42}, fns)).to.be(Math.sqrt(42));
-    });
-
-    it('accepts multiple expression arguments', function() {
-      var expr = new ol.expression.Call(
-          new ol.expression.Identifier('strConcat'),
-          [
-            new ol.expression.Identifier('foo'),
-            new ol.expression.Literal(' comes after '),
-            new ol.expression.Math(
-                ol.expression.MathOp.SUBTRACT,
-                new ol.expression.Identifier('foo'),
-                new ol.expression.Literal(1))
-          ]);
-      expect(expr.evaluate({foo: 42}, fns)).to.be('42 comes after 41');
-    });
-
-    it('accepts optional this arg', function() {
-      var expr = new ol.expression.Call(
-          new ol.expression.Identifier('discouraged'), []);
-
-      var thisArg = {
-        message: 'avoid this'
-      };
-
-      expect(expr.evaluate(fns, null, thisArg)).to.be('avoid this');
-    });
-
-  });
-
-  var callee = new ol.expression.Identifier('sqrt');
-  var args = [new ol.expression.Literal(42)];
-  var expr = new ol.expression.Call(callee, args);
-
-  describe('#getArgs()', function() {
-    it('gets the callee expression', function() {
-      expect(expr.getArgs()).to.be(args);
-    });
-  });
-
-  describe('#getCallee()', function() {
-    it('gets the callee expression', function() {
-      expect(expr.getCallee()).to.be(callee);
-    });
-  });
-
-});
-
-
-describe('ol.expression.Comparison', function() {
-
-  describe('constructor', function() {
-    it('creates a new expression', function() {
-      var expr = new ol.expression.Comparison(
-          ol.expression.ComparisonOp.EQ,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(42));
-      expect(expr).to.be.a(ol.expression.Expression);
-      expect(expr).to.be.a(ol.expression.Comparison);
-    });
-  });
-
-  describe('#evaluate()', function() {
-    it('compares with ==', function() {
-      var expr = new ol.expression.Comparison(
-          ol.expression.ComparisonOp.EQ,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(42));
-
-      expect(expr.evaluate({foo: 42})).to.be(true);
-      expect(expr.evaluate({foo: '42'})).to.be(true);
-      expect(expr.evaluate({foo: true})).to.be(false);
-      expect(expr.evaluate({bar: true})).to.be(false);
-    });
-
-    it('compares with !=', function() {
-      var expr = new ol.expression.Comparison(
-          ol.expression.ComparisonOp.NEQ,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(42));
-
-      expect(expr.evaluate({foo: 42})).to.be(false);
-      expect(expr.evaluate({foo: '42'})).to.be(false);
-      expect(expr.evaluate({foo: true})).to.be(true);
-      expect(expr.evaluate({bar: true})).to.be(true);
-    });
-
-    it('compares with ===', function() {
-      var expr = new ol.expression.Comparison(
-          ol.expression.ComparisonOp.STRICT_EQ,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(42));
-
-      expect(expr.evaluate({foo: 42})).to.be(true);
-      expect(expr.evaluate({foo: '42'})).to.be(false);
-      expect(expr.evaluate({foo: true})).to.be(false);
-      expect(expr.evaluate({bar: true})).to.be(false);
-    });
-
-    it('compares with !==', function() {
-      var expr = new ol.expression.Comparison(
-          ol.expression.ComparisonOp.STRICT_NEQ,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(42));
-
-      expect(expr.evaluate({foo: 42})).to.be(false);
-      expect(expr.evaluate({foo: '42'})).to.be(true);
-      expect(expr.evaluate({foo: true})).to.be(true);
-      expect(expr.evaluate({bar: true})).to.be(true);
-    });
-
-    it('compares with >', function() {
-      var expr = new ol.expression.Comparison(
-          ol.expression.ComparisonOp.GT,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(42));
-
-      expect(expr.evaluate({foo: 42})).to.be(false);
-      expect(expr.evaluate({foo: 41})).to.be(false);
-      expect(expr.evaluate({foo: 43})).to.be(true);
-    });
-
-    it('compares with <', function() {
-      var expr = new ol.expression.Comparison(
-          ol.expression.ComparisonOp.LT,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(42));
-
-      expect(expr.evaluate({foo: 42})).to.be(false);
-      expect(expr.evaluate({foo: 41})).to.be(true);
-      expect(expr.evaluate({foo: 43})).to.be(false);
-    });
-
-    it('compares with >=', function() {
-      var expr = new ol.expression.Comparison(
-          ol.expression.ComparisonOp.GTE,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(42));
-
-      expect(expr.evaluate({foo: 42})).to.be(true);
-      expect(expr.evaluate({foo: 41})).to.be(false);
-      expect(expr.evaluate({foo: 43})).to.be(true);
-    });
-
-    it('compares with <=', function() {
-      var expr = new ol.expression.Comparison(
-          ol.expression.ComparisonOp.LTE,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(42));
-
-      expect(expr.evaluate({foo: 42})).to.be(true);
-      expect(expr.evaluate({foo: 41})).to.be(true);
-      expect(expr.evaluate({foo: 43})).to.be(false);
-    });
-  });
-
-  describe('#isValidOp()', function() {
-    it('determines if a string is a valid operator', function() {
-      expect(ol.expression.Comparison.isValidOp('<')).to.be(true);
-      expect(ol.expression.Comparison.isValidOp('<')).to.be(true);
-      expect(ol.expression.Comparison.isValidOp('<=')).to.be(true);
-      expect(ol.expression.Comparison.isValidOp('<=')).to.be(true);
-      expect(ol.expression.Comparison.isValidOp('==')).to.be(true);
-      expect(ol.expression.Comparison.isValidOp('!=')).to.be(true);
-      expect(ol.expression.Comparison.isValidOp('===')).to.be(true);
-      expect(ol.expression.Comparison.isValidOp('!==')).to.be(true);
-
-      expect(ol.expression.Comparison.isValidOp('')).to.be(false);
-      expect(ol.expression.Comparison.isValidOp('+')).to.be(false);
-      expect(ol.expression.Comparison.isValidOp('-')).to.be(false);
-      expect(ol.expression.Comparison.isValidOp('&&')).to.be(false);
-    });
-  });
-
-  var op = ol.expression.ComparisonOp.LTE;
-  var left = new ol.expression.Identifier('foo');
-  var right = new ol.expression.Literal(42);
-  var expr = new ol.expression.Comparison(op, left, right);
-
-  describe('#getOperator()', function() {
-    it('gets the operator', function() {
-      expect(expr.getOperator()).to.be(op);
-    });
-  });
-
-  describe('#getLeft()', function() {
-    it('gets the left expression', function() {
-      expect(expr.getLeft()).to.be(left);
-    });
-  });
-
-  describe('#getRight()', function() {
-    it('gets the right expression', function() {
-      expect(expr.getRight()).to.be(right);
-    });
-  });
-
-});
-
-describe('ol.expression.Identifier', function() {
-
-  describe('constructor', function() {
-    it('creates a new expression', function() {
-      var expr = new ol.expression.Identifier('foo');
-      expect(expr).to.be.a(ol.expression.Expression);
-      expect(expr).to.be.a(ol.expression.Identifier);
-    });
-  });
-
-  describe('#evaluate()', function() {
-    it('returns a number from the scope', function() {
-      var expr = new ol.expression.Identifier('foo');
-      expect(expr.evaluate({foo: 42})).to.be(42);
-    });
-
-    it('returns a string from the scope', function() {
-      var expr = new ol.expression.Identifier('foo');
-      expect(expr.evaluate({foo: 'chicken'})).to.be('chicken');
-    });
-
-    it('returns a boolean from the scope', function() {
-      var expr = new ol.expression.Identifier('bar');
-      expect(expr.evaluate({bar: false})).to.be(false);
-      expect(expr.evaluate({bar: true})).to.be(true);
-    });
-
-    it('returns a null from the scope', function() {
-      var expr = new ol.expression.Identifier('nada');
-      expect(expr.evaluate({nada: null})).to.be(null);
-    });
-
-    it('works for unicode identifiers', function() {
-      var expr = new ol.expression.Identifier('\u03c0');
-      expect(expr.evaluate({'\u03c0': Math.PI})).to.be(Math.PI);
-    });
-  });
-
-  describe('#getName()', function() {
-    var expr = new ol.expression.Identifier('asdf');
-    expect(expr.getName()).to.be('asdf');
-  });
-
-});
-
-describe('ol.expression.Literal', function() {
-
-  describe('constructor', function() {
-    it('creates a new expression', function() {
-      var expr = new ol.expression.Literal(true);
-      expect(expr).to.be.a(ol.expression.Expression);
-      expect(expr).to.be.a(ol.expression.Literal);
-    });
-  });
-
-  describe('#evaluate()', function() {
-    it('works for numeric literal', function() {
-      var expr = new ol.expression.Literal(42e-11);
-      expect(expr.evaluate()).to.be(4.2e-10);
-    });
-
-    it('works for string literal', function() {
-      var expr = new ol.expression.Literal('asdf');
-      expect(expr.evaluate()).to.be('asdf');
-    });
-
-    it('works for boolean literal', function() {
-      var expr = new ol.expression.Literal(true);
-      expect(expr.evaluate()).to.be(true);
-    });
-
-    it('works for null literal', function() {
-      var expr = new ol.expression.Literal(null);
-      expect(expr.evaluate()).to.be(null);
-    });
-  });
-
-  describe('#getValue()', function() {
-    var expr = new ol.expression.Literal('asdf');
-    expect(expr.getValue()).to.be('asdf');
-  });
-
-});
-
-
-describe('ol.expression.Logical', function() {
-
-  describe('constructor', function() {
-    it('creates a new expression', function() {
-      var expr = new ol.expression.Logical(
-          ol.expression.LogicalOp.OR,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Identifier('bar'));
-      expect(expr).to.be.a(ol.expression.Expression);
-      expect(expr).to.be.a(ol.expression.Logical);
-    });
-  });
-
-  describe('#evaluate()', function() {
-    it('applies || to resolved identifiers', function() {
-      var expr = new ol.expression.Logical(
-          ol.expression.LogicalOp.OR,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Identifier('bar'));
-
-      expect(expr.evaluate({foo: true, bar: true})).to.be(true);
-      expect(expr.evaluate({foo: true, bar: false})).to.be(true);
-      expect(expr.evaluate({foo: false, bar: true})).to.be(true);
-      expect(expr.evaluate({foo: false, bar: false})).to.be(false);
-    });
-
-    it('applies && to resolved identifiers', function() {
-      var expr = new ol.expression.Logical(
-          ol.expression.LogicalOp.AND,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Identifier('bar'));
-
-      expect(expr.evaluate({foo: true, bar: true})).to.be(true);
-      expect(expr.evaluate({foo: true, bar: false})).to.be(false);
-      expect(expr.evaluate({foo: false, bar: true})).to.be(false);
-      expect(expr.evaluate({foo: false, bar: false})).to.be(false);
-    });
-  });
-
-  describe('#isValidOp()', function() {
-    it('determines if a string is a valid operator', function() {
-      expect(ol.expression.Logical.isValidOp('||')).to.be(true);
-      expect(ol.expression.Logical.isValidOp('&&')).to.be(true);
-
-      expect(ol.expression.Logical.isValidOp('')).to.be(false);
-      expect(ol.expression.Logical.isValidOp('+')).to.be(false);
-      expect(ol.expression.Logical.isValidOp('<')).to.be(false);
-      expect(ol.expression.Logical.isValidOp('|')).to.be(false);
-    });
-  });
-
-  var op = ol.expression.LogicalOp.AND;
-  var left = new ol.expression.Identifier('foo');
-  var right = new ol.expression.Literal(false);
-  var expr = new ol.expression.Logical(op, left, right);
-
-  describe('#getOperator()', function() {
-    it('gets the operator', function() {
-      expect(expr.getOperator()).to.be(op);
-    });
-  });
-
-  describe('#getLeft()', function() {
-    it('gets the left expression', function() {
-      expect(expr.getLeft()).to.be(left);
-    });
-  });
-
-  describe('#getRight()', function() {
-    it('gets the right expression', function() {
-      expect(expr.getRight()).to.be(right);
-    });
-  });
-
-});
-
-describe('ol.expression.Math', function() {
-
-  describe('constructor', function() {
-    it('creates a new expression', function() {
-      var expr = new ol.expression.Math(
-          ol.expression.MathOp.ADD,
-          new ol.expression.Literal(40),
-          new ol.expression.Literal(2));
-      expect(expr).to.be.a(ol.expression.Expression);
-      expect(expr).to.be.a(ol.expression.Math);
-    });
-  });
-
-  describe('#evaluate()', function() {
-    it('does + with numeric literal', function() {
-      var expr = new ol.expression.Math(
-          ol.expression.MathOp.ADD,
-          new ol.expression.Literal(40),
-          new ol.expression.Literal(2));
-
-      expect(expr.evaluate()).to.be(42);
-    });
-
-    it('does + with string literal (note: subject to change)', function() {
-      var expr = new ol.expression.Math(
-          ol.expression.MathOp.ADD,
-          new ol.expression.Literal('foo'),
-          new ol.expression.Literal('bar'));
-
-      expect(expr.evaluate()).to.be('foobar');
-    });
-
-    it('does + with identifiers', function() {
-      var expr = new ol.expression.Math(
-          ol.expression.MathOp.ADD,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Identifier('bar'));
-
-      expect(expr.evaluate({foo: 40, bar: 2})).to.be(42);
-    });
-
-    it('does - with identifiers', function() {
-      var expr = new ol.expression.Math(
-          ol.expression.MathOp.SUBTRACT,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(2));
-
-      expect(expr.evaluate({foo: 40})).to.be(38);
-    });
-
-    it('casts to number with - (note: this may throw later)', function() {
-      var expr = new ol.expression.Math(
-          ol.expression.MathOp.SUBTRACT,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(2));
-
-      expect(expr.evaluate({foo: '40'})).to.be(38);
-    });
-
-    it('does * with identifiers', function() {
-      var expr = new ol.expression.Math(
-          ol.expression.MathOp.MULTIPLY,
-          new ol.expression.Literal(2),
-          new ol.expression.Identifier('foo'));
-
-      expect(expr.evaluate({foo: 21})).to.be(42);
-    });
-
-    it('casts to number with * (note: this may throw later)', function() {
-      var expr = new ol.expression.Math(
-          ol.expression.MathOp.MULTIPLY,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(2));
-
-      expect(expr.evaluate({foo: '21'})).to.be(42);
-    });
-
-    it('does % with identifiers', function() {
-      var expr = new ol.expression.Math(
-          ol.expression.MathOp.MOD,
-          new ol.expression.Literal(97),
-          new ol.expression.Identifier('foo'));
-
-      expect(expr.evaluate({foo: 55})).to.be(42);
-    });
-
-    it('casts to number with % (note: this may throw later)', function() {
-      var expr = new ol.expression.Math(
-          ol.expression.MathOp.MOD,
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Literal(100));
-
-      expect(expr.evaluate({foo: '150'})).to.be(50);
-    });
-  });
-
-  describe('#isValidOp()', function() {
-    it('determines if a string is a valid operator', function() {
-      expect(ol.expression.Math.isValidOp('+')).to.be(true);
-      expect(ol.expression.Math.isValidOp('-')).to.be(true);
-      expect(ol.expression.Math.isValidOp('*')).to.be(true);
-      expect(ol.expression.Math.isValidOp('/')).to.be(true);
-      expect(ol.expression.Math.isValidOp('%')).to.be(true);
-
-      expect(ol.expression.Math.isValidOp('')).to.be(false);
-      expect(ol.expression.Math.isValidOp('|')).to.be(false);
-      expect(ol.expression.Math.isValidOp('&')).to.be(false);
-      expect(ol.expression.Math.isValidOp('<')).to.be(false);
-      expect(ol.expression.Math.isValidOp('||')).to.be(false);
-      expect(ol.expression.Math.isValidOp('.')).to.be(false);
-    });
-  });
-
-  var op = ol.expression.MathOp.MOD;
-  var left = new ol.expression.Identifier('foo');
-  var right = new ol.expression.Literal(20);
-  var expr = new ol.expression.Math(op, left, right);
-
-  describe('#getOperator()', function() {
-    it('gets the operator', function() {
-      expect(expr.getOperator()).to.be(op);
-    });
-  });
-
-  describe('#getLeft()', function() {
-    it('gets the left expression', function() {
-      expect(expr.getLeft()).to.be(left);
-    });
-  });
-
-  describe('#getRight()', function() {
-    it('gets the right expression', function() {
-      expect(expr.getRight()).to.be(right);
-    });
-  });
-
-});
-
-describe('ol.expression.Member', function() {
-  describe('constructor', function() {
-    it('creates a new expression', function() {
-      var expr = new ol.expression.Member(
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Identifier('bar'));
-
-      expect(expr).to.be.a(ol.expression.Expression);
-      expect(expr).to.be.a(ol.expression.Member);
-    });
-  });
-
-  describe('#evaluate()', function() {
-    it('accesses an object property', function() {
-
-      var expr = new ol.expression.Member(
-          new ol.expression.Identifier('foo'),
-          new ol.expression.Identifier('bar'));
-
-      var scope = {foo: {bar: 42}};
-      expect(expr.evaluate(scope)).to.be(42);
-    });
-  });
-
-  var object = new ol.expression.Identifier('foo');
-  var property = new ol.expression.Identifier('bar');
-  var expr = new ol.expression.Member(object, property);
-
-  describe('#getObject()', function() {
-    expect(expr.getObject()).to.be(object);
-  });
-
-  describe('#getProperty()', function() {
-    expect(expr.getProperty()).to.be(property);
-  });
-
-});
-
-
-describe('ol.expression.Not', function() {
-
-  describe('constructor', function() {
-    it('creates a new expression', function() {
-      var expr = new ol.expression.Not(
-          new ol.expression.Literal(true));
-      expect(expr).to.be.a(ol.expression.Expression);
-      expect(expr).to.be.a(ol.expression.Not);
-    });
-  });
-
-  describe('#evaluate()', function() {
-    it('returns the logical complement', function() {
-      var expr = new ol.expression.Not(new ol.expression.Literal(true));
-      expect(expr.evaluate()).to.be(false);
-
-      expr = new ol.expression.Not(new ol.expression.Literal(false));
-      expect(expr.evaluate()).to.be(true);
-    });
-
-    it('negates a truthy string', function() {
-      var expr = new ol.expression.Not(new ol.expression.Literal('asdf'));
-      expect(expr.evaluate()).to.be(false);
-    });
-
-    it('negates a falsy string', function() {
-      var expr = new ol.expression.Not(new ol.expression.Literal(''));
-      expect(expr.evaluate()).to.be(true);
-    });
-
-    it('negates a truthy number', function() {
-      var expr = new ol.expression.Not(new ol.expression.Literal(42));
-      expect(expr.evaluate()).to.be(false);
-    });
-
-    it('negates a falsy number', function() {
-      var expr = new ol.expression.Not(new ol.expression.Literal(NaN));
-      expect(expr.evaluate()).to.be(true);
-    });
-  });
-
-  describe('#getArgument()', function() {
-    var argument = new ol.expression.Literal(true);
-    var expr = new ol.expression.Not(argument);
-    expect(expr.getArgument()).to.be(argument);
-  });
-
-});
-
-
-goog.require('ol.expression.Call');
-goog.require('ol.expression.Comparison');
-goog.require('ol.expression.ComparisonOp');
-goog.require('ol.expression.Expression');
-goog.require('ol.expression.Identifier');
-goog.require('ol.expression.Literal');
-goog.require('ol.expression.Logical');
-goog.require('ol.expression.LogicalOp');
-goog.require('ol.expression.Math');
-goog.require('ol.expression.MathOp');
-goog.require('ol.expression.Member');
-goog.require('ol.expression.Not');
diff --git a/test/spec/ol/layer/vectorlayer.test.js b/test/spec/ol/layer/vectorlayer.test.js
index d1773d65b9..1525617d6a 100644
--- a/test/spec/ol/layer/vectorlayer.test.js
+++ b/test/spec/ol/layer/vectorlayer.test.js
@@ -50,8 +50,8 @@ describe('ol.layer.Vector', function() {
       layer.addFeatures(features);
     });
 
-    var geomFilter = ol.expression.parse('geometryType("linestring")');
-    var extentFilter = ol.expression.parse('extent(16, 16.3, 48, 48.3)');
+    var geomFilter = ol.expr.parse('geometryType("linestring")');
+    var extentFilter = ol.expr.parse('extent(16, 16.3, 48, 48.3)');
 
     it('can filter by geometry type using its GeometryType index', function() {
       sinon.spy(geomFilter, 'evaluate');
@@ -70,10 +70,10 @@ describe('ol.layer.Vector', function() {
     });
 
     it('can filter by extent and geometry type using its index', function() {
-      var filter1 = new ol.expression.Logical(
-          ol.expression.LogicalOp.AND, geomFilter, extentFilter);
-      var filter2 = new ol.expression.Logical(
-          ol.expression.LogicalOp.AND, extentFilter, geomFilter);
+      var filter1 = new ol.expr.Logical(
+          ol.expr.LogicalOp.AND, geomFilter, extentFilter);
+      var filter2 = new ol.expr.Logical(
+          ol.expr.LogicalOp.AND, extentFilter, geomFilter);
       sinon.spy(filter1, 'evaluate');
       sinon.spy(filter2, 'evaluate');
       var subset1 = layer.getFeatures(filter1);
@@ -85,8 +85,8 @@ describe('ol.layer.Vector', function() {
     });
 
     it('can handle query using the filter\'s evaluate function', function() {
-      var filter = new ol.expression.Logical(
-          ol.expression.LogicalOp.OR, geomFilter, extentFilter);
+      var filter = new ol.expr.Logical(
+          ol.expr.LogicalOp.OR, geomFilter, extentFilter);
       sinon.spy(filter, 'evaluate');
       var subset = layer.getFeatures(filter);
       expect(filter.evaluate).to.be.called();
@@ -107,7 +107,7 @@ describe('ol.layer.Vector', function() {
             symbolizers: [
               new ol.style.Line({
                 strokeWidth: 2,
-                strokeColor: ol.expression.parse('colorProperty'),
+                strokeColor: ol.expr.parse('colorProperty'),
                 opacity: 1
               })
             ]
@@ -144,7 +144,7 @@ describe('ol.layer.Vector', function() {
     it('groups equal symbolizers also when defined on features', function() {
       var symbolizer = new ol.style.Line({
         strokeWidth: 3,
-        strokeColor: ol.expression.parse('colorProperty'),
+        strokeColor: ol.expr.parse('colorProperty'),
         opacity: 1
       });
       var anotherSymbolizer = new ol.style.Line({
@@ -178,9 +178,9 @@ describe('ol.layer.Vector', function() {
 
 goog.require('goog.dispose');
 goog.require('ol.Feature');
-goog.require('ol.expression');
-goog.require('ol.expression.Logical');
-goog.require('ol.expression.LogicalOp');
+goog.require('ol.expr');
+goog.require('ol.expr.Logical');
+goog.require('ol.expr.LogicalOp');
 goog.require('ol.geom.LineString');
 goog.require('ol.geom.Point');
 goog.require('ol.proj');
diff --git a/test/spec/ol/style/line.test.js b/test/spec/ol/style/line.test.js
index f57d4a71fa..6022486638 100644
--- a/test/spec/ol/style/line.test.js
+++ b/test/spec/ol/style/line.test.js
@@ -42,8 +42,8 @@ describe('ol.style.Line', function() {
 
     it('accepts expressions', function() {
       var symbolizer = new ol.style.Line({
-        opacity: ol.expression.parse('value / 100'),
-        strokeWidth: ol.expression.parse('widthAttr')
+        opacity: ol.expr.parse('value / 100'),
+        strokeWidth: ol.expr.parse('widthAttr')
       });
       expect(symbolizer).to.be.a(ol.style.Line);
     });
@@ -54,8 +54,8 @@ describe('ol.style.Line', function() {
 
     it('evaluates expressions with the given feature', function() {
       var symbolizer = new ol.style.Line({
-        opacity: ol.expression.parse('value / 100'),
-        strokeWidth: ol.expression.parse('widthAttr')
+        opacity: ol.expr.parse('value / 100'),
+        strokeWidth: ol.expr.parse('widthAttr')
       });
 
       var feature = new ol.Feature({
@@ -74,6 +74,6 @@ describe('ol.style.Line', function() {
 });
 
 goog.require('ol.Feature');
-goog.require('ol.expression');
+goog.require('ol.expr');
 goog.require('ol.style.Line');
 goog.require('ol.style.LineLiteral');
diff --git a/test/spec/ol/style/polygon.test.js b/test/spec/ol/style/polygon.test.js
index e8a9453899..6ce43ae867 100644
--- a/test/spec/ol/style/polygon.test.js
+++ b/test/spec/ol/style/polygon.test.js
@@ -45,8 +45,8 @@ describe('ol.style.Polygon', function() {
 
     it('accepts expressions', function() {
       var symbolizer = new ol.style.Polygon({
-        opacity: ol.expression.parse('value / 100'),
-        fillColor: ol.expression.parse('fillAttr')
+        opacity: ol.expr.parse('value / 100'),
+        fillColor: ol.expr.parse('fillAttr')
       });
       expect(symbolizer).to.be.a(ol.style.Polygon);
     });
@@ -57,8 +57,8 @@ describe('ol.style.Polygon', function() {
 
     it('evaluates expressions with the given feature', function() {
       var symbolizer = new ol.style.Polygon({
-        opacity: ol.expression.parse('value / 100'),
-        fillColor: ol.expression.parse('fillAttr')
+        opacity: ol.expr.parse('value / 100'),
+        fillColor: ol.expr.parse('fillAttr')
       });
 
       var feature = new ol.Feature({
@@ -90,6 +90,6 @@ describe('ol.style.Polygon', function() {
 });
 
 goog.require('ol.Feature');
-goog.require('ol.expression');
+goog.require('ol.expr');
 goog.require('ol.style.Polygon');
 goog.require('ol.style.PolygonLiteral');
diff --git a/test/spec/ol/style/rule.test.js b/test/spec/ol/style/rule.test.js
index 789d9de889..c2a2e2d821 100644
--- a/test/spec/ol/style/rule.test.js
+++ b/test/spec/ol/style/rule.test.js
@@ -13,14 +13,14 @@ describe('ol.style.Rule', function() {
 
     it('returns false when the rule does not apply', function() {
       rule = new ol.style.Rule({
-        filter: new ol.expression.Literal(false)
+        filter: new ol.expr.Literal(false)
       });
       expect(rule.applies(feature)).to.be(false);
     });
 
     it('returns true when the rule applies', function() {
       rule = new ol.style.Rule({
-        filter: new ol.expression.Literal(true)
+        filter: new ol.expr.Literal(true)
       });
       expect(rule.applies(feature)).to.be(true);
     });
@@ -29,5 +29,5 @@ describe('ol.style.Rule', function() {
 });
 
 goog.require('ol.Feature');
-goog.require('ol.expression.Literal');
+goog.require('ol.expr.Literal');
 goog.require('ol.style.Rule');
diff --git a/test/spec/ol/style/shape.test.js b/test/spec/ol/style/shape.test.js
index 90a1158f06..1e629eef1b 100644
--- a/test/spec/ol/style/shape.test.js
+++ b/test/spec/ol/style/shape.test.js
@@ -51,8 +51,8 @@ describe('ol.style.Shape', function() {
 
     it('accepts expressions', function() {
       var symbolizer = new ol.style.Shape({
-        size: ol.expression.parse('sizeAttr'),
-        strokeColor: ol.expression.parse('color')
+        size: ol.expr.parse('sizeAttr'),
+        strokeColor: ol.expr.parse('color')
       });
       expect(symbolizer).to.be.a(ol.style.Shape);
     });
@@ -63,8 +63,8 @@ describe('ol.style.Shape', function() {
 
     it('evaluates expressions with the given feature', function() {
       var symbolizer = new ol.style.Shape({
-        size: ol.expression.parse('sizeAttr'),
-        opacity: ol.expression.parse('opacityAttr'),
+        size: ol.expr.parse('sizeAttr'),
+        opacity: ol.expr.parse('opacityAttr'),
         fillColor: '#BADA55'
       });
 
@@ -99,8 +99,8 @@ describe('ol.style.Shape', function() {
 
     it('applies default type if none provided', function() {
       var symbolizer = new ol.style.Shape({
-        size: ol.expression.parse('sizeAttr'),
-        opacity: ol.expression.parse('opacityAttr'),
+        size: ol.expr.parse('sizeAttr'),
+        opacity: ol.expr.parse('opacityAttr'),
         fillColor: '#BADA55'
       });
 
@@ -120,7 +120,7 @@ describe('ol.style.Shape', function() {
 });
 
 goog.require('ol.Feature');
-goog.require('ol.expression');
+goog.require('ol.expr');
 goog.require('ol.style.Shape');
 goog.require('ol.style.ShapeLiteral');
 goog.require('ol.style.ShapeType');