// Example of the warning:
// FlowScript knows that x is not equal to null.
// The warning indicates that the comparison will always be false.
let x : number? = 1;
if x == null {
// ...
}
Value is known to be null (warning)
The value is known to be null here.
// Example of the warning:
// FlowScript knows that x is equal to null. The warning indicates
// that the comparison will always be true.
let x : number? = null;
if x == null {
// ...
}
Missing expected field
Expected field <name> of type <type name>
type Country = { name: text, isoCode: text }
// Example of the error: the "name" field is missing.
return new Country { isoCode: 'bt' }
Generic function must be specialized
The function is generic and the argument types cannot be inferred from usage.
// Example of the error: JSON.deserialize requires a type argument.
return JSON.deserialize("[1, 2]");
// Example resolution: supply the type argument
return JSON.deserialize<number*>("[1, 2]");
default() is not supported for type variables
The default keyword cannot be used with type variables.
// Example of the error: we cannot use the "default"
// keyword with type variables.
function getDefault<T>() => default(T)
Function is not generic
The function is not generic and cannot accept type arguments.
let xs = [1, 2];
// Example of the error: supplying a type argument to a non-generic function.
return count<number>(xs);
// Example resolution: remove the type arguments.
return count(xs);
Type mismatch
Expected a <A>, but the term has type <B>.
// Example: update a variable with the wrong type.
let x = 1;
set x = false;
Operator type mismatch
The operator <operator> cannot be used with types <A> and <B>.
let x = "3";
let y = "1";
// Example of the error: trying to subtract a text value from a text value.
return x - y;
// Example resolution: convert both sides to numbers
return val(x) - val(y);
Argument type mismatch
Argument <name> was expected to have type <A>, but the expression has type <B>.
let x = "1";
let y = 2;
// Example of the error:
// The first argument to the 'max' function is not a number.
return max(x, y);
// Example resolution: convert x to a number.
return max(val(x), y);
Wrong argument count
Incorrect number of arguments for function <function signature>.
// Example of the error:
// Pass too many arguments to the 'max' function. (It only accepts exactly two.)
return max(1, 2, 3);
Unknown member
The type does not contain a field labelled <name> and no matching self function was found.
let user = {id: 0, name: 'Ismail'};
// Example of the error:
// Access a record member which does not exist.
return user.email;
Value is not a record
The value is not a record.
// Example 1: forgetting to use parentheses with a self function.
return [1, 2].count;
// Example 1 resolution: call the self function.
return [1, 2].count();
// Example 2: using dot notation with a non record.
return "1".id;
Wrong arity of type constructor
The type <name> requires <number> type arguments.
type Box<T> = { contents: T }
// Example of the error: Box<T> has arity 1, but two arguments are supplied.
type BooleanShipment = { box: Box<boolean, boolean>, address: text }
Duplicate field
The field label <label> occurs more than once.
// Example of the error: a record where the "name" field occurs twice.
return {
name: "greta",
name: "coco"
}
Duplicated type argument
The function has duplicated type arguments.
// Example of the error: the function has two type arguments by the same name
function foo<T, T>() {
// ...
}
Duplicated parameter name
The parameter <name> occurs more than once.
// Example of the error: the function has two parameters called "x"
function compare(x: number, x: number) {
// ...
}
Cyclic reference in type
The type involves an immediate cyclic reference.
// Example of the error: Company contains a Company which contains a Company...
type Company = { name: text, parent: Company }
// Example resolution: make the cyclic reference nullable.
type Company = { name: text, parent: Company? }
Multiple nullability annotations (warning)
The type is already nullable.
// Example: a doubly nullable type.
type NullableBoolean = boolean?;
type NullableNullableBoolean = NullableBoolean?;
Type is not a record type
The type is not a record type.
// Example of the error: use the 'new' syntax with a sequence type
type UserTable = {id: number, name: text}*; // note the sequence star
return new UserTable {
id: 0,
name: 'George'
}
Impossible type narrowing
The type narrowing expression will always be false.
let user = {id: 0, name: "Ljudmila"}
// Example of the error: FlowScript knows that 'user' could never be a number.
if user is number {
// ...
}
Truistic type narrowing
The type narrowing expression will always be true.
let x = 1;
// Example of the error: FlowScript knows that 'x' is always a number.
if x is number {
// ...
}
Control flow errors
Identifier already declared
The identifier <name> is already declared.
// Example 1: "count" is the name of a built-in function.
let count = 1;
// Example 2: declaring the same variable twice.
let x = 1;
let x = 2;
Unknown variable
The variable <name> does not exist or cannot be used in this context.
// Example of the error:
// Access a variable which does not exist.
return foo + 1;
Unknown type
The type <name> does not exist.
// Example of the error: access a type which does not exist.
let user = {id: 0, name: 'Farah'};
if x is User {
// ...
}
Variable is read-only
The variable <name> is read-only in this scope.
// Example of the error: we can only update the value of local variables,
// i.e. variables declared in the same script.
set count = 2;
Continue only allowed in loops
The continue statement is only allowed in the body of loops.
// Example of the error: "continue" has no meaning outside of a loop body.
let x = 1;
continue;
Break only allowed in loops
The break statement is only allowed in the body of loops.
// Example of the error: "break" has no meaning outside of a loop body.
let x = 1;
break;
Type already declared
The type <name> is already declared.
// Example of the error:
// declare the "User" type twice.'
type User = {id: number, name: text};
type User = {id: number, name: text, email: text};
Not all paths return a value
Not all paths return a value.
// Example of the error:
// A function which does not always return.
function absolute(x: number) {
if x < 0:
return x * -1;
}
// Example resolution: add a return statement on the path where it is missing.
function absolute(x: number) {
if x < 0:
return x * -1;
else:
return x;
}
Type cannot be used with loops
The term has type <type> and cannot be used with for loops or queries.
let user = {id: 0, name: 'Jacinto'};
// Example: trying to loop over a record
for x in user {
// ...
}
// Example resolution: turn the record into a sequence of members
for x in Record.getMembers(user) {
// ...
]
Cannot declare type inside loop or conditional block
Types cannot be declared inside loops or conditional blocks.
let response = HTTP.getText("https://example.com/api/users/1", {});
// Example of the error: a type declared in a loop.
if response.statusCode == 200 {
type User = {id: number, name: text};
return JSON.deserialize<User>(response.contents);
}
// Example resolution: move the type definition to the root level.
type User = {id: number, name: text};
if response.statusCode == 200 {
return JSON.deserialize<User>(response.contents);
}
Module not found
The module <name> is not declared.
// Example of the error: open a non-existent module
open Hello;
Statement in module
Modules can only contain functions and type definitions.
// Example of the error: doing any kind of work in a module.
let result = HTTP.get("https://www.example.com", {});
Query errors
Ambiguous join condition
The join condition has ambiguous identifiers; use an alias to resolve.
let table = [{a: 1, b: 2}, {a: 2, b: 3}];
let other = [{a: 1, c: 2}, {a: 4, c: 5}];
// Example of the error: label "a" exists in both "table" and "other"
return select b from table join other on a = a;
// Example resolution: add aliases to both "table" and "other"
return select b from table as t join other as o on t.a = o.a;
Wildcard in joint selection
The wildcard (*) is not supported when joining two sequences. Specify the columns explicitly instead.
let users = [
{id: 0, name: 'bob', departmentId: 0},
{id: 1, name: 'alice', departmentId: 1}
];
let departments = [
{id: 0, name: 'Finance'},
{id: 1, name: 'R&D'}
];
// Example of the error: wildcard selection not supported with joins
return select * from users as u
left join departments as d
on u.departmentId = d.id;
// Example resolution: specify the columns explicitly.
return select u.id, u.name, d.name as departmentName
from users as u
left join departments as d
on u.departmentId = d.id;'
Wildcard in grouped selection
The wildcard (*) is not supported when grouping a sequence. Specify the columns explicitly instead.
let table = [{a:1, b:2}, {a: 1, b: 2}, {a: 1, b: 5}, {a: 2, b: 5}];
// Example of the error: wildcard selection not supported with groups
return select * from table group by a
// Example resolution: specify the columns explicitly
return select a, count(b) as b
from table group by a
Ambiguous reference in query
The identifier is ambiguous; use an alias to resolve.
let table = [{a: 1, b: 2}, {a: 2, b: 3}];
let other = [{a: 1, c: 2}, {a: 4, c: 5}];
// Example of the error: "a" in the where clause exists in both sequences
return select b
from table
join other on b = c
where a = 1;
// Example resolution: use an alias to disambiguate
return select b
from table as t
join other as o
on t.b = o.c
where t.a = 1;
Type is not queryable
The type <type name> cannot be used with query operators.
// Example of the error: we cannot query a record.
let user = {id: 0, name: 'Francesca'}
return user where id = 0;
Missing alias
The expression contains no implicit field name. Specify one with the 'as' keyword.
// Example of the error:
// FlowScript cannot assign a name to the second column.
return select x, max(x, y)
from [{x: 1, y: 2}]
// Example resolution: specify an alias for the second column
return select x, max(x, y) as maximum
from [{x: 1, y: 2}]
Missing consition on with update
If any clause of a with-expression has a condition, all clauses must have conditions.
let coord = {x: 1, y: 2}
// Example of the error: the second clause has no condition
return coord with {x: x + 1} when y == 0, {x: x - 1};
// Example resolution: add the "otherwise" keyword or a condition.
return coord with {x: x + 1} when y == 0, {x: x - 1} otherwise;
More than one otherwise clause
There may be at most one 'otherwise' clause.
let points = [{x: 1, y: 0}, {x: 0, y: 1}]
// Example of the error: two 'otherwise' clauses.
return points with {y: [1, 2, 3]} when x = 0,
{y: []} otherwise,
{y: [1]} otherwise;
Redundant otherwise clause (warning)
An 'otherwise' clause is only needed in conjunction with 'when' clauses.
let points = [{x: 1, y: 0}, {x: 0, y: 1}]
// Example of the error: the 'otherwise' keyword is not needed here.
return points with {y: [1, 2, 3]} otherwise;
Otherwise clause must come last
An 'otherwise' must be the last clause in a with-expression.
let points = [{x: 1, y: 0}, {x: 0, y: 1}]
// Example of the error: the 'otherwise' clause does not come last.
return points with {y: [1, 2, 3]} otherwise, {y: [2, 3]} when x = 0;
