@mapbox/mapbox-gl-style-spec 13.24.0-alpha.3 → 13.24.0

package/empty.js

@@ -1,29 +1,10 @@
-import latest from './reference/latest.js';
-
-export default function emptyStyle() {
-    const style = {};
-
-    const version = latest['$version'];
-    for (const styleKey in latest['$root']) {
-        const spec = latest['$root'][styleKey];
-
-        if (spec.required) {
-            let value = null;
-            if (styleKey === 'version') {
-                value = version;
-            } else {
-                if (spec.type === 'array') {
-                    value = [];
-                } else {
-                    value = {};
-                }
-            }
-
-            if (value != null) {
-                style[styleKey] = value;
-            }
-        }
-    }
-
-    return style;
+// @flow
+import type {StyleSpecification} from './types.js';
+
+export default function emptyStyle(): StyleSpecification {
+    return {
+        version: 8,
+        layers: [],
+        sources: {}
+    };
 }

package/expression/compound_expression.js

@@ -31,7 +31,7 @@ class CompoundExpression implements Expression {
         this.args = args;
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): Value {
         return this._evaluate(ctx, this.args);
     }
 
@@ -39,7 +39,7 @@ class CompoundExpression implements Expression {
         this.args.forEach(fn);
     }
 
-    outputDefined() {
+    outputDefined(): boolean {
         return false;
     }
 

package/expression/definitions/assertion.js

@@ -15,7 +15,7 @@ import {
 import RuntimeError from '../runtime_error.js';
 import {typeOf} from '../values.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type {Type} from '../types.js';
@@ -85,7 +85,7 @@ class Assertion implements Expression {
         return new Assertion(type, parsed);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): any | null {
         for (let i = 0; i < this.args.length; i++) {
             const value = this.args[i].evaluate(ctx);
             const error = checkSubtype(this.type, typeOf(value));
@@ -108,7 +108,7 @@ class Assertion implements Expression {
         return this.args.every(arg => arg.outputDefined());
     }
 
-    serialize(): Array<mixed> {
+    serialize(): SerializedExpression {
         const type = this.type;
         const serialized = [type.kind];
         if (type.kind === 'array') {

package/expression/definitions/at.js

@@ -4,7 +4,7 @@ import {array, ValueType, NumberType} from '../types.js';
 
 import RuntimeError from '../runtime_error.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type {Type, ArrayType} from '../types.js';
@@ -21,7 +21,7 @@ class At implements Expression {
         this.input = input;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?At {
         if (args.length !== 3)
             return context.error(`Expected 2 arguments, but found ${args.length - 1} instead.`);
 
@@ -34,7 +34,7 @@ class At implements Expression {
         return new At(t.itemType, index, input);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): Value {
         const index = ((this.index.evaluate(ctx): any): number);
         const array = ((this.input.evaluate(ctx): any): Array<Value>);
 
@@ -58,11 +58,11 @@ class At implements Expression {
         fn(this.input);
     }
 
-    outputDefined() {
+    outputDefined(): boolean {
         return false;
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         return ["at", this.index.serialize(), this.input.serialize()];
     }
 }

package/expression/definitions/case.js

@@ -4,7 +4,7 @@ import assert from 'assert';
 
 import {BooleanType} from '../types.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type {Type} from '../types.js';
@@ -23,7 +23,7 @@ class Case implements Expression {
         this.otherwise = otherwise;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Case {
         if (args.length < 4)
             return context.error(`Expected at least 3 arguments, but found only ${args.length - 1}.`);
         if (args.length % 2 !== 0)
@@ -54,7 +54,7 @@ class Case implements Expression {
         return new Case((outputType: any), branches, otherwise);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): any {
         for (const [test, expression] of this.branches) {
             if (test.evaluate(ctx)) {
                 return expression.evaluate(ctx);
@@ -75,7 +75,7 @@ class Case implements Expression {
         return this.branches.every(([_, out]) => out.outputDefined()) && this.otherwise.outputDefined();
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         const serialized = ["case"];
         this.eachChild(child => { serialized.push(child.serialize()); });
         return serialized;

package/expression/definitions/coalesce.js

@@ -5,7 +5,7 @@ import assert from 'assert';
 import {checkSubtype, ValueType} from '../types.js';
 import ResolvedImage from '../types/resolved_image.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type {Type} from '../types.js';
@@ -19,7 +19,7 @@ class Coalesce implements Expression {
         this.args = args;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Coalesce {
         if (args.length < 2) {
             return context.error("Expectected at least one argument.");
         }
@@ -51,7 +51,7 @@ class Coalesce implements Expression {
             new Coalesce((outputType: any), parsedArgs);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): any | null {
         let result = null;
         let argCount = 0;
         let firstImage;
@@ -85,7 +85,7 @@ class Coalesce implements Expression {
         return this.args.every(arg => arg.outputDefined());
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         const serialized = ["coalesce"];
         this.eachChild(child => { serialized.push(child.serialize()); });
         return serialized;

package/expression/definitions/coercion.js

@@ -10,7 +10,7 @@ import FormatExpression from '../definitions/format.js';
 import ImageExpression from '../definitions/image.js';
 import ResolvedImage from '../types/resolved_image.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type {Type} from '../types.js';
@@ -60,7 +60,7 @@ class Coercion implements Expression {
         return new Coercion(type, parsed);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): null | boolean | number | string | Color | Formatted | ResolvedImage {
         if (this.type.kind === 'boolean') {
             return Boolean(this.args[0].evaluate(ctx));
         } else if (this.type.kind === 'color') {
@@ -115,7 +115,7 @@ class Coercion implements Expression {
         return this.args.every(arg => arg.outputDefined());
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         if (this.type.kind === 'formatted') {
             return new FormatExpression([{content: this.args[0], scale: null, font: null, textColor: null}]).serialize();
         }

package/expression/definitions/collator.js

@@ -3,7 +3,7 @@
 import {StringType, BooleanType, CollatorType} from '../types.js';
 import Collator from '../types/collator.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type ParsingContext from '../parsing_context.js';
 import type {Type} from '../types.js';
@@ -46,7 +46,7 @@ export default class CollatorExpression implements Expression {
         return new CollatorExpression(caseSensitive, diacriticSensitive, locale);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): Collator {
         return new Collator(this.caseSensitive.evaluate(ctx), this.diacriticSensitive.evaluate(ctx), this.locale ? this.locale.evaluate(ctx) : null);
     }
 
@@ -58,7 +58,7 @@ export default class CollatorExpression implements Expression {
         }
     }
 
-    outputDefined() {
+    outputDefined(): boolean {
         // Technically the set of possible outputs is the combinatoric set of Collators produced
         // by all possible outputs of locale/caseSensitive/diacriticSensitive
         // But for the primary use of Collators in comparison operators, we ignore the Collator's
@@ -66,7 +66,7 @@ export default class CollatorExpression implements Expression {
         return false;
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         const options = {};
         options['case-sensitive'] = this.caseSensitive.serialize();
         options['diacritic-sensitive'] = this.diacriticSensitive.serialize();

package/expression/definitions/comparison.js

@@ -5,7 +5,7 @@ import Assertion from './assertion.js';
 import {typeOf} from '../values.js';
 import RuntimeError from '../runtime_error.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression, ExpressionRegistration} from '../expression.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type ParsingContext from '../parsing_context.js';
 import type {Type} from '../types.js';
@@ -28,19 +28,19 @@ function isComparableType(op: ComparisonOperator, type: Type) {
     }
 }
 
-function eq(ctx, a, b) { return a === b; }
-function neq(ctx, a, b) { return a !== b; }
-function lt(ctx, a, b) { return a < b; }
-function gt(ctx, a, b) { return a > b; }
-function lteq(ctx, a, b) { return a <= b; }
-function gteq(ctx, a, b) { return a >= b; }
+function eq(ctx: EvaluationContext, a: any, b: any): boolean { return a === b; }
+function neq(ctx: EvaluationContext, a: any, b: any): boolean { return a !== b; }
+function lt(ctx: EvaluationContext, a: any, b: any): boolean { return a < b; }
+function gt(ctx: EvaluationContext, a: any, b: any): boolean { return a > b; }
+function lteq(ctx: EvaluationContext, a: any, b: any): boolean { return a <= b; }
+function gteq(ctx: EvaluationContext, a: any, b: any): boolean { return a >= b; }
 
-function eqCollate(ctx, a, b, c) { return c.compare(a, b) === 0; }
-function neqCollate(ctx, a, b, c) { return !eqCollate(ctx, a, b, c); }
-function ltCollate(ctx, a, b, c) { return c.compare(a, b) < 0; }
-function gtCollate(ctx, a, b, c) { return c.compare(a, b) > 0; }
-function lteqCollate(ctx, a, b, c) { return c.compare(a, b) <= 0; }
-function gteqCollate(ctx, a, b, c) { return c.compare(a, b) >= 0; }
+function eqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) === 0; }
+function neqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return !eqCollate(ctx, a, b, c); }
+function ltCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) < 0; }
+function gtCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) > 0; }
+function lteqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) <= 0; }
+function gteqCollate(ctx: EvaluationContext, a: any, b: any, c: any): boolean { return c.compare(a, b) >= 0; }
 
 /**
  * Special form for comparison operators, implementing the signatures:
@@ -59,7 +59,7 @@ function gteqCollate(ctx, a, b, c) { return c.compare(a, b) >= 0; }
  *
  * @private
  */
-function makeComparison(op: ComparisonOperator, compareBasic, compareWithCollator) {
+function makeComparison(op: ComparisonOperator, compareBasic: (EvaluationContext, any, any) => boolean, compareWithCollator: (EvaluationContext, any, any, any) => boolean): ExpressionRegistration {
     const isOrderComparison = op !== '==' && op !== '!=';
 
     return class Comparison implements Expression {
@@ -130,7 +130,7 @@ function makeComparison(op: ComparisonOperator, compareBasic, compareWithCollato
             return new Comparison(lhs, rhs, collator);
         }
 
-        evaluate(ctx: EvaluationContext) {
+        evaluate(ctx: EvaluationContext): boolean {
             const lhs = this.lhs.evaluate(ctx);
             const rhs = this.rhs.evaluate(ctx);
 
@@ -168,7 +168,7 @@ function makeComparison(op: ComparisonOperator, compareBasic, compareWithCollato
             return true;
         }
 
-        serialize() {
+        serialize(): SerializedExpression {
             const serialized = [op];
             this.eachChild(child => { serialized.push(child.serialize()); });
             return serialized;
@@ -176,9 +176,9 @@ function makeComparison(op: ComparisonOperator, compareBasic, compareWithCollato
     };
 }
 
-export const Equals = makeComparison('==', eq, eqCollate);
-export const NotEquals = makeComparison('!=', neq, neqCollate);
-export const LessThan = makeComparison('<', lt, ltCollate);
-export const GreaterThan = makeComparison('>', gt, gtCollate);
-export const LessThanOrEqual = makeComparison('<=', lteq, lteqCollate);
-export const GreaterThanOrEqual = makeComparison('>=', gteq, gteqCollate);
+export const Equals: $Call<typeof makeComparison, '==', typeof eq, typeof eqCollate> = makeComparison('==', eq, eqCollate);
+export const NotEquals: $Call<typeof makeComparison, '!=', typeof neq, typeof neqCollate> = makeComparison('!=', neq, neqCollate);
+export const LessThan: $Call<typeof makeComparison, '<', typeof lt, typeof ltCollate> = makeComparison('<', lt, ltCollate);
+export const GreaterThan: $Call<typeof makeComparison, '>', typeof gt, typeof gtCollate> = makeComparison('>', gt, gtCollate);
+export const LessThanOrEqual: $Call<typeof makeComparison, '<=', typeof lteq, typeof lteqCollate> = makeComparison('<=', lteq, lteqCollate);
+export const GreaterThanOrEqual: $Call<typeof makeComparison, '>=', typeof gteq, typeof gteqCollate> = makeComparison('>=', gteq, gteqCollate);

package/expression/definitions/format.js

@@ -4,7 +4,7 @@ import {NumberType, ValueType, FormattedType, array, StringType, ColorType, Reso
 import Formatted, {FormattedSection} from '../types/formatted.js';
 import {toString, typeOf} from '../values.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type ParsingContext from '../parsing_context.js';
 import type {Type} from '../types.js';
@@ -83,7 +83,7 @@ export default class FormatExpression implements Expression {
         return new FormatExpression(sections);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): Formatted {
         const evaluateSection = section => {
             const evaluatedContent = section.content.evaluate(ctx);
             if (typeOf(evaluatedContent) === ResolvedImageType) {
@@ -117,13 +117,13 @@ export default class FormatExpression implements Expression {
         }
     }
 
-    outputDefined() {
+    outputDefined(): boolean {
         // Technically the combinatoric set of all children
         // Usually, this.text will be undefined anyway
         return false;
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         const serialized = ["format"];
         for (const section of this.sections) {
             serialized.push(section.content.serialize());

package/expression/definitions/image.js

@@ -3,7 +3,7 @@
 import {ResolvedImageType, StringType} from '../types.js';
 import ResolvedImage from '../types/resolved_image.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type ParsingContext from '../parsing_context.js';
 import type {Type} from '../types.js';
@@ -28,7 +28,7 @@ export default class ImageExpression implements Expression {
         return new ImageExpression(name);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): null | ResolvedImage {
         const evaluatedImageName = this.input.evaluate(ctx);
 
         const value = ResolvedImage.fromString(evaluatedImageName);
@@ -41,12 +41,12 @@ export default class ImageExpression implements Expression {
         fn(this.input);
     }
 
-    outputDefined() {
+    outputDefined(): boolean {
         // The output of image is determined by the list of available images in the evaluation context
         return false;
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         return ["image", this.input.serialize()];
     }
 }

package/expression/definitions/in.js

@@ -4,7 +4,7 @@ import {BooleanType, StringType, ValueType, NullType, toString, NumberType, isVa
 import RuntimeError from '../runtime_error.js';
 import {typeOf} from '../values.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type {Type} from '../types.js';
@@ -20,7 +20,7 @@ class In implements Expression {
         this.haystack = haystack;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?In {
         if (args.length !== 3) {
             return context.error(`Expected 2 arguments, but found ${args.length - 1} instead.`);
         }
@@ -38,11 +38,11 @@ class In implements Expression {
         return new In(needle, haystack);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): boolean {
         const needle = (this.needle.evaluate(ctx): any);
         const haystack = (this.haystack.evaluate(ctx): any);
 
-        if (!haystack) return false;
+        if (haystack == null) return false;
 
         if (!isValidNativeType(needle, ['boolean', 'string', 'number', 'null'])) {
             throw new RuntimeError(`Expected first argument to be of type boolean, string, number or null, but found ${toString(typeOf(needle))} instead.`);
@@ -60,11 +60,11 @@ class In implements Expression {
         fn(this.haystack);
     }
 
-    outputDefined() {
+    outputDefined(): boolean {
         return true;
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         return ["in", this.needle.serialize(), this.haystack.serialize()];
     }
 }

package/expression/definitions/index_of.js

@@ -4,7 +4,7 @@ import {BooleanType, StringType, ValueType, NullType, toString, NumberType, isVa
 import RuntimeError from '../runtime_error.js';
 import {typeOf} from '../values.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type {Type} from '../types.js';
@@ -22,7 +22,7 @@ class IndexOf implements Expression {
         this.fromIndex = fromIndex;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?IndexOf {
         if (args.length <= 2 ||  args.length >= 5) {
             return context.error(`Expected 3 or 4 arguments, but found ${args.length - 1} instead.`);
         }
@@ -45,7 +45,7 @@ class IndexOf implements Expression {
         }
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): any {
         const needle = (this.needle.evaluate(ctx): any);
         const haystack = (this.haystack.evaluate(ctx): any);
 
@@ -73,11 +73,11 @@ class IndexOf implements Expression {
         }
     }
 
-    outputDefined() {
+    outputDefined(): boolean {
         return false;
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         if (this.fromIndex != null && this.fromIndex !== undefined) {
             const fromIndex = this.fromIndex.serialize();
             return ["index-of", this.needle.serialize(), this.haystack.serialize(), fromIndex];

package/expression/definitions/interpolate.js

@@ -6,9 +6,10 @@ import * as interpolate from '../../util/interpolate.js';
 import {toString, NumberType, ColorType} from '../types.js';
 import {findStopLessThanOrEqualTo} from '../stops.js';
 import {hcl, lab} from '../../util/color_spaces.js';
+import Color from '../../util/color.js';
 
 import type {Stops} from '../stops.js';
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type {Type} from '../types.js';
@@ -41,7 +42,7 @@ class Interpolate implements Expression {
         }
     }
 
-    static interpolationFactor(interpolation: InterpolationType, input: number, lower: number, upper: number) {
+    static interpolationFactor(interpolation: InterpolationType, input: number, lower: number, upper: number): number {
         let t = 0;
         if (interpolation.name === 'exponential') {
             t = exponentialInterpolation(input, interpolation.base, lower, upper);
@@ -55,7 +56,7 @@ class Interpolate implements Expression {
         return t;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Interpolate {
         let [operator, interpolation, input, ...rest] = args;
 
         if (!Array.isArray(interpolation) || interpolation.length === 0) {
@@ -144,7 +145,7 @@ class Interpolate implements Expression {
         return new Interpolate(outputType, (operator: any), interpolation, input, stops);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): Color {
         const labels = this.labels;
         const outputs = this.outputs;
 
@@ -190,7 +191,7 @@ class Interpolate implements Expression {
         return this.outputs.every(out => out.outputDefined());
     }
 
-    serialize(): Array<mixed> {
+    serialize(): SerializedExpression {
         let interpolation;
         if (this.interpolation.name === 'linear') {
             interpolation = ["linear"];

package/expression/definitions/length.js

@@ -5,7 +5,7 @@ import {NumberType, toString} from '../types.js';
 import {typeOf} from '../values.js';
 import RuntimeError from '../runtime_error.js';
 
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext from '../evaluation_context.js';
 import type {Type} from '../types.js';
@@ -19,7 +19,7 @@ class Length implements Expression {
         this.input = input;
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Length {
         if (args.length !== 2)
             return context.error(`Expected 1 argument, but found ${args.length - 1} instead.`);
 
@@ -32,7 +32,7 @@ class Length implements Expression {
         return new Length(input);
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): any | number {
         const input = this.input.evaluate(ctx);
         if (typeof input === 'string') {
             return input.length;
@@ -47,11 +47,11 @@ class Length implements Expression {
         fn(this.input);
     }
 
-    outputDefined() {
+    outputDefined(): boolean {
         return false;
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         const serialized = ["length"];
         this.eachChild(child => { serialized.push(child.serialize()); });
         return serialized;

package/expression/definitions/let.js

@@ -1,7 +1,7 @@
 // @flow
 
 import type {Type} from '../types.js';
-import type {Expression} from '../expression.js';
+import type {Expression, SerializedExpression} from '../expression.js';
 import type ParsingContext from '../parsing_context.js';
 import type EvaluationContext  from '../evaluation_context.js';
 
@@ -16,7 +16,7 @@ class Let implements Expression {
         this.result = result;
     }
 
-    evaluate(ctx: EvaluationContext) {
+    evaluate(ctx: EvaluationContext): any {
         return this.result.evaluate(ctx);
     }
 
@@ -27,7 +27,7 @@ class Let implements Expression {
         fn(this.result);
     }
 
-    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext) {
+    static parse(args: $ReadOnlyArray<mixed>, context: ParsingContext): ?Let {
         if (args.length < 4)
             return context.error(`Expected at least 3 arguments, but found ${args.length - 1} instead.`);
 
@@ -55,11 +55,11 @@ class Let implements Expression {
         return new Let(bindings, result);
     }
 
-    outputDefined() {
+    outputDefined(): boolean {
         return this.result.outputDefined();
     }
 
-    serialize() {
+    serialize(): SerializedExpression {
         const serialized = ["let"];
         for (const [name, expr] of this.bindings) {
             serialized.push(name, expr.serialize());