unary constant evaluation in types-first

Summary:
We were careful to ask for annotations on addition and logical operations in signature verification, since Flow has complex logic for these operations, but forgot to do so for unary minus and not, where also the logic is complex.

This diff compensates a bit in the signature generator, but there is still a gap between classic and types-first here. We can leave it as is by design, or do more later.

Reviewed By: panagosg7

Differential Revision: D15565075

fbshipit-source-id: 014a7f05c004489f005bf2e047e4bb86df708023

Author: avikchaudhuri

src/parser_utils/signature_builder_generate.ml

@@ -975,18 +975,43 @@ module Eval(Env: Signature_builder_verify.EvalEnv) = struct
         end
       | _ -> None
 
-  and arith_unary operator loc _argument =
+  and arith_unary operator loc argument =
     let open Ast.Expression.Unary in
     match operator with
       (* These operations have simple result types. *)
-      | Minus -> loc, T.Number
       | Plus -> loc, T.Number
-      | Not -> loc, T.Boolean
       | BitNot -> loc, T.Number
       | Typeof -> loc, T.String
       | Void -> loc, T.Void
       | Delete -> loc, T.Boolean
 
+      (* These operations may or may not have simple result types. See associated TODO: comment in
+         Signature_builder_verify. *)
+      | Minus ->
+        begin match literal_expr argument with
+        | _, T.NumberLiteral { Ast.NumberLiteral.value; raw } ->
+          loc, T.NumberLiteral { Ast.NumberLiteral.value = -.value; raw = "-"^raw }
+        | _ -> loc, T.Number
+        end
+      | Not ->
+        begin match literal_expr argument with
+        | _, T.BooleanLiteral b ->
+          loc, T.BooleanLiteral (not b)
+        | _, T.Function _
+        | _, T.ObjectLiteral _
+        | _, T.ArrayLiteral _
+        | _, T.JSXLiteral _
+          -> loc, T.BooleanLiteral false
+        | _, T.Void
+        | _, T.Null
+          -> loc, T.BooleanLiteral true
+        | _, T.NumberLiteral { Ast.NumberLiteral.value; _ } ->
+           loc, T.BooleanLiteral (value = 0.)
+        | _, T.StringLiteral { Ast.StringLiteral.value; _ } ->
+           loc, T.BooleanLiteral (value = "")
+        | _ -> loc, T.Boolean
+        end
+
       | Await ->
         (* The result type of this operation depends in a complicated way on the argument type. *)
         T.FixMe.mk_expr_type loc

src/parser_utils/signature_builder_verify.ml

@@ -420,16 +420,21 @@ module Eval(Env: EvalEnv) = struct
   and arith_unary tps operator loc argument =
     let open Ast.Expression.Unary in
     match operator with
-      | Minus
       | Plus
-      | Not
       | BitNot
       | Typeof
       | Void
       | Delete
         ->
         (* These operations have simple result types. *)
         ignore tps; ignore argument; Deps.bot
+      | Minus
+      | Not
+        ->
+        (* TODO: These operations are evaluated by Flow; they may or may not have simple result
+           types. Ideally we'd be verifying the argument. Unfortunately, we don't (see below). The
+           generator does some basic constant evaluation to compensate, but it's not enough. *)
+        ignore tps; ignore argument; Deps.bot
       | Await ->
         (* The result type of this operation depends in a complicated way on the argument type. *)
         Deps.top (Error.UnexpectedExpression (loc, Ast_utils.ExpressionSort.Unary))

tests/types-first-unary/.flowconfig

@@ -0,0 +1,3 @@
+[options]
+experimental.well_formed_exports=true
+experimental.types_first=true

tests/types-first-unary/a.js

@@ -0,0 +1,12 @@
+// @flow
+export type T1 = -1;
+export type T2 = false;
+export type T3 = 1;
+export type T4 = true;
+
+module.exports = {
+  P1: -1,
+  P2: !true,
+  P3: -(-1),
+  P4: !!1,
+};

tests/types-first-unary/b.js

@@ -0,0 +1,12 @@
+// @flow
+import type {
+  T1,
+  T2,
+  T3,
+  T4,
+} from './a';
+const A = require('./a');
+(A.P1: T1);
+(A.P2: T2);
+(A.P3: T3);
+(A.P4: T4);

tests/types-first-unary/types-first-unary.exp

@@ -0,0 +1 @@
+Found 0 errors