diff options
Diffstat (limited to 'lib/syntax')
| -rw-r--r-- | lib/syntax/type_of.ml | 66 |
1 files changed, 27 insertions, 39 deletions
diff --git a/lib/syntax/type_of.ml b/lib/syntax/type_of.ml index 3c04256..97b7f91 100644 --- a/lib/syntax/type_of.ml +++ b/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 |