Cleanup the code

lib/syntax/type_of.ml

@@ -142,26 +142,23 @@ end
 
 module TypeBuilder = Compose.Expression (Get_type)
 
-type t' = { result : Get_type.t Lazy.t; pos : S.pos; empty : bool }
+type t' = { result : Get_type.t Lazy.t; pos : S.pos }
 
 let arg_of_repr : Get_type.t Lazy.t -> S.pos -> Helper.argument_repr =
  fun type_of pos -> { pos; t = Lazy.force type_of }
 
 module TypedExpression = struct
   type nonrec t' = t' * Report.t list
-  type state = { pos : S.pos; empty : bool }
+  type state = { pos : S.pos }
   type t = state * Report.t list
 
   let v : Get_type.t Lazy.t * t -> t' =
-   fun (type_of, (t, r)) ->
-    ({ result = type_of; pos = t.pos; empty = t.empty }, r)
+   fun (type_of, (t, r)) -> ({ result = type_of; pos = t.pos }, r)
 
   (** The variable has type string when starting with a '$' *)
   let ident :
       (S.pos, Get_type.t Lazy.t * t) S.variable -> Get_type.t Lazy.t -> t =
    fun var _type_of ->
-    let empty = false in
-
     (* Extract the error from the index *)
     let report =
       match var.index with
@@ -170,39 +167,35 @@ module TypedExpression = struct
           let _, r = expr in
           r
     in
-    ({ pos = var.pos; empty }, report)
+    ({ pos = var.pos }, report)
 
   let integer : S.pos -> string -> Get_type.t Lazy.t -> t =
    fun pos value _type_of ->
     let int_value = int_of_string_opt value in
 
-    let empty, report =
+    let report =
       match int_value with
-      | Some 0 -> (true, [])
-      | Some _ -> (false, [])
-      | None -> (false, Report.error pos "Invalid integer value" :: [])
+      | Some 0 -> []
+      | Some _ -> []
+      | None -> Report.error pos "Invalid integer value" :: []
     in
 
-    ({ pos; empty }, report)
+    ({ pos }, report)
 
   let literal :
       S.pos -> (Get_type.t Lazy.t * t) T.literal list -> Get_type.t Lazy.t -> t
       =
    fun pos values type_of ->
     ignore type_of;
-    let init = (true, []) in
-    let empty, report =
-      List.fold_left values ~init ~f:(fun (was_empty, report) -> function
-        | T.Text t ->
-            let empty_text = String.equal t String.empty in
-            let empty = was_empty && empty_text in
-            (empty, report)
+    let init = [] in
+    let report =
+      List.fold_left values ~init ~f:(fun report -> function
+        | T.Text _ -> report
         | T.Expression (_, t) ->
-            let empty = was_empty && (fst t).empty in
-            let report = List.rev_append (snd t) (snd init) in
-            (empty, report))
+            let report = List.rev_append (snd t) report in
+            report)
     in
-    ({ pos; empty }, report)
+    ({ pos }, report)
 
   let function_ :
       S.pos ->
@@ -222,7 +215,7 @@ module TypedExpression = struct
           let arg = arg_of_repr type_of t.pos in
           (arg :: types, r @ report))
     in
-    let types = List.rev types and default = { pos; empty = false } in
+    let types = List.rev types and default = { pos } in
 
     match function_ with
     | Arrcomp | Arrpos | Arrsize | Countobj | Desc | Dyneval | Getobj | Instr
@@ -235,7 +228,7 @@ module TypedExpression = struct
         let expected = Helper.[ Fixed Bool; Dynamic d; Dynamic d ] in
         let report = Helper.compare_args pos expected types report in
         (* Extract the type for the expression *)
-        ({ pos; empty = false }, report)
+        ({ pos }, report)
     | Input | Input' ->
         (* Input should check the result if the variable is a num and raise a
            message in this case.*)
@@ -263,7 +256,7 @@ module TypedExpression = struct
         (* All the arguments must have the same type *)
         let expected = Helper.[ Variable (Dynamic d) ] in
         let report = Helper.compare_args pos expected types report in
-        ({ pos; empty = false }, report)
+        ({ pos }, report)
     | Mid | Mid' ->
         let expected = Helper.[ Fixed String; Variable (Fixed Integer) ] in
         let report = Helper.compare_args pos expected types report in
@@ -308,7 +301,7 @@ module TypedExpression = struct
         let types = [ arg_of_repr type_of t.pos ] in
         let expected = Helper.[ Fixed Integer ] in
         let report = Helper.compare_args pos expected types report in
-        ({ pos; empty = false }, report)
+        ({ pos }, report)
 
   let boperator :
       S.pos ->
@@ -333,7 +326,7 @@ module TypedExpression = struct
 
            When concatenating, it’s allowed to add an integer and a number.
         *)
-        ({ pos; empty = false }, report)
+        ({ pos }, report)
     | T.Eq | T.Neq | Lt | Gte | Lte | Gt ->
         (* If the expression is '' or 0, we accept the comparaison as if
             instead of raising a warning *)
@@ -351,17 +344,17 @@ module TypedExpression = struct
                 report
           | report -> report
         in
-        ({ pos; empty = false }, report)
+        ({ pos }, report)
     | T.Mod | T.Minus | T.Product | T.Div ->
         (* Operation over number *)
         let expected = Helper.[ Fixed Integer; Fixed Integer ] in
         let report = Helper.compare_args pos expected types report in
-        ({ pos; empty = false }, report)
+        ({ pos }, report)
     | T.And | T.Or ->
         (* Operation over booleans *)
         let expected = Helper.[ Fixed Bool; Fixed Bool ] in
         let report = Helper.compare_args pos expected types report in
-        ({ pos; empty = false }, report)
+        ({ pos }, report)
 end
 
 module Expression = TypeBuilder.Make (TypedExpression)
@@ -450,13 +443,8 @@ module Instruction = struct
 
     let report = List.rev_append report' report in
 
-    match
-      ( right_expression.empty,
-        op,
-        Get_type.get_type (Lazy.force right_expression.result) )
-    with
-    | true, _, _ -> report
-    | _, T.Eq', Get_type.(Integer) ->
+    match (op, Get_type.get_type (Lazy.force right_expression.result)) with
+    | T.Eq', Get_type.Integer ->
         (* Assigning an intger is allowed in a string variable, but raise a
            warning. *)
         let var_type = Lazy.from_val (Get_type.ident variable) in
@@ -464,7 +452,7 @@ module Instruction = struct
         let expected = Helper.[ Fixed Integer ] in
         Helper.compare_args ~strict:true ~level:Report.Warn pos expected [ op1 ]
           report
-    | false, _, _ -> (
+    | _, _ -> (
         let var_type = Lazy.from_val (Get_type.ident variable) in
         let op1 = arg_of_repr var_type variable.pos in
         let op2 = arg_of_repr right_expression.result right_expression.pos in