Do not put a newline on empty `{}` for functions (#447)
The original intent of it was for `if then else` and `try catch` as they aren't likely to be empty, but it accidentally caught function bodys, which have many valid reasons to be empty. Let's special case those out.master
Christopher Chedeau
James Long
parent
4c82f4a2ab
commit
fb52e7a5c8
|
|
@ -449,7 +449,7 @@ function genericPrintNoParens(path, options, print) {
|
|||
parts.push(path.call(print, "source"), ";");
|
||||
|
||||
return concat(parts);
|
||||
case "BlockStatement":
|
||||
case "BlockStatement": {
|
||||
var naked = path.call(
|
||||
function(bodyPath) {
|
||||
return printStatementSequence(bodyPath, options, print);
|
||||
|
|
@ -460,6 +460,14 @@ function genericPrintNoParens(path, options, print) {
|
|||
const hasContent = getFirstString(naked);
|
||||
const hasDirectives = n.directives && n.directives.length > 0;
|
||||
|
||||
var parent = path.getParentNode();
|
||||
if (!hasContent && !hasDirectives && !n.comments &&
|
||||
(parent.type === "ArrowFunctionExpression" ||
|
||||
parent.type === "FunctionExpression" ||
|
||||
parent.type === "FunctionDeclaration")) {
|
||||
return "{}";
|
||||
}
|
||||
|
||||
parts.push("{");
|
||||
|
||||
// Babel 6
|
||||
|
|
@ -491,6 +499,7 @@ function genericPrintNoParens(path, options, print) {
|
|||
parts.push(hardline, "}");
|
||||
|
||||
return concat(parts);
|
||||
}
|
||||
case "ReturnStatement":
|
||||
parts.push("return");
|
||||
|
||||
|
|
|
|||
|
|
@ -30,8 +30,7 @@ function foo() {
|
|||
bar(x);
|
||||
}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
function bar(x: number) {
|
||||
}
|
||||
function bar(x: number) {}
|
||||
function foo() {
|
||||
var x = null;
|
||||
if (x == null) return;
|
||||
|
|
|
|||
|
|
@ -174,8 +174,7 @@ exports[`test issue-530.js 1`] = `
|
|||
|
||||
module.exports = foo;
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
function foo(...args: any) {
|
||||
}
|
||||
function foo(...args: any) {}
|
||||
|
||||
module.exports = foo;
|
||||
"
|
||||
|
|
|
|||
|
|
@ -93,11 +93,9 @@ let tests = [
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @providesModule Arith */
|
||||
|
||||
function num(x: number) {
|
||||
}
|
||||
function num(x: number) {}
|
||||
|
||||
function str(x: string) {
|
||||
}
|
||||
function str(x: string) {}
|
||||
|
||||
function foo() {
|
||||
var x = 0;
|
||||
|
|
@ -291,8 +289,7 @@ y *= 2; // error
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @flow */
|
||||
|
||||
function num(x: number) {
|
||||
}
|
||||
function num(x: number) {}
|
||||
|
||||
num(null * 1);
|
||||
num(1 * null);
|
||||
|
|
|
|||
|
|
@ -58,8 +58,7 @@ function from_test() {
|
|||
}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @flow */
|
||||
function foo(x: string) {
|
||||
}
|
||||
function foo(x: string) {}
|
||||
|
||||
var a = [ 0 ];
|
||||
var b = a.map(function(x) {
|
||||
|
|
|
|||
|
|
@ -41,8 +41,7 @@ module.exports = \"arrays\";
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @providesModule Arrays */
|
||||
|
||||
function foo(x: string) {
|
||||
}
|
||||
function foo(x: string) {}
|
||||
|
||||
var a = [];
|
||||
a[0] = 1;
|
||||
|
|
|
|||
|
|
@ -35,20 +35,13 @@ export default (() => {})();
|
|||
new (() => {});
|
||||
if ((() => {}) ? 1 : 0) {}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
(a => {
|
||||
}).length;
|
||||
typeof (() => {
|
||||
});
|
||||
export default (() => {
|
||||
})();
|
||||
(() => {
|
||||
})()\`\`;
|
||||
(() => {
|
||||
})\`\`;
|
||||
new (() => {
|
||||
})();
|
||||
if ((() => {
|
||||
}) ? 1 : 0) {
|
||||
(a => {}).length;
|
||||
typeof (() => {});
|
||||
export default (() => {})();
|
||||
(() => {})()\`\`;
|
||||
(() => {})\`\`;
|
||||
new (() => {})();
|
||||
if ((() => {}) ? 1 : 0) {
|
||||
}
|
||||
"
|
||||
`;
|
||||
|
|
@ -87,8 +80,7 @@ exports[`test long-call-no-args.js 1`] = `
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
veryLongCall(
|
||||
VERY_VERY_VERY_VERY_VERY_VERY_VERY_VERY_VERY_VERY_LONG_CONSTANT,
|
||||
() => {
|
||||
}
|
||||
() => {}
|
||||
);
|
||||
"
|
||||
`;
|
||||
|
|
|
|||
|
|
@ -171,42 +171,24 @@ console.log(x.async);
|
|||
var async = 3;
|
||||
var y = { async };
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
async function f() {
|
||||
}
|
||||
async function ft<T>(a: T) {
|
||||
}
|
||||
async function f() {}
|
||||
async function ft<T>(a: T) {}
|
||||
|
||||
class C {
|
||||
async m() {
|
||||
}
|
||||
async mt<T>(a: T) {
|
||||
}
|
||||
static async m(a) {
|
||||
}
|
||||
static async mt<T>(a: T) {
|
||||
}
|
||||
async m() {}
|
||||
async mt<T>(a: T) {}
|
||||
static async m(a) {}
|
||||
static async mt<T>(a: T) {}
|
||||
}
|
||||
|
||||
var e = async function() {
|
||||
};
|
||||
var et = async function<T>(a: T) {
|
||||
};
|
||||
var e = async function() {};
|
||||
var et = async function<T>(a: T) {};
|
||||
|
||||
var n = new (async function() {
|
||||
})();
|
||||
var n = new (async function() {})();
|
||||
|
||||
var o = {
|
||||
async m() {
|
||||
}
|
||||
};
|
||||
var ot = {
|
||||
async m<T>(a: T) {
|
||||
}
|
||||
};
|
||||
var oz = {
|
||||
async async() {
|
||||
}
|
||||
};
|
||||
var o = { async m() {} };
|
||||
var ot = { async m<T>(a: T) {} };
|
||||
var oz = { async async() {} };
|
||||
|
||||
var x = { async: 5 };
|
||||
console.log(x.async);
|
||||
|
|
@ -254,8 +236,7 @@ async function foo2(): Promise<string> {
|
|||
}
|
||||
|
||||
async function foo3(): Promise<string> {
|
||||
function bar() {
|
||||
}
|
||||
function bar() {}
|
||||
return bar();
|
||||
}
|
||||
"
|
||||
|
|
|
|||
|
|
@ -411,18 +411,14 @@ function var_var() {
|
|||
|
||||
// function x *
|
||||
function function_toplevel() {
|
||||
function a() {
|
||||
}
|
||||
function a() {
|
||||
}
|
||||
function a() {}
|
||||
function a() {}
|
||||
}
|
||||
|
||||
function function_block() {
|
||||
{
|
||||
function a() {
|
||||
}
|
||||
function a() {
|
||||
}
|
||||
function a() {}
|
||||
function a() {}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -446,8 +442,7 @@ function type_shadow_nested_scope() {
|
|||
}
|
||||
|
||||
// fn params name clash
|
||||
function fn_params_name_clash(x, x /* error: x already bound */) {
|
||||
}
|
||||
function fn_params_name_clash(x, x /* error: x already bound */) {}
|
||||
function fn_params_clash_fn_binding(x, y) {
|
||||
let x = 0;
|
||||
// error: x already bound
|
||||
|
|
|
|||
|
|
@ -235,15 +235,13 @@ const o: MutationObserver = new MutationObserver(callback);
|
|||
// correct
|
||||
new MutationObserver((arr: Array<MutationRecord>) => true);
|
||||
// correct
|
||||
new MutationObserver(() => {
|
||||
});
|
||||
new MutationObserver(() => {});
|
||||
// correct
|
||||
new MutationObserver();
|
||||
// incorrect
|
||||
new MutationObserver(42);
|
||||
// incorrect
|
||||
new MutationObserver((n: number) => {
|
||||
});
|
||||
new MutationObserver((n: number) => {});
|
||||
|
||||
// incorrect
|
||||
// observe
|
||||
|
|
|
|||
|
|
@ -4,8 +4,7 @@ foo(0, \"\");
|
|||
|
||||
function bar<X:number, Y:X>(x:X, y:Y): number { return y*0; }
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
function foo<X, Y: X>(x: X, y: Y): void {
|
||||
}
|
||||
function foo<X, Y: X>(x: X, y: Y): void {}
|
||||
foo(0, \"\");
|
||||
|
||||
function bar<X: number, Y: X>(x: X, y: Y): number {
|
||||
|
|
|
|||
|
|
@ -64,8 +64,7 @@ class Foo<T> {
|
|||
map<U>(callbackfn: () => U): Foo<U> {
|
||||
return new Foo();
|
||||
}
|
||||
set(x: T): void {
|
||||
}
|
||||
set(x: T): void {}
|
||||
get(): T {
|
||||
return this.x;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -106,15 +106,13 @@ var d: { (): string } = function(x: number): string {
|
|||
};
|
||||
|
||||
// ...but subtyping rules still apply
|
||||
var e: { (x: any): void } = function() {
|
||||
};
|
||||
var e: { (x: any): void } = function() {};
|
||||
// arity
|
||||
var f: { (): mixed } = function(): string {
|
||||
return \"hi\";
|
||||
};
|
||||
// return type
|
||||
var g: { (x: string): void } = function(x: mixed) {
|
||||
};
|
||||
var g: { (x: string): void } = function(x: mixed) {};
|
||||
|
||||
// param type
|
||||
// A function can be an object
|
||||
|
|
@ -264,16 +262,13 @@ f.myProp = 123;
|
|||
var c : { myProp: number } = f;
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// Expecting properties that don\'t exist should be an error
|
||||
var a: { someProp: number } = function() {
|
||||
};
|
||||
var a: { someProp: number } = function() {};
|
||||
|
||||
// Expecting properties that do exist should be fine
|
||||
var b: { apply: Function } = function() {
|
||||
};
|
||||
var b: { apply: Function } = function() {};
|
||||
|
||||
// Expecting properties in the functions statics should be fine
|
||||
var f = function() {
|
||||
};
|
||||
var f = function() {};
|
||||
f.myProp = 123;
|
||||
var c: { myProp: number } = f;
|
||||
"
|
||||
|
|
@ -316,8 +311,7 @@ var c: { (x: string): string } = x => x.toFixed();
|
|||
var d: { (): string } = x => \"hi\";
|
||||
|
||||
// ...but subtyping rules still apply
|
||||
var e: { (x: any): void } = () => {
|
||||
};
|
||||
var e: { (x: any): void } = () => {};
|
||||
// arity
|
||||
var f: { (): mixed } = () => \"hi\";
|
||||
// return type
|
||||
|
|
|
|||
|
|
@ -44,8 +44,7 @@ callable(0); // error, number ~> string
|
|||
callable.call(null, 0); // error, number ~> string
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
var x = Boolean(4);
|
||||
function foo(fn: (value: any) => boolean) {
|
||||
}
|
||||
function foo(fn: (value: any) => boolean) {}
|
||||
foo(Boolean);
|
||||
|
||||
var dict: { [k: string]: any } = {};
|
||||
|
|
|
|||
|
|
@ -58,8 +58,7 @@ function* f() {
|
|||
x = class extends (++b) {}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// \"ArrowFunctionExpression\"
|
||||
class a extends (() => {
|
||||
}) {}
|
||||
class a extends (() => {}) {}
|
||||
|
||||
// \"AssignmentExpression\"
|
||||
class a extends (b = c) {}
|
||||
|
|
@ -82,8 +81,7 @@ class a extends class {} {}
|
|||
class a extends (b ? c : d) {}
|
||||
|
||||
// \"FunctionExpression\"
|
||||
class a extends function() {
|
||||
} {}
|
||||
class a extends function() {} {}
|
||||
|
||||
// \"LogicalExpression\"
|
||||
class a extends (b || c) {}
|
||||
|
|
|
|||
|
|
@ -64,20 +64,16 @@ module.exports = {
|
|||
class A {
|
||||
static x: number;
|
||||
static y: string;
|
||||
static foo(x: number) {
|
||||
}
|
||||
static bar(y: string) {
|
||||
}
|
||||
static foo(x: number) {}
|
||||
static bar(y: string) {}
|
||||
}
|
||||
A.qux = function(x: string) {
|
||||
};
|
||||
A.qux = function(x: string) {};
|
||||
|
||||
// error?
|
||||
class B extends A {
|
||||
static x: string;
|
||||
// error?
|
||||
static foo(x: string) {
|
||||
}
|
||||
static foo(x: string) {}
|
||||
// error?
|
||||
static main() {
|
||||
B.x = 0;
|
||||
|
|
@ -103,8 +99,7 @@ class B extends A {
|
|||
|
||||
class C<X> {
|
||||
static x: X;
|
||||
static bar(x: X) {
|
||||
}
|
||||
static bar(x: X) {}
|
||||
static create(): C<*> {
|
||||
return new this();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -69,8 +69,7 @@ class C<X> {
|
|||
x: X;
|
||||
}
|
||||
|
||||
function foo<X>(c: C<X>, x: X) {
|
||||
}
|
||||
function foo<X>(c: C<X>, x: X) {}
|
||||
|
||||
type O = { f: number };
|
||||
|
||||
|
|
|
|||
|
|
@ -17,8 +17,7 @@ function foo(x: Class<A>): A {
|
|||
}
|
||||
|
||||
class B {
|
||||
constructor(_: any) {
|
||||
}
|
||||
constructor(_: any) {}
|
||||
}
|
||||
function bar(x: Class<B>): B {
|
||||
return new x(); // error (too few args)
|
||||
|
|
|
|||
|
|
@ -6,8 +6,7 @@ exports[`test A.js 1`] = `
|
|||
module.exports = A;
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
class A {
|
||||
foo(x: number): void {
|
||||
}
|
||||
foo(x: number): void {}
|
||||
}
|
||||
|
||||
module.exports = A;
|
||||
|
|
@ -51,8 +50,7 @@ module.exports = C;
|
|||
var B = require(\"./B\");
|
||||
|
||||
class C extends B {
|
||||
foo(x: string): void {
|
||||
}
|
||||
foo(x: string): void {}
|
||||
}
|
||||
|
||||
let c = new C();
|
||||
|
|
|
|||
|
|
@ -85,15 +85,13 @@ function local_meth() {
|
|||
* @flow
|
||||
*/
|
||||
|
||||
function takes_string(_: string) {
|
||||
}
|
||||
function takes_string(_: string) {}
|
||||
|
||||
// global write from function
|
||||
//
|
||||
var global_x = \"hello\";
|
||||
|
||||
function global_f() {
|
||||
}
|
||||
function global_f() {}
|
||||
function global_g() {
|
||||
global_x = 42;
|
||||
}
|
||||
|
|
@ -114,8 +112,7 @@ global_x = 42;
|
|||
function local_func() {
|
||||
var local_x = \"hello\";
|
||||
|
||||
function local_f() {
|
||||
}
|
||||
function local_f() {}
|
||||
function local_g() {
|
||||
local_x = 42;
|
||||
}
|
||||
|
|
@ -136,8 +133,7 @@ function local_func() {
|
|||
var global_y = \"hello\";
|
||||
|
||||
var global_o = {
|
||||
f: function() {
|
||||
},
|
||||
f: function() {},
|
||||
g: function() {
|
||||
global_y = 42;
|
||||
}
|
||||
|
|
@ -160,8 +156,7 @@ function local_meth() {
|
|||
var local_y = \"hello\";
|
||||
|
||||
var local_o = {
|
||||
f: function() {
|
||||
},
|
||||
f: function() {},
|
||||
g: function() {
|
||||
local_y = 42;
|
||||
}
|
||||
|
|
@ -268,8 +263,7 @@ call_me();
|
|||
*/
|
||||
|
||||
// global, anybody can call it at any time
|
||||
var call_me: () => void = () => {
|
||||
};
|
||||
var call_me: () => void = () => {};
|
||||
|
||||
function g(x: ?number) {
|
||||
const const_x = x;
|
||||
|
|
|
|||
|
|
@ -113,8 +113,7 @@ function f(
|
|||
someReallyLongArgument: WithSomeLongType,
|
||||
// Trailing comment should stay after
|
||||
someReallyLongArgument2: WithSomeLongType
|
||||
) {
|
||||
}
|
||||
) {}
|
||||
|
||||
// Comments should either stay at the end of the line or always before, but
|
||||
// not one before and one after.
|
||||
|
|
@ -314,8 +313,7 @@ function f(
|
|||
someReallyLongArgument: WithSomeLongType,
|
||||
// Trailing comment should stay after
|
||||
someReallyLongArgument2: WithSomeLongType
|
||||
) {
|
||||
}
|
||||
) {}
|
||||
|
||||
// Comments should either stay at the end of the line or always before, but
|
||||
// not one before and one after.
|
||||
|
|
|
|||
|
|
@ -4,8 +4,7 @@ function f(x:string) { }
|
|||
|
||||
module.exports = f;
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
function f(x: string) {
|
||||
}
|
||||
function f(x: string) {}
|
||||
|
||||
module.exports = f;
|
||||
"
|
||||
|
|
|
|||
|
|
@ -4,8 +4,7 @@ exports[`test classes.js 1`] = `
|
|||
}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
class c {
|
||||
[\"i\"]() {
|
||||
}
|
||||
[\"i\"]() {}
|
||||
}
|
||||
"
|
||||
`;
|
||||
|
|
|
|||
|
|
@ -10,13 +10,11 @@ class D {
|
|||
module.exports = C;
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
class C {
|
||||
constructor() {
|
||||
}
|
||||
constructor() {}
|
||||
}
|
||||
|
||||
class D {
|
||||
constructor(): number {
|
||||
}
|
||||
constructor(): number {}
|
||||
}
|
||||
|
||||
module.exports = C;
|
||||
|
|
|
|||
|
|
@ -218,17 +218,13 @@ var {
|
|||
(p: void);
|
||||
|
||||
// error: string ~> void
|
||||
function obj_prop_err({ x: { y } } = null) {
|
||||
}
|
||||
function obj_prop_err({ x: { y } } = null) {}
|
||||
// error: property \`x\` cannot be accessed on null
|
||||
function obj_rest_err({ ...o } = 0) {
|
||||
}
|
||||
function obj_rest_err({ ...o } = 0) {}
|
||||
// error: expected object instead of number
|
||||
function arr_elem_err([ x ] = null) {
|
||||
}
|
||||
function arr_elem_err([ x ] = null) {}
|
||||
// error: element 0 cannot be accessed on null
|
||||
function arr_rest_err([ ...a ] = null) {
|
||||
}
|
||||
function arr_rest_err([ ...a ] = null) {}
|
||||
|
||||
// error: expected array instead of null
|
||||
function gen<T>(x: T, { p = x }: { p: T }): T {
|
||||
|
|
@ -242,19 +238,14 @@ obj_prop_var(({}: { p?: { q?: null } }));
|
|||
|
||||
// ok
|
||||
// union-like upper bounds preserved through destructuring
|
||||
function obj_prop_opt({ p }: { p?: string } = { p: 0 }) {
|
||||
}
|
||||
function obj_prop_maybe({ p }: { p: ?string } = { p: 0 }) {
|
||||
}
|
||||
function obj_prop_union({ p }: { p: number | string } = { p: true }) {
|
||||
}
|
||||
function obj_prop_opt({ p }: { p?: string } = { p: 0 }) {}
|
||||
function obj_prop_maybe({ p }: { p: ?string } = { p: 0 }) {}
|
||||
function obj_prop_union({ p }: { p: number | string } = { p: true }) {}
|
||||
|
||||
// TODO: union-of-objects upper bounds preserved through destructuring
|
||||
function obj_prop_union2({ p }: { p: number } | { p: string } = { p: true }) {
|
||||
}
|
||||
function obj_prop_union2({ p }: { p: number } | { p: string } = { p: true }) {}
|
||||
|
||||
function default_expr_scope({ a, b = a }) {
|
||||
}
|
||||
function default_expr_scope({ a, b = a }) {}
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
@ -360,11 +351,9 @@ bar({ x: \"\", y: 0 });
|
|||
var spread = { y: \"\" };
|
||||
var extend: { x: number, y: string, z: boolean } = { x: 0, ...spread };
|
||||
|
||||
function qux(_: { a: number }) {
|
||||
}
|
||||
function qux(_: { a: number }) {}
|
||||
qux({ a: \"\" });
|
||||
function corge({ b }: { b: string }) {
|
||||
}
|
||||
function corge({ b }: { b: string }) {}
|
||||
corge({ b: 0 });
|
||||
|
||||
var { n }: { n: number } = { n: \"\" };
|
||||
|
|
@ -484,35 +473,27 @@ function arr_rest_pattern<X>([ _, ...a ] : ArrRest<X>) { // a: [X]
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// @flow
|
||||
|
||||
function obj_pattern<X>({ prop }: { prop: X }) {
|
||||
}
|
||||
function obj_pattern<X>({ prop }: { prop: X }) {}
|
||||
// prop: X
|
||||
type Prop<X> = { prop: X };
|
||||
function obj_pattern2<X>({ prop }: Prop<X>) {
|
||||
}
|
||||
function obj_pattern2<X>({ prop }: Prop<X>) {}
|
||||
|
||||
// prop: X
|
||||
function arr_pattern<X>([ elem ]: X[]) {
|
||||
}
|
||||
function arr_pattern<X>([ elem ]: X[]) {}
|
||||
// elem: X
|
||||
type Elem<X> = X[];
|
||||
function arr_pattern2<X>([ elem ]: Elem<X>) {
|
||||
}
|
||||
function arr_pattern2<X>([ elem ]: Elem<X>) {}
|
||||
|
||||
// elem: X
|
||||
function tup_pattern<X>([ proj ]: [X]) {
|
||||
}
|
||||
function tup_pattern<X>([ proj ]: [X]) {}
|
||||
// proj: X
|
||||
type Proj<X> = [X];
|
||||
function tup_pattern2<X>([ proj ]: Proj<X>) {
|
||||
}
|
||||
function tup_pattern2<X>([ proj ]: Proj<X>) {}
|
||||
|
||||
// proj: X
|
||||
function rest_antipattern<T>(...t: T) {
|
||||
}
|
||||
function rest_antipattern<T>(...t: T) {}
|
||||
// nonsense
|
||||
function rest_pattern<X>(...r: X[]) {
|
||||
}
|
||||
function rest_pattern<X>(...r: X[]) {}
|
||||
|
||||
// r: X[]
|
||||
function obj_rest_pattern<X>({ _, ...o }: { _: any, x: X }) {
|
||||
|
|
|
|||
|
|
@ -301,8 +301,7 @@ let tests = [
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// @flow
|
||||
|
||||
let listener: EventListener = function(event: Event): void {
|
||||
};
|
||||
let listener: EventListener = function(event: Event): void {};
|
||||
|
||||
let tests = [
|
||||
// attachEvent
|
||||
|
|
@ -424,26 +423,16 @@ let tests = [
|
|||
function() {
|
||||
document.registerElement(\"custom-element\", {
|
||||
prototype: Object.create(HTMLElement.prototype, {
|
||||
createdCallback: {
|
||||
value: function createdCallback() {
|
||||
}
|
||||
},
|
||||
attachedCallback: {
|
||||
value: function attachedCallback() {
|
||||
}
|
||||
},
|
||||
detachedCallback: {
|
||||
value: function detachedCallback() {
|
||||
}
|
||||
},
|
||||
createdCallback: { value: function createdCallback() {} },
|
||||
attachedCallback: { value: function attachedCallback() {} },
|
||||
detachedCallback: { value: function detachedCallback() {} },
|
||||
attributeChangedCallback: {
|
||||
value: function attributeChangedCallback(
|
||||
attributeLocalName,
|
||||
oldAttributeValue,
|
||||
newAttributeValue,
|
||||
attributeNamespace
|
||||
) {
|
||||
}
|
||||
) {}
|
||||
}
|
||||
})
|
||||
});
|
||||
|
|
@ -452,19 +441,15 @@ let tests = [
|
|||
function() {
|
||||
document.registerElement(\"custom-element\", {
|
||||
prototype: Object.assign(Object.create(HTMLElement.prototype), {
|
||||
createdCallback() {
|
||||
},
|
||||
attachedCallback() {
|
||||
},
|
||||
detachedCallback() {
|
||||
},
|
||||
createdCallback() {},
|
||||
attachedCallback() {},
|
||||
detachedCallback() {},
|
||||
attributeChangedCallback(
|
||||
attributeLocalName,
|
||||
oldAttributeValue,
|
||||
newAttributeValue,
|
||||
attributeNamespace
|
||||
) {
|
||||
}
|
||||
) {}
|
||||
})
|
||||
});
|
||||
},
|
||||
|
|
@ -479,8 +464,7 @@ let tests = [
|
|||
newVal: string,
|
||||
// Error: This might be null
|
||||
namespace: string
|
||||
) {
|
||||
}
|
||||
) {}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,8 +7,7 @@ module.exports = num;
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// @flow
|
||||
var num = 42;
|
||||
function bar() {
|
||||
}
|
||||
function bar() {}
|
||||
bar();
|
||||
module.exports = num;
|
||||
"
|
||||
|
|
@ -39,8 +38,7 @@ const idxResult = idx(obj, obj => obj.a.b.c.d);
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// @flow
|
||||
var num = require(\"./import\");
|
||||
function foo(x) {
|
||||
}
|
||||
function foo(x) {}
|
||||
foo(0);
|
||||
var a: string = num;
|
||||
|
||||
|
|
|
|||
|
|
@ -36,10 +36,8 @@ class C5 {
|
|||
new C5().m = new C5().m - 42;
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
class C1 {
|
||||
m() {
|
||||
}
|
||||
m() {
|
||||
}
|
||||
m() {}
|
||||
m() {}
|
||||
}
|
||||
|
||||
new C1().m();
|
||||
|
|
@ -48,17 +46,14 @@ class C2 {
|
|||
get m() {
|
||||
return 42;
|
||||
}
|
||||
m() {
|
||||
}
|
||||
m() {}
|
||||
}
|
||||
|
||||
new C2().m();
|
||||
|
||||
class C3 {
|
||||
set m(x) {
|
||||
}
|
||||
m() {
|
||||
}
|
||||
set m(x) {}
|
||||
m() {}
|
||||
}
|
||||
|
||||
new C3().m();
|
||||
|
|
@ -67,20 +62,17 @@ class C4 {
|
|||
get m() {
|
||||
return 42;
|
||||
}
|
||||
set m(x: number) {
|
||||
}
|
||||
set m(x: number) {}
|
||||
}
|
||||
|
||||
new C4().m = new C4().m - 42;
|
||||
|
||||
class C5 {
|
||||
m() {
|
||||
}
|
||||
m() {}
|
||||
get m() {
|
||||
return 42;
|
||||
}
|
||||
set m(x: number) {
|
||||
}
|
||||
set m(x: number) {}
|
||||
}
|
||||
|
||||
new C5().m = new C5().m - 42;
|
||||
|
|
|
|||
|
|
@ -1350,8 +1350,7 @@ import {
|
|||
exports[`test export_default_arrow_expression.js 1`] = `
|
||||
"export default () => {};
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
export default () => {
|
||||
};
|
||||
export default () => {};
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
@ -1379,32 +1378,28 @@ export default (class foobar {});
|
|||
exports[`test export_default_function_declaration.js 1`] = `
|
||||
"export default function() {}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
export default function() {
|
||||
}
|
||||
export default function() {}
|
||||
"
|
||||
`;
|
||||
|
||||
exports[`test export_default_function_declaration_named.js 1`] = `
|
||||
"export default function f(){}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
export default function f() {
|
||||
}
|
||||
export default function f() {}
|
||||
"
|
||||
`;
|
||||
|
||||
exports[`test export_default_function_expression.js 1`] = `
|
||||
"export default (function() {});
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
export default (function() {
|
||||
});
|
||||
export default (function() {});
|
||||
"
|
||||
`;
|
||||
|
||||
exports[`test export_default_function_expression_named.js 1`] = `
|
||||
"export default (function f(){})
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
export default (function f() {
|
||||
});
|
||||
export default (function f() {});
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
|
|||
|
|
@ -79,8 +79,7 @@ let tests = [
|
|||
},
|
||||
// passed as a function
|
||||
function(copyProperties: Object$Assign) {
|
||||
function x(cb: Function) {
|
||||
}
|
||||
function x(cb: Function) {}
|
||||
x(copyProperties);
|
||||
}
|
||||
];
|
||||
|
|
@ -206,8 +205,7 @@ let tests = [
|
|||
},
|
||||
// passed as a function
|
||||
function(mergeInto: $Facebookism$MergeInto) {
|
||||
function x(cb: Function) {
|
||||
}
|
||||
function x(cb: Function) {}
|
||||
x(mergeInto);
|
||||
}
|
||||
];
|
||||
|
|
|
|||
|
|
@ -122,8 +122,7 @@ for (let v of e.entries()) {
|
|||
const [ i, j ]: [string, string] = v; // correct
|
||||
}
|
||||
|
||||
e.getAll(\"content-type\").forEach((v: string) => {
|
||||
}); // correct
|
||||
e.getAll(\"content-type\").forEach((v: string) => {}); // correct
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
@ -412,7 +411,6 @@ for (let v of e.entries()) {
|
|||
const [ i, j ]: [string, string] = v; // correct
|
||||
}
|
||||
|
||||
e.getAll(\"key1\").forEach((v: string) => {
|
||||
}); // correct
|
||||
e.getAll(\"key1\").forEach((v: string) => {}); // correct
|
||||
"
|
||||
`;
|
||||
|
|
|
|||
|
|
@ -317,8 +317,7 @@ function bad(x: Function, y: Object): void {
|
|||
|
||||
let tests = [
|
||||
function(y: () => void, z: Function) {
|
||||
function x() {
|
||||
}
|
||||
function x() {}
|
||||
(x.length: void);
|
||||
// error, it\'s a number
|
||||
(y.length: void);
|
||||
|
|
@ -333,8 +332,7 @@ let tests = [
|
|||
(z.name: void); // error, it\'s a string
|
||||
},
|
||||
function(y: () => void, z: Function) {
|
||||
function x() {
|
||||
}
|
||||
function x() {}
|
||||
x.length = \"foo\";
|
||||
// error, it\'s a number
|
||||
y.length = \"foo\";
|
||||
|
|
@ -373,23 +371,14 @@ new (function() {});
|
|||
(function() {});
|
||||
a = function f() {} || b;
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
(function() {
|
||||
}).length;
|
||||
typeof (function() {
|
||||
});
|
||||
export default (function() {
|
||||
})();
|
||||
(function() {
|
||||
})()\`\`;
|
||||
(function() {
|
||||
})\`\`;
|
||||
new (function() {
|
||||
})();
|
||||
(function() {
|
||||
});
|
||||
a = function f() {
|
||||
} ||
|
||||
b;
|
||||
(function() {}).length;
|
||||
typeof (function() {});
|
||||
export default (function() {})();
|
||||
(function() {})()\`\`;
|
||||
(function() {})\`\`;
|
||||
new (function() {})();
|
||||
(function() {});
|
||||
a = function f() {} || b;
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
|
|||
|
|
@ -81,8 +81,7 @@ class D extends C {
|
|||
// @flow
|
||||
|
||||
class C {
|
||||
override() {
|
||||
}
|
||||
override() {}
|
||||
}
|
||||
|
||||
class D extends C {
|
||||
|
|
@ -92,8 +91,7 @@ class D extends C {
|
|||
bar() {
|
||||
this.override;
|
||||
}
|
||||
override() {
|
||||
}
|
||||
override() {}
|
||||
}
|
||||
"
|
||||
`;
|
||||
|
|
|
|||
|
|
@ -79,19 +79,16 @@ class Foo {
|
|||
get propWithMatchingGetterAndSetter(): number {
|
||||
return 4;
|
||||
}
|
||||
set propWithMatchingGetterAndSetter(x: number) {
|
||||
}
|
||||
set propWithMatchingGetterAndSetter(x: number) {}
|
||||
|
||||
// The getter and setter need not have the same type - no error
|
||||
get propWithSubtypingGetterAndSetter(): ?number {
|
||||
return 4;
|
||||
}
|
||||
set propWithSubtypingGetterAndSetter(x: number) {
|
||||
}
|
||||
set propWithSubtypingGetterAndSetter(x: number) {}
|
||||
|
||||
// The getter and setter need not have the same type - no error
|
||||
set propWithSubtypingGetterAndSetterReordered(x: number) {
|
||||
}
|
||||
set propWithSubtypingGetterAndSetterReordered(x: number) {}
|
||||
get propWithSubtypingGetterAndSetterReordered(): ?number {
|
||||
return 4;
|
||||
}
|
||||
|
|
@ -99,8 +96,7 @@ class Foo {
|
|||
get propWithMismatchingGetterAndSetter(): number {
|
||||
return 4;
|
||||
}
|
||||
set propWithMismatchingGetterAndSetter(x: string) {
|
||||
}
|
||||
set propWithMismatchingGetterAndSetter(x: string) {}
|
||||
|
||||
// doesn\'t match getter (OK)
|
||||
propOverriddenWithGetter: number;
|
||||
|
|
@ -109,8 +105,7 @@ class Foo {
|
|||
}
|
||||
|
||||
propOverriddenWithSetter: number;
|
||||
set propOverriddenWithSetter(x: string) {
|
||||
}
|
||||
set propOverriddenWithSetter(x: string) {}
|
||||
}
|
||||
|
||||
var foo = new Foo();
|
||||
|
|
@ -231,17 +226,14 @@ var obj = {
|
|||
get propWithMatchingGetterAndSetter(): number {
|
||||
return 4;
|
||||
},
|
||||
set propWithMatchingGetterAndSetter(x: number) {
|
||||
},
|
||||
set propWithMatchingGetterAndSetter(x: number) {},
|
||||
// The getter and setter need not have the same type
|
||||
get propWithSubtypingGetterAndSetter(): ?number {
|
||||
return 4;
|
||||
},
|
||||
// OK
|
||||
set propWithSubtypingGetterAndSetter(x: number) {
|
||||
},
|
||||
set propWithSubtypingGetterAndSetterReordered(x: number) {
|
||||
},
|
||||
set propWithSubtypingGetterAndSetter(x: number) {},
|
||||
set propWithSubtypingGetterAndSetterReordered(x: number) {},
|
||||
// OK
|
||||
get propWithSubtypingGetterAndSetterReordered(): ?number {
|
||||
return 4;
|
||||
|
|
@ -249,10 +241,8 @@ var obj = {
|
|||
get exampleOfOrderOfGetterAndSetter(): A {
|
||||
return new A();
|
||||
},
|
||||
set exampleOfOrderOfGetterAndSetter(x: B) {
|
||||
},
|
||||
set exampleOfOrderOfGetterAndSetterReordered(x: B) {
|
||||
},
|
||||
set exampleOfOrderOfGetterAndSetter(x: B) {},
|
||||
set exampleOfOrderOfGetterAndSetterReordered(x: B) {},
|
||||
get exampleOfOrderOfGetterAndSetterReordered(): A {
|
||||
return new A();
|
||||
}
|
||||
|
|
@ -430,8 +420,7 @@ class Base {
|
|||
|
||||
(class extends Base {
|
||||
// error: setter incompatible with read/write property
|
||||
set x(value: B): void {
|
||||
}
|
||||
set x(value: B): void {}
|
||||
});
|
||||
|
||||
(class extends Base {
|
||||
|
|
@ -439,14 +428,12 @@ class Base {
|
|||
get x(): C {
|
||||
return c;
|
||||
}
|
||||
set x(value: A): void {
|
||||
}
|
||||
set x(value: A): void {}
|
||||
});
|
||||
|
||||
(class extends Base {
|
||||
// error: setter incompatible with read-only property
|
||||
set pos(value: B): void {
|
||||
}
|
||||
set pos(value: B): void {}
|
||||
});
|
||||
|
||||
(class extends Base {
|
||||
|
|
@ -465,8 +452,7 @@ class Base {
|
|||
|
||||
(class extends Base {
|
||||
// ok: setter contravariant with write-only property
|
||||
set neg(value: A): void {
|
||||
}
|
||||
set neg(value: A): void {}
|
||||
});
|
||||
|
||||
(class extends Base {
|
||||
|
|
|
|||
|
|
@ -53,48 +53,42 @@ function _for_of(arr: Array<number>) {
|
|||
|
||||
function _if(b: () => boolean) {
|
||||
if (b()) {
|
||||
var f = function() {
|
||||
};
|
||||
var f = function() {};
|
||||
}
|
||||
f(); // error, possibly undefined
|
||||
}
|
||||
|
||||
function _while(b: () => boolean) {
|
||||
while (b()) {
|
||||
var f = function() {
|
||||
};
|
||||
var f = function() {};
|
||||
}
|
||||
f(); // error, possibly undefined
|
||||
}
|
||||
|
||||
function _do_while(b: () => boolean) {
|
||||
do {
|
||||
var f = function() {
|
||||
};
|
||||
var f = function() {};
|
||||
} while (b());
|
||||
f(); // ok
|
||||
}
|
||||
|
||||
function _for(n: number) {
|
||||
for (var i = 0; i < n; i++) {
|
||||
var f = function() {
|
||||
};
|
||||
var f = function() {};
|
||||
}
|
||||
f(); // error, possibly undefined
|
||||
}
|
||||
|
||||
function _for_in(obj: Object) {
|
||||
for (var p in obj) {
|
||||
var f = function() {
|
||||
};
|
||||
var f = function() {};
|
||||
}
|
||||
f(); // error, possibly undefined
|
||||
}
|
||||
|
||||
function _for_of(arr: Array<number>) {
|
||||
for (var x of arr) {
|
||||
var f = function() {
|
||||
};
|
||||
var f = function() {};
|
||||
}
|
||||
f(); // error, possibly undefined
|
||||
}
|
||||
|
|
|
|||
|
|
@ -190,13 +190,11 @@ declare class C {
|
|||
new C().bar((x: string) => { }); // error, number ~/~> string
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
interface I { foo(x: number): void }
|
||||
(function foo(x: number) {
|
||||
}: I);
|
||||
(function foo(x: number) {}: I);
|
||||
|
||||
// error, property \`foo\` not found function
|
||||
declare class C { bar(i: I): void, bar(f: (x: number) => void): void }
|
||||
|
||||
new C().bar((x: string) => {
|
||||
}); // error, number ~/~> string
|
||||
new C().bar((x: string) => {}); // error, number ~/~> string
|
||||
"
|
||||
`;
|
||||
|
|
|
|||
|
|
@ -38,8 +38,7 @@ for (var y in this) {
|
|||
}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
var a = [ true, false ];
|
||||
function foo(x) {
|
||||
}
|
||||
function foo(x) {}
|
||||
|
||||
for (var i = 0; i < 3; i++) {
|
||||
foo(a[i]);
|
||||
|
|
|
|||
|
|
@ -37,14 +37,12 @@ var red:string = tuple[indices.red]; // error: tuple[0] is a number
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
var APIKeys = require(\"./enum\");
|
||||
// object that maps \"AGE\" to \"age\", \"NAME\" to \"name\"
|
||||
function foo(x: $Keys<typeof APIKeys>) {
|
||||
}
|
||||
function foo(x: $Keys<typeof APIKeys>) {}
|
||||
foo(\"AGE\");
|
||||
foo(\"LOCATION\");
|
||||
|
||||
// error
|
||||
function bar(x: $Keys<{ age: number }>) {
|
||||
}
|
||||
function bar(x: $Keys<{ age: number }>) {}
|
||||
bar(APIKeys.AGE);
|
||||
// not an error: APIKeys.AGE = \"age\"
|
||||
bar(APIKeys.NAME);
|
||||
|
|
|
|||
|
|
@ -159,8 +159,7 @@ var x: string = 0;
|
|||
var x: number = 1;
|
||||
|
||||
//declare var T: $Type<number | Array<T>>;
|
||||
function foo(p: boolean) {
|
||||
}
|
||||
function foo(p: boolean) {}
|
||||
|
||||
function sorry(really: boolean) {
|
||||
if (really) {
|
||||
|
|
|
|||
|
|
@ -36,12 +36,9 @@ function f(x) {
|
|||
f(foo);
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
class C {
|
||||
C() {
|
||||
}
|
||||
foo() {
|
||||
}
|
||||
static bar() {
|
||||
}
|
||||
C() {}
|
||||
foo() {}
|
||||
static bar() {}
|
||||
qux() {
|
||||
this.constructor.x;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,8 +21,7 @@ module.exports = {};
|
|||
var A = { x: true, ...{} };
|
||||
module.exports.cls = A;
|
||||
|
||||
function f(x: boolean) {
|
||||
}
|
||||
function f(x: boolean) {}
|
||||
module.exports.fn = f;
|
||||
|
||||
A.y = \"?\";
|
||||
|
|
@ -147,8 +146,7 @@ module.exports = {obj: o};
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @providesModule E */
|
||||
|
||||
function h(x: number) {
|
||||
}
|
||||
function h(x: number) {}
|
||||
var proto = { fn: h };
|
||||
|
||||
var o = Object.create(proto);
|
||||
|
|
|
|||
|
|
@ -41,8 +41,7 @@ module.exports = f;
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @flow */
|
||||
|
||||
function g(x: string) {
|
||||
}
|
||||
function g(x: string) {}
|
||||
|
||||
//function f(x) { g(x); return x; }
|
||||
//function f(x:number) { g(x); return x; }
|
||||
|
|
|
|||
|
|
@ -42,8 +42,7 @@ var o2: Foo = new Foo();
|
|||
function Foo() {
|
||||
this.x = 0;
|
||||
}
|
||||
Foo.prototype.m = function() {
|
||||
};
|
||||
Foo.prototype.m = function() {};
|
||||
|
||||
var o1: { x: number, m(): void } = new Foo();
|
||||
|
||||
|
|
@ -58,8 +57,7 @@ class D extends C { }
|
|||
var d: { +m: () => void } = new D();
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
class C {
|
||||
m() {
|
||||
}
|
||||
m() {}
|
||||
}
|
||||
class D extends C {}
|
||||
|
||||
|
|
|
|||
|
|
@ -121,8 +121,7 @@ class Qux {
|
|||
return this.w;
|
||||
}
|
||||
|
||||
fooqux(x: number) {
|
||||
}
|
||||
fooqux(x: number) {}
|
||||
}
|
||||
|
||||
module.exports = Qux;
|
||||
|
|
|
|||
|
|
@ -59,8 +59,7 @@ module.exports = true;
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @providesModule Condition */
|
||||
|
||||
function f(x: number) {
|
||||
}
|
||||
function f(x: number) {}
|
||||
function g() {
|
||||
return 42 || \"hello\";
|
||||
}
|
||||
|
|
@ -86,8 +85,7 @@ function bar() {
|
|||
}
|
||||
|
||||
class C {
|
||||
qux() {
|
||||
}
|
||||
qux() {}
|
||||
}
|
||||
|
||||
function foo() {
|
||||
|
|
@ -140,8 +138,7 @@ module.exports = FlowSA;
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @providesModule FlowSA */
|
||||
|
||||
function check(x: string) {
|
||||
}
|
||||
function check(x: string) {}
|
||||
|
||||
function FlowSA() {
|
||||
var x = 0;
|
||||
|
|
@ -198,18 +195,15 @@ module.exports = \"sigma\";
|
|||
/* @providesModule Sigma */
|
||||
|
||||
class A {
|
||||
a() {
|
||||
}
|
||||
a() {}
|
||||
}
|
||||
|
||||
class B extends A {
|
||||
b() {
|
||||
}
|
||||
b() {}
|
||||
}
|
||||
|
||||
class C extends B {
|
||||
c() {
|
||||
}
|
||||
c() {}
|
||||
}
|
||||
|
||||
function bar(x: B) {
|
||||
|
|
@ -234,8 +228,7 @@ function foo(x: A) {
|
|||
}
|
||||
|
||||
class D {
|
||||
d() {
|
||||
}
|
||||
d() {}
|
||||
}
|
||||
|
||||
function baz(x: D) {
|
||||
|
|
|
|||
|
|
@ -31,8 +31,7 @@ module.exports = { foo: (\"\": number) };
|
|||
/*@flow*/
|
||||
// import type { T } from \'...\'
|
||||
type T = (x: number) => void;
|
||||
var f: T = function(x: string): void {
|
||||
};
|
||||
var f: T = function(x: string): void {};
|
||||
|
||||
type Map<X, Y> = (x: X) => Y;
|
||||
|
||||
|
|
|
|||
|
|
@ -44,18 +44,14 @@ var data = \"foo\";
|
|||
|
||||
ls.stdin.write(data);
|
||||
ls.stdin.write(data, \"utf-8\");
|
||||
ls.stdin.write(data, () => {
|
||||
});
|
||||
ls.stdin.write(data, \"utf-8\", () => {
|
||||
});
|
||||
ls.stdin.write(data, () => {});
|
||||
ls.stdin.write(data, \"utf-8\", () => {});
|
||||
|
||||
ls.stdin.end();
|
||||
ls.stdin.end(data);
|
||||
ls.stdin.end(data, \"utf-8\");
|
||||
ls.stdin.end(data, () => {
|
||||
});
|
||||
ls.stdin.end(data, \"utf-8\", () => {
|
||||
});
|
||||
ls.stdin.end(data, () => {});
|
||||
ls.stdin.end(data, \"utf-8\", () => {});
|
||||
|
||||
var ws = fs.createWriteStream(\"/dev/null\");
|
||||
ls.stdout.pipe(ws).end();
|
||||
|
|
|
|||
|
|
@ -42,11 +42,9 @@ function bar(): ?string {
|
|||
return null;
|
||||
}
|
||||
|
||||
function qux(x: string) {
|
||||
}
|
||||
function qux(x: string) {}
|
||||
|
||||
function corge(x: number) {
|
||||
}
|
||||
function corge(x: number) {}
|
||||
|
||||
var x = bar();
|
||||
// x: ?string
|
||||
|
|
@ -76,15 +74,12 @@ bar(\'hmm\');
|
|||
function fn(data: ?{}) {}
|
||||
fn({some: \'literal\'});
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
function foo(x: ?string) {
|
||||
}
|
||||
function bar(x: ?number) {
|
||||
}
|
||||
function foo(x: ?string) {}
|
||||
function bar(x: ?number) {}
|
||||
foo(\"hmm\");
|
||||
bar(\"hmm\");
|
||||
|
||||
function fn(data: ?{}) {
|
||||
}
|
||||
function fn(data: ?{}) {}
|
||||
fn({ some: \"literal\" });
|
||||
"
|
||||
`;
|
||||
|
|
|
|||
|
|
@ -4,10 +4,7 @@ exports[`test a.js 1`] = `
|
|||
module.exports = { a() {} };~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @flow */
|
||||
|
||||
module.exports = {
|
||||
a() {
|
||||
}
|
||||
};
|
||||
module.exports = { a() {} };
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
@ -22,14 +19,7 @@ module.exports = b;
|
|||
/* @flow */
|
||||
|
||||
var a = require(\"./a\");
|
||||
var b = Object.assign(
|
||||
{
|
||||
bar() {
|
||||
},
|
||||
...{}
|
||||
},
|
||||
a
|
||||
);
|
||||
var b = Object.assign({ bar() {}, ...{} }, a);
|
||||
b.a();
|
||||
// works here
|
||||
module.exports = b;
|
||||
|
|
@ -207,8 +197,7 @@ var any: Object = {};
|
|||
// error, Array<string>
|
||||
class Foo {
|
||||
prop: string;
|
||||
foo() {
|
||||
}
|
||||
foo() {}
|
||||
}
|
||||
// constructor and foo not enumerable
|
||||
(Object.keys(new Foo()): Array<\"error\">);
|
||||
|
|
@ -216,8 +205,7 @@ class Foo {
|
|||
// error: prop ~> error
|
||||
class Bar extends Foo {
|
||||
bar_prop: string;
|
||||
bar() {
|
||||
}
|
||||
bar() {}
|
||||
}
|
||||
// only own enumerable props
|
||||
(Object.keys(new Bar()): Array<\"error\">); // error: bar_prop ~> error
|
||||
|
|
@ -411,14 +399,10 @@ var k : Object = a.constructor;
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @flow */
|
||||
|
||||
function takesABool(x: boolean) {
|
||||
}
|
||||
function takesAString(x: string) {
|
||||
}
|
||||
function takesANumber(x: number) {
|
||||
}
|
||||
function takesAnObject(x: Object) {
|
||||
}
|
||||
function takesABool(x: boolean) {}
|
||||
function takesAString(x: string) {}
|
||||
function takesANumber(x: number) {}
|
||||
function takesAnObject(x: Object) {}
|
||||
|
||||
class Foo {}
|
||||
|
||||
|
|
@ -473,8 +457,7 @@ takesAString(y.toString());
|
|||
// ... on a primitive
|
||||
(123).toString();
|
||||
(123).toString;
|
||||
(123).toString = function() {
|
||||
};
|
||||
(123).toString = function() {};
|
||||
// error
|
||||
(123).toString(2);
|
||||
(123).toString(\"foo\");
|
||||
|
|
|
|||
|
|
@ -39,8 +39,7 @@ bliffl.corge;
|
|||
// error
|
||||
bliffl.constructor = baz;
|
||||
// error
|
||||
bliffl.toString = function() {
|
||||
};
|
||||
bliffl.toString = function() {};
|
||||
|
||||
// error
|
||||
baz.baz = 0;
|
||||
|
|
|
|||
|
|
@ -27,12 +27,10 @@ class C {
|
|||
x<T>(x: T = 0) {}
|
||||
}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
function x<T>(x: T = 0) {
|
||||
}
|
||||
function x<T>(x: T = 0) {}
|
||||
|
||||
class C {
|
||||
x<T>(x: T = 0) {
|
||||
}
|
||||
x<T>(x: T = 0) {}
|
||||
}
|
||||
"
|
||||
`;
|
||||
|
|
@ -267,8 +265,7 @@ function testOptionalNullableProperty(obj: { x?: ?string }): string {
|
|||
}
|
||||
|
||||
function testOptionalNullableFlowingToNullable(x?: ?string): ?string {
|
||||
var f = function(y: ?string) {
|
||||
};
|
||||
var f = function(y: ?string) {};
|
||||
f(x);
|
||||
}
|
||||
"
|
||||
|
|
@ -298,8 +295,7 @@ function bar(x = \"bar\"): string {
|
|||
}
|
||||
bar(undefined); // ok
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
function foo(x?: number) {
|
||||
}
|
||||
function foo(x?: number) {}
|
||||
foo(undefined);
|
||||
|
||||
// ok
|
||||
|
|
|
|||
|
|
@ -24,8 +24,7 @@ y = o;
|
|||
o.foo = 0;
|
||||
|
||||
// future widening is constrained
|
||||
function bar(config: { foo?: number }) {
|
||||
}
|
||||
function bar(config: { foo?: number }) {}
|
||||
bar({});
|
||||
bar({ foo: \"\" });
|
||||
"
|
||||
|
|
|
|||
|
|
@ -24,8 +24,7 @@ function f6(x: mixed): %checks (x !== null) { }
|
|||
|
||||
// Error: no return statement
|
||||
|
||||
function f6(x: mixed): %checks(x !== null) {
|
||||
}
|
||||
function f6(x: mixed): %checks(x !== null) {}
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
|
|||
|
|
@ -589,8 +589,7 @@ Promise
|
|||
// TODO: resolvedPromise<T> -> catch() -> then():T
|
||||
Promise
|
||||
.resolve(0)
|
||||
.catch(function(err) {
|
||||
})
|
||||
.catch(function(err) {})
|
||||
.then(function(num) {
|
||||
var a: number = num;
|
||||
|
||||
|
|
|
|||
|
|
@ -197,18 +197,8 @@ var Example = React.createClass({
|
|||
propTypes: { func: React.PropTypes.func.isRequired }
|
||||
});
|
||||
|
||||
var ok_void = (
|
||||
<Example
|
||||
func={() => {
|
||||
}}
|
||||
/>
|
||||
);
|
||||
var ok_args = (
|
||||
<Example
|
||||
func={x => {
|
||||
}}
|
||||
/>
|
||||
);
|
||||
var ok_void = <Example func={() => {}} />;
|
||||
var ok_args = <Example func={x => {}} />;
|
||||
var ok_retval = <Example func={() => 1} />;
|
||||
|
||||
var fail_mistyped = <Example func={2} />;
|
||||
|
|
|
|||
|
|
@ -15,8 +15,7 @@ var Z = 0;
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
import React from \"react\";
|
||||
|
||||
function F(props: { foo: string }) {
|
||||
}
|
||||
function F(props: { foo: string }) {}
|
||||
<F />;
|
||||
/* error: missing \`foo\`*/
|
||||
<F foo={0} />;
|
||||
|
|
@ -25,8 +24,7 @@ function F(props: { foo: string }) {
|
|||
|
||||
// ok
|
||||
// props subtyping is property-wise covariant
|
||||
function G(props: { foo: string | numner }) {
|
||||
}
|
||||
function G(props: { foo: string | numner }) {}
|
||||
<G foo=\"\" />;
|
||||
|
||||
// ok
|
||||
|
|
|
|||
|
|
@ -130,8 +130,7 @@ export function foo(props: { x: number }) { }
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// @flow
|
||||
|
||||
export function foo(props: { x: number }) {
|
||||
}
|
||||
export function foo(props: { x: number }) {}
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
|
|||
|
|
@ -5,7 +5,6 @@ export function foo(props: { y: number }) { }
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// @flow
|
||||
|
||||
export function foo(props: { y: number }) {
|
||||
}
|
||||
export function foo(props: { y: number }) {}
|
||||
"
|
||||
`;
|
||||
|
|
|
|||
|
|
@ -208,8 +208,7 @@ function testLiteralProperty(a: A) {
|
|||
|
||||
type A = { \"b_c\": ?string };
|
||||
|
||||
function stuff(str: string) {
|
||||
}
|
||||
function stuff(str: string) {}
|
||||
|
||||
function testProperty(a: A) {
|
||||
if (a.b_c) {
|
||||
|
|
@ -601,8 +600,7 @@ function def_assign_setprop_nohavoc(obj: Obj, obj2: Obj2) {
|
|||
|
||||
type Obj = { p: number | string };
|
||||
|
||||
function f() {
|
||||
}
|
||||
function f() {}
|
||||
|
||||
function def_assign_function_havoc(obj: Obj) {
|
||||
obj.p = 10;
|
||||
|
|
@ -799,8 +797,7 @@ function foo5() {
|
|||
o.p();
|
||||
}
|
||||
function _foo5() {
|
||||
o.p = function() {
|
||||
};
|
||||
o.p = function() {};
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -958,10 +955,8 @@ function arr0(x: mixed) {
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @flow */
|
||||
|
||||
function takesNumber(x: number) {
|
||||
}
|
||||
function takesString(x: string) {
|
||||
}
|
||||
function takesNumber(x: number) {}
|
||||
function takesString(x: string) {}
|
||||
|
||||
function num(x: mixed) {
|
||||
if (typeof x === \"number\") {
|
||||
|
|
@ -1726,8 +1721,7 @@ function bar(b) {
|
|||
var z: string = x;
|
||||
}
|
||||
|
||||
function maybe_throw() {
|
||||
}
|
||||
function maybe_throw() {}
|
||||
function qux() {
|
||||
var x = 0;
|
||||
try {
|
||||
|
|
|
|||
|
|
@ -7,8 +7,7 @@ foo(\"\");
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
var a = 0;
|
||||
|
||||
function foo(x) {
|
||||
}
|
||||
function foo(x) {}
|
||||
|
||||
foo(\"\");
|
||||
"
|
||||
|
|
|
|||
|
|
@ -74,8 +74,7 @@ require(\"not a module name\");
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// @flow
|
||||
|
||||
function require() {
|
||||
}
|
||||
function require() {}
|
||||
require(\"not a module name\");
|
||||
"
|
||||
`;
|
||||
|
|
@ -132,10 +131,8 @@ require.call(null, \"DoesNotExist\");
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @flow */
|
||||
|
||||
function takesANumber(num: number): void {
|
||||
}
|
||||
function takesAString(str: string): void {
|
||||
}
|
||||
function takesANumber(num: number): void {}
|
||||
function takesAString(str: string): void {}
|
||||
|
||||
// @providesModule
|
||||
var A = require(\"A\");
|
||||
|
|
|
|||
|
|
@ -86,8 +86,7 @@ var notB: Object = B;
|
|||
|
||||
requireLazy();
|
||||
// Error: No args
|
||||
requireLazy([ nope ], function() {
|
||||
});
|
||||
requireLazy([ nope ], function() {});
|
||||
// Error: Non-stringliteral args
|
||||
requireLazy([ \"A\" ]); // Error: No calback expression
|
||||
"
|
||||
|
|
|
|||
|
|
@ -27,8 +27,7 @@ declare class C {
|
|||
function f(
|
||||
superSuperSuperSuperSuperSuperSuperSuperSuperSuperSuperSuperSuperSuperLong,
|
||||
...args
|
||||
) {
|
||||
}
|
||||
) {}
|
||||
|
||||
declare class C {
|
||||
f(
|
||||
|
|
|
|||
|
|
@ -37,8 +37,7 @@ module.exports = C;
|
|||
//module.exports = fn;
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
class C {
|
||||
foo() {
|
||||
}
|
||||
foo() {}
|
||||
bar() {
|
||||
return;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -24,8 +24,7 @@ function Bar() {
|
|||
var bar: number = new Bar();
|
||||
|
||||
// error (returns new object)
|
||||
function Qux() {
|
||||
}
|
||||
function Qux() {}
|
||||
var qux: number = new Qux();
|
||||
|
||||
// error (returns new object)
|
||||
|
|
|
|||
|
|
@ -41,8 +41,7 @@ var export_o: { x:any; } = o; // awkward type cast
|
|||
|
||||
module.exports = export_o;
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
function Foo() {
|
||||
}
|
||||
function Foo() {}
|
||||
var o = new Foo();
|
||||
var x: number = o.x;
|
||||
|
||||
|
|
|
|||
|
|
@ -3,8 +3,7 @@ exports[`test shebang.js 1`] = `
|
|||
function a() {}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
#!/usr/bin/env node
|
||||
function a() {
|
||||
}
|
||||
function a() {}
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
@ -15,7 +14,6 @@ function a() {}
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
#!/usr/bin/env node
|
||||
|
||||
function a() {
|
||||
}
|
||||
function a() {}
|
||||
"
|
||||
`;
|
||||
|
|
|
|||
|
|
@ -127,8 +127,7 @@ bar(3);
|
|||
|
||||
// error
|
||||
type ComparatorResult = -1 | 0 | 1;
|
||||
function sort(fn: (x: any, y: any) => ComparatorResult) {
|
||||
}
|
||||
function sort(fn: (x: any, y: any) => ComparatorResult) {}
|
||||
sort((x, y) => -1);
|
||||
"
|
||||
`;
|
||||
|
|
|
|||
|
|
@ -74,8 +74,7 @@ foo({foo: 42});
|
|||
function foo(o) {
|
||||
bar({ ...o });
|
||||
}
|
||||
function bar(_: { foo: number }) {
|
||||
}
|
||||
function bar(_: { foo: number }) {}
|
||||
foo({ foo: 42 });
|
||||
"
|
||||
`;
|
||||
|
|
@ -119,8 +118,7 @@ function test(...nums: Array<number>) {}
|
|||
test(0, ...[1, 2, 3]);
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @flow */
|
||||
function test(...nums: Array<number>) {
|
||||
}
|
||||
function test(...nums: Array<number>) {}
|
||||
|
||||
test(0, ...[ 1, 2, 3 ]);
|
||||
"
|
||||
|
|
|
|||
|
|
@ -10,8 +10,7 @@ C.g(0);
|
|||
var x:number = C.x;
|
||||
C.x = 0;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
class C {
|
||||
static f(x: number) {
|
||||
}
|
||||
static f(x: number) {}
|
||||
static x: string;
|
||||
}
|
||||
|
||||
|
|
@ -32,8 +31,7 @@ C.g = function(x) { return x; };
|
|||
|
||||
var x:string = new C().f();
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
function C() {
|
||||
}
|
||||
function C() {}
|
||||
C.prototype.f = function() {
|
||||
return C.g(0);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -15,8 +15,7 @@ class B extends A {
|
|||
foo(x: A): A {
|
||||
return x;
|
||||
}
|
||||
bar(x) {
|
||||
}
|
||||
bar(x) {}
|
||||
qux<X, Y>(x: X, y: Y): X {
|
||||
return x;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -223,8 +223,7 @@ class I_ {
|
|||
constructor(leaked_this) {
|
||||
leaked_this.foo();
|
||||
}
|
||||
foo() {
|
||||
}
|
||||
foo() {}
|
||||
}
|
||||
class I extends I_ {
|
||||
constructor() {
|
||||
|
|
@ -238,8 +237,7 @@ class J_ extends J__ {
|
|||
closure_leaking_this();
|
||||
super();
|
||||
}
|
||||
foo() {
|
||||
}
|
||||
foo() {}
|
||||
}
|
||||
class J extends J_ {
|
||||
constructor() {
|
||||
|
|
@ -257,8 +255,7 @@ class K_ {
|
|||
constructor(closure_leaking_this) {
|
||||
this.closure_leaking_this = closure_leaking_this;
|
||||
}
|
||||
foo() {
|
||||
}
|
||||
foo() {}
|
||||
}
|
||||
class K extends K_ {
|
||||
constructor() {
|
||||
|
|
@ -362,13 +359,11 @@ class B extends A {
|
|||
}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
class A {
|
||||
constructor(x: number) {
|
||||
}
|
||||
constructor(x: number) {}
|
||||
static staticMethod(x: string): string {
|
||||
return x;
|
||||
}
|
||||
f(x: string) {
|
||||
}
|
||||
f(x: string) {}
|
||||
}
|
||||
|
||||
class B extends A {
|
||||
|
|
|
|||
|
|
@ -74,8 +74,7 @@ function runTest(y: number): void {
|
|||
);
|
||||
}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
function takesAString(x: string): void {
|
||||
}
|
||||
function takesAString(x: string): void {}
|
||||
|
||||
function runTest(y: number): void {
|
||||
takesAString(
|
||||
|
|
|
|||
|
|
@ -61,8 +61,7 @@ function a() {
|
|||
}
|
||||
}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
const c = () => {
|
||||
};
|
||||
const c = () => {};
|
||||
|
||||
function a() {
|
||||
return function b() {
|
||||
|
|
@ -89,8 +88,7 @@ function a() {
|
|||
}
|
||||
}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
const c = () => {
|
||||
};
|
||||
const c = () => {};
|
||||
|
||||
function a() {
|
||||
return function b() {
|
||||
|
|
|
|||
|
|
@ -88,8 +88,7 @@ function* f() {
|
|||
}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// \"ArrowFunctionExpression\"
|
||||
(() => {
|
||||
})\`\`;
|
||||
(() => {})\`\`;
|
||||
|
||||
// \"AssignmentExpression\"
|
||||
(b = c)\`\`;
|
||||
|
|
@ -112,8 +111,7 @@ b()\`\`;
|
|||
(b ? c : d)\`\`;
|
||||
|
||||
// \"FunctionExpression\"
|
||||
(function() {
|
||||
})\`\`;
|
||||
(function() {})\`\`;
|
||||
|
||||
// \"LogicalExpression\"
|
||||
(b || c)\`\`;
|
||||
|
|
|
|||
|
|
@ -69,8 +69,7 @@ F.prototype.m = function() {
|
|||
this.y = 0;
|
||||
};
|
||||
|
||||
function foo(p: string) {
|
||||
}
|
||||
function foo(p: string) {}
|
||||
|
||||
var o1 = new F();
|
||||
// sets o1.x to 0
|
||||
|
|
@ -199,8 +198,7 @@ var j = g();
|
|||
|
||||
// error, since return type of bar is C, not the type of \`this\`
|
||||
class E {
|
||||
foo(x: number) {
|
||||
}
|
||||
foo(x: number) {}
|
||||
}
|
||||
class F extends E {
|
||||
foo() {
|
||||
|
|
|
|||
|
|
@ -90,13 +90,11 @@ var d = new D();
|
|||
|
||||
// sneaky
|
||||
class A {
|
||||
foo<X: this>(that: X) {
|
||||
} // error: can\'t hide contravariance using a bound
|
||||
foo<X: this>(that: X) {} // error: can\'t hide contravariance using a bound
|
||||
}
|
||||
|
||||
class B extends A {
|
||||
foo<Y: this>(that: Y) {
|
||||
} // error (see above, catches hidden override)
|
||||
foo<Y: this>(that: Y) {} // error (see above, catches hidden override)
|
||||
}
|
||||
|
||||
// covariance checks on this type in invariant positions
|
||||
|
|
@ -104,15 +102,13 @@ class Invariant {
|
|||
out_object(): { _: this } {
|
||||
return { _: this };
|
||||
}
|
||||
in_object(_: { _: this }) {
|
||||
}
|
||||
in_object(_: { _: this }) {}
|
||||
inout_object: { _: this };
|
||||
|
||||
out_array(): Array<this> {
|
||||
return [ this ];
|
||||
}
|
||||
in_array(_: Array<this>) {
|
||||
}
|
||||
in_array(_: Array<this>) {}
|
||||
inout_array: Array<this>;
|
||||
}
|
||||
|
||||
|
|
@ -122,16 +118,14 @@ class Misc {
|
|||
out_set(): Set<this> {
|
||||
return new Set().add(this);
|
||||
}
|
||||
in_set(_: Set<this>) {
|
||||
}
|
||||
in_set(_: Set<this>) {}
|
||||
inout_set: Set<this>;
|
||||
|
||||
// Promise<X> has covariant X
|
||||
async out_promise(): Promise<this> {
|
||||
return this;
|
||||
}
|
||||
in_promise(_: Promise<this>) {
|
||||
}
|
||||
in_promise(_: Promise<this>) {}
|
||||
inout_promise: Promise<this>;
|
||||
|
||||
// Generator<X,Y,Z> has covariant X, covariant Y, contravariant Z
|
||||
|
|
@ -139,8 +133,7 @@ class Misc {
|
|||
yield this;
|
||||
return this;
|
||||
}
|
||||
in_generator(_: Generator<this, this, this>) {
|
||||
}
|
||||
in_generator(_: Generator<this, this, this>) {}
|
||||
inout_generator: Generator<this, this, this>;
|
||||
}
|
||||
"
|
||||
|
|
@ -529,10 +522,8 @@ class Base2 {
|
|||
return this.bar();
|
||||
}
|
||||
|
||||
corge(that: this) {
|
||||
}
|
||||
grault(that: Base2) {
|
||||
}
|
||||
corge(that: this) {}
|
||||
grault(that: Base2) {}
|
||||
}
|
||||
|
||||
class Inherit2 extends Base2 {}
|
||||
|
|
@ -552,12 +543,10 @@ class Override2 extends Base2 {
|
|||
}
|
||||
// error (cf. OK above)
|
||||
// see exploit below
|
||||
corge(that: this) {
|
||||
}
|
||||
corge(that: this) {}
|
||||
// error
|
||||
// see exploit below
|
||||
grault(that: this) {
|
||||
} // error, too
|
||||
grault(that: this) {} // error, too
|
||||
}
|
||||
|
||||
class InheritOverride2 extends Override2 {}
|
||||
|
|
|
|||
|
|
@ -21,24 +21,21 @@ function double(n) { return n * 2 }
|
|||
f3(double);
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// arg/param type mismatch on arg 0
|
||||
function g0(y: string) {
|
||||
}
|
||||
function g0(y: string) {}
|
||||
function f0(x) {
|
||||
g0(x);
|
||||
}
|
||||
f0(0);
|
||||
|
||||
// ...on arg n
|
||||
function g1(a: string, b: string) {
|
||||
}
|
||||
function g1(a: string, b: string) {}
|
||||
function f1(x, y) {
|
||||
g1(x, y);
|
||||
}
|
||||
f1(\"hey\", 0);
|
||||
|
||||
// h/o call with function expr
|
||||
function g2(ylam: (s: string) => number) {
|
||||
}
|
||||
function g2(ylam: (s: string) => number) {}
|
||||
function f2(xlam) {
|
||||
g2(xlam);
|
||||
}
|
||||
|
|
@ -47,8 +44,7 @@ f2(function(x) {
|
|||
});
|
||||
|
||||
// h/o call with function def
|
||||
function g3(ylam: (s: string) => number) {
|
||||
}
|
||||
function g3(ylam: (s: string) => number) {}
|
||||
function f3(xlam) {
|
||||
g3(xlam);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -11,8 +11,7 @@ a(
|
|||
|
||||
a(\'value\', \'value2\', a(\'long-nested-value\', \'long-nested-value2\', \'long-nested-value3\'));
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
const a = (param1, param2, param3) => {
|
||||
};
|
||||
const a = (param1, param2, param3) => {};
|
||||
|
||||
a(\"value\", \"value2\", \"value3\");
|
||||
|
||||
|
|
@ -43,8 +42,7 @@ a(
|
|||
|
||||
a(\'value\', \'value2\', a(\'long-nested-value\', \'long-nested-value2\', \'long-nested-value3\'));
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
const a = (param1, param2, param3) => {
|
||||
};
|
||||
const a = (param1, param2, param3) => {};
|
||||
|
||||
a(\"value\", \"value2\", \"value3\");
|
||||
|
||||
|
|
|
|||
|
|
@ -196,8 +196,7 @@ function f(b) {
|
|||
|
||||
// for illustrative purposes only - Flow considers a throw possible
|
||||
// anywhere within a block
|
||||
function might_throw() {
|
||||
}
|
||||
function might_throw() {}
|
||||
|
||||
// local use of annotated var within try is ok
|
||||
function f() {
|
||||
|
|
|
|||
|
|
@ -49,8 +49,7 @@ foo([ {} ]); // error, too few elements in array passed to a tuple
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
/* @flow */
|
||||
|
||||
function foo(a: [Object, Object]) {
|
||||
}
|
||||
function foo(a: [Object, Object]) {}
|
||||
|
||||
foo([ {} ]); // error, too few elements in array passed to a tuple
|
||||
"
|
||||
|
|
|
|||
|
|
@ -59,10 +59,7 @@ const y = {
|
|||
// foo(): void {}
|
||||
// }
|
||||
|
||||
const y = {
|
||||
bar(): void {
|
||||
}
|
||||
};
|
||||
const y = { bar(): void {} };
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
@ -135,8 +132,7 @@ module.exports = num;
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// @flow
|
||||
var num = 42;
|
||||
function bar() {
|
||||
}
|
||||
function bar() {}
|
||||
bar();
|
||||
module.exports = num;
|
||||
"
|
||||
|
|
@ -254,8 +250,7 @@ const w:MyNum = 42;
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
// @flow
|
||||
var str = require(\"./import\");
|
||||
function foo() {
|
||||
}
|
||||
function foo() {}
|
||||
foo();
|
||||
str;
|
||||
|
||||
|
|
|
|||
|
|
@ -15,8 +15,7 @@ class C<T> {
|
|||
this.b(a); // error: A ~> incompatible instance of T
|
||||
}
|
||||
|
||||
b(x: T) {
|
||||
}
|
||||
b(x: T) {}
|
||||
}
|
||||
"
|
||||
`;
|
||||
|
|
@ -37,8 +36,7 @@ f(0); // ok
|
|||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
function f<T>(a: T) {
|
||||
function g<U>(b: U, c: T = a) {
|
||||
function h(d: U = b) {
|
||||
}
|
||||
function h(d: U = b) {}
|
||||
h();
|
||||
// ok
|
||||
h(b);
|
||||
|
|
|
|||
|
|
@ -23,8 +23,7 @@ function doSomethingAsync(): Promise<void> {
|
|||
}
|
||||
|
||||
// simpler repro to show that too few args are fine when expecting void
|
||||
function foo(x: void) {
|
||||
}
|
||||
function foo(x: void) {}
|
||||
foo();
|
||||
"
|
||||
`;
|
||||
|
|
@ -52,8 +51,7 @@ function bar() {
|
|||
if (x) x.bar();
|
||||
}
|
||||
|
||||
function qux(x?: number, y: string = \"\", z) {
|
||||
}
|
||||
function qux(x?: number, y: string = \"\", z) {}
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
|
|||
|
|
@ -110,27 +110,8 @@ myclass.myfun([\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", function (ar) {}
|
|||
declare class Myclass { myfun(myarray: Array<Function | string>): any }
|
||||
declare var myclass: Myclass;
|
||||
|
||||
myclass.myfun([
|
||||
\"1\",
|
||||
\"2\",
|
||||
\"3\",
|
||||
\"4\",
|
||||
\"5\",
|
||||
\"6\",
|
||||
function(ar) {
|
||||
}
|
||||
]);
|
||||
myclass.myfun([
|
||||
\"1\",
|
||||
\"2\",
|
||||
\"3\",
|
||||
\"4\",
|
||||
\"5\",
|
||||
\"6\",
|
||||
\"7\",
|
||||
function(ar) {
|
||||
}
|
||||
]);
|
||||
myclass.myfun([ \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", function(ar) {} ]);
|
||||
myclass.myfun([ \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", function(ar) {} ]);
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
@ -343,8 +324,7 @@ type Foo<X: ?C> = Array<X>;
|
|||
// workaround
|
||||
var x: Array<C> = [];
|
||||
var y: Array<?C> = [];
|
||||
function foo<X>(x: Foo<X>) {
|
||||
}
|
||||
function foo<X>(x: Foo<X>) {}
|
||||
foo(x);
|
||||
foo(y);
|
||||
|
||||
|
|
@ -356,8 +336,7 @@ type Bar = () => C | string;
|
|||
function f() {
|
||||
return \"\";
|
||||
}
|
||||
function bar(x: Bar) {
|
||||
}
|
||||
function bar(x: Bar) {}
|
||||
bar(f);
|
||||
"
|
||||
`;
|
||||
|
|
@ -431,8 +410,7 @@ function corge(b) {
|
|||
new F().foo(x);
|
||||
}
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
function bar(x: Document | string): void {
|
||||
}
|
||||
function bar(x: Document | string): void {}
|
||||
bar(0);
|
||||
|
||||
class C {}
|
||||
|
|
@ -441,11 +419,9 @@ function CD(b) {
|
|||
var E = b ? C : D;
|
||||
var c: C = new E();
|
||||
// error, since E could be D, and D is not a subtype of C
|
||||
function qux(e: E) {
|
||||
}
|
||||
function qux(e: E) {}
|
||||
// this annotation is an error: is it C, or is it D?
|
||||
function qux2(e: C | D) {
|
||||
}
|
||||
function qux2(e: C | D) {}
|
||||
// OK
|
||||
qux2(new C());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -155,8 +155,7 @@ function node(content: ?Foobar | String | Array<String>) {
|
|||
/* @flow */
|
||||
import type { Foobar } from \"./issue-1455-helper\";
|
||||
|
||||
function create(content: ?Foobar | String | Array<String>) {
|
||||
}
|
||||
function create(content: ?Foobar | String | Array<String>) {}
|
||||
|
||||
function node(content: ?Foobar | String | Array<String>) {
|
||||
create(content);
|
||||
|
|
@ -490,8 +489,7 @@ type B4 = string;
|
|||
/////////////////////////////////////////////
|
||||
// similar example with class instance types
|
||||
/////////////////////////////////////////////
|
||||
function inst(a: A5 | A6) {
|
||||
}
|
||||
function inst(a: A5 | A6) {}
|
||||
|
||||
class B5 {}
|
||||
class B6 {}
|
||||
|
|
@ -591,8 +589,7 @@ type B6 = string;
|
|||
// example with object types
|
||||
//////////////////////////////
|
||||
|
||||
function obj(a: { x: number } | { x: string }) {
|
||||
}
|
||||
function obj(a: { x: number } | { x: string }) {}
|
||||
|
||||
obj(({ x: \"\" }: A1));
|
||||
|
||||
|
|
@ -603,8 +600,7 @@ type B1 = string;
|
|||
///////////////////////////////////////
|
||||
// similar example with function types
|
||||
///////////////////////////////////////
|
||||
function fun(a: (() => number) | (() => string)) {
|
||||
}
|
||||
function fun(a: (() => number) | (() => string)) {}
|
||||
|
||||
fun((() => \"\": A2));
|
||||
|
||||
|
|
@ -617,8 +613,7 @@ type B2 = string;
|
|||
/////////////////////////////////////////////////////
|
||||
class C<X> {}
|
||||
|
||||
function inst(a: C<number> | C<string>) {
|
||||
}
|
||||
function inst(a: C<number> | C<string>) {}
|
||||
|
||||
inst((new C(): A3));
|
||||
|
||||
|
|
@ -629,12 +624,8 @@ type B3 = string;
|
|||
/////////////////////////////////////////////
|
||||
// similar example with generic type aliases
|
||||
/////////////////////////////////////////////
|
||||
function alias(a: T<number> | T<string>) {
|
||||
}
|
||||
alias({
|
||||
x: (x: V<B4>) => {
|
||||
}
|
||||
});
|
||||
function alias(a: T<number> | T<string>) {}
|
||||
alias({ x: (x: V<B4>) => {} });
|
||||
|
||||
type T<X> = { x: U<X> };
|
||||
type U<X> = (x: V<X>) => void;
|
||||
|
|
@ -643,8 +634,7 @@ type V<X> = X;
|
|||
type B4 = string;
|
||||
|
||||
// class statics
|
||||
function stat(a: { x: number } | { x: string }) {
|
||||
}
|
||||
function stat(a: { x: number } | { x: string }) {}
|
||||
|
||||
class D {
|
||||
static x: B5;
|
||||
|
|
@ -655,8 +645,7 @@ stat(D);
|
|||
type B5 = string;
|
||||
|
||||
// tuples
|
||||
function tup(a: [number, boolean] | [string, boolean]) {
|
||||
}
|
||||
function tup(a: [number, boolean] | [string, boolean]) {}
|
||||
|
||||
tup(([ \"\", false ]: A6));
|
||||
|
||||
|
|
@ -706,13 +695,9 @@ type B2 = string;
|
|||
// example with function types
|
||||
///////////////////////////////
|
||||
|
||||
function fun(a: ((x: number) => void) | ((x: string) => void)) {
|
||||
}
|
||||
function fun(a: ((x: number) => void) | ((x: string) => void)) {}
|
||||
|
||||
fun(
|
||||
(x => {
|
||||
}: A1)
|
||||
);
|
||||
fun((x => {}: A1));
|
||||
|
||||
type A1 = (x: B1) => void;
|
||||
|
||||
|
|
@ -721,8 +706,7 @@ type B1 = string;
|
|||
////////////////////////////
|
||||
// example with array types
|
||||
////////////////////////////
|
||||
function arr(a: number[] | string[]) {
|
||||
}
|
||||
function arr(a: number[] | string[]) {}
|
||||
|
||||
arr(([]: A2));
|
||||
|
||||
|
|
@ -780,11 +764,9 @@ type B2 = string;
|
|||
// example with function types
|
||||
///////////////////////////////
|
||||
|
||||
function fun(a: ((x: number) => void) | ((x: string) => void)) {
|
||||
}
|
||||
function fun(a: ((x: number) => void) | ((x: string) => void)) {}
|
||||
|
||||
const a1 = (x => {
|
||||
}: A1);
|
||||
const a1 = (x => {}: A1);
|
||||
fun(a1);
|
||||
|
||||
function fun_call(x: string) {
|
||||
|
|
@ -798,8 +780,7 @@ type B1 = string;
|
|||
////////////////////////////
|
||||
// example with array types
|
||||
////////////////////////////
|
||||
function arr(a: number[] | string[]) {
|
||||
}
|
||||
function arr(a: number[] | string[]) {}
|
||||
|
||||
const a2 = ([]: A2);
|
||||
arr(a2);
|
||||
|
|
@ -856,8 +837,7 @@ function arr_set(x: string, i: number) { a2[i] = x; }
|
|||
// example with function types
|
||||
///////////////////////////////
|
||||
|
||||
function fun(a: ((x: number) => number) | ((x: string) => string)) {
|
||||
}
|
||||
function fun(a: ((x: number) => number) | ((x: string) => string)) {}
|
||||
|
||||
function a1(x) {
|
||||
return x;
|
||||
|
|
@ -871,8 +851,7 @@ function fun_call(x: string): string {
|
|||
/////////////////////////////
|
||||
// example with array types
|
||||
/////////////////////////////
|
||||
function arr(a: number[] | string[]) {
|
||||
}
|
||||
function arr(a: number[] | string[]) {}
|
||||
|
||||
var a2 = [];
|
||||
arr(a2);
|
||||
|
|
@ -981,8 +960,7 @@ type PG<X> = { x: X, y?: PG<X> };
|
|||
// recursive types
|
||||
////////////////////
|
||||
|
||||
function rec(x: F1 | F2) {
|
||||
}
|
||||
function rec(x: F1 | F2) {}
|
||||
rec({ x: 0 });
|
||||
|
||||
type F1 = G1;
|
||||
|
|
@ -995,8 +973,7 @@ type H2 = number;
|
|||
///////////////////////////////
|
||||
// polymorphic recursive types
|
||||
///////////////////////////////
|
||||
function polyrec(x: PF<number> | PF<string>) {
|
||||
}
|
||||
function polyrec(x: PF<number> | PF<string>) {}
|
||||
rec({ x: 0 });
|
||||
|
||||
type PF<X> = PG<X>;
|
||||
|
|
@ -1039,8 +1016,7 @@ type H2_ = number;
|
|||
// nested union types
|
||||
//////////////////////
|
||||
|
||||
function rec(x: F1 | F2) {
|
||||
}
|
||||
function rec(x: F1 | F2) {}
|
||||
rec({ x: 0 });
|
||||
|
||||
type F1 = G1 | G1_;
|
||||
|
|
@ -1088,8 +1064,7 @@ function square(x? = 0) {
|
|||
return x * x;
|
||||
}
|
||||
|
||||
function foo(f: ((_: ?number) => ?number) | (() => void)) {
|
||||
}
|
||||
function foo(f: ((_: ?number) => ?number) | (() => void)) {}
|
||||
foo((x): number => square(x));
|
||||
"
|
||||
`;
|
||||
|
|
@ -1177,8 +1152,7 @@ function id<X>(x: X): X {
|
|||
/////////////////////////
|
||||
// primitive annotations
|
||||
/////////////////////////
|
||||
function check_prim(_: number | string) {
|
||||
}
|
||||
function check_prim(_: number | string) {}
|
||||
|
||||
// ok
|
||||
check_prim(\"\");
|
||||
|
|
@ -1191,8 +1165,7 @@ check_prim(id(\"\"));
|
|||
//////////////////////////////
|
||||
class C {}
|
||||
class D {}
|
||||
function check_inst(_: C | D) {
|
||||
}
|
||||
function check_inst(_: C | D) {}
|
||||
|
||||
// ok
|
||||
check_inst(new D());
|
||||
|
|
@ -1203,8 +1176,7 @@ check_inst(id(new C()));
|
|||
////////////////////////
|
||||
// function annotations
|
||||
////////////////////////
|
||||
function check_fun(_: ((_: number) => number) | ((_: string) => string)) {
|
||||
}
|
||||
function check_fun(_: ((_: number) => number) | ((_: string) => string)) {}
|
||||
|
||||
// help!
|
||||
check_fun(x => x);
|
||||
|
|
@ -1212,8 +1184,7 @@ check_fun(x => x);
|
|||
//////////////////////
|
||||
// object annotations
|
||||
//////////////////////
|
||||
function check_obj(_: { x: number } | { x: string }) {
|
||||
}
|
||||
function check_obj(_: { x: number } | { x: string }) {}
|
||||
|
||||
// ok
|
||||
check_obj({ x: \"\" });
|
||||
|
|
@ -1224,8 +1195,7 @@ check_obj({ x: id(\"\") });
|
|||
/////////////////////
|
||||
// array annotations
|
||||
/////////////////////
|
||||
function check_arr(_: number[] | string[]) {
|
||||
}
|
||||
function check_arr(_: number[] | string[]) {}
|
||||
|
||||
// ok
|
||||
check_arr([ \"\" ]);
|
||||
|
|
@ -1237,8 +1207,7 @@ check_arr([ id(\"\") ]);
|
|||
// generic class instance annotations
|
||||
//////////////////////////////////////
|
||||
class P<X> {}
|
||||
function check_poly_inst(_: P<number> | P<string>) {
|
||||
}
|
||||
function check_poly_inst(_: P<number> | P<string>) {}
|
||||
|
||||
// help!
|
||||
check_poly_inst(new P());
|
||||
|
|
@ -1356,8 +1325,7 @@ function foo(c: C<number>) {
|
|||
|
||||
declare class C<X> { get(): X }
|
||||
|
||||
function union(o: { x: string } | { x: number }) {
|
||||
}
|
||||
function union(o: { x: string } | { x: number }) {}
|
||||
|
||||
function foo(c: C<number>) {
|
||||
union({ x: c.get() });
|
||||
|
|
@ -1396,8 +1364,7 @@ bar(() => { });
|
|||
// functions as objects
|
||||
|
||||
function foo<X>(target: EventTarget) {
|
||||
target.addEventListener(\"click\", e => {
|
||||
});
|
||||
target.addEventListener(\"click\", e => {});
|
||||
}
|
||||
|
||||
declare class EventTarget {
|
||||
|
|
@ -1412,11 +1379,9 @@ type EventHandler = (event: Event) => mixed;
|
|||
type KeyboardEventHandler = (event: KeyboardEvent) => mixed;
|
||||
|
||||
// example where globals are not yet resolved
|
||||
function bar(x: (() => void) | { x: number }) {
|
||||
}
|
||||
function bar(x: (() => void) | { x: number }) {}
|
||||
|
||||
bar(() => {
|
||||
});
|
||||
bar(() => {});
|
||||
"
|
||||
`;
|
||||
|
||||
|
|
@ -1449,12 +1414,10 @@ type Foo = T | (() => boolean);
|
|||
|
||||
type Bar = number | (() => string) | (() => boolean);
|
||||
|
||||
function foo(x: Foo) {
|
||||
}
|
||||
function foo(x: Foo) {}
|
||||
foo(() => qux());
|
||||
|
||||
function bar(x: Bar) {
|
||||
}
|
||||
function bar(x: Bar) {}
|
||||
bar(() => qux());
|
||||
|
||||
var x = false;
|
||||
|
|
|
|||
|
|
@ -82,8 +82,7 @@ class C {
|
|||
return new C();
|
||||
}
|
||||
}
|
||||
function blah() {
|
||||
}
|
||||
function blah() {}
|
||||
var node: ?C = new C();
|
||||
while (node) {
|
||||
var parent = node.m();
|
||||
|
|
|
|||
Loading…
Reference in New Issue