1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
open StdLabels
let identifier = "escaped_string"
let description = "Check for unnecessary use of expression encoded in string"
let active = ref true
module TypeBuilder = Compose.Expression (Get_type)
module Expression = TypeBuilder.Make (struct
type t = Report.t list
type t' = Report.t list
let v : Get_type.t Lazy.t * t -> t' = snd
(** Identify the expressions reprented as string. That’s here that the report
are added.
All the rest of the module only push thoses warning to the top level. *)
let literal :
S.pos -> (Get_type.t Lazy.t * t) T.literal list -> Get_type.t Lazy.t -> t
=
fun pos content _type_of ->
match content with
| [ T.Expression [ (t', _) ]; T.Text "" ] -> (
match Get_type.get_type (Lazy.force t') with
| Get_type.Integer -> []
| _ ->
let msg = Report.debug pos "This expression can be simplified" in
[ msg ])
| _ -> []
let ident :
(S.pos, Get_type.t Lazy.t * t) S.variable -> Get_type.t Lazy.t -> t =
fun variable _type_of ->
match variable.index with None -> [] | Some (_, t) -> t
let integer : S.pos -> string -> Get_type.t Lazy.t -> t =
fun pos t _type_of ->
ignore pos;
ignore t;
[]
let function_ :
S.pos ->
T.function_ ->
(Get_type.t Lazy.t * t) list ->
Get_type.t Lazy.t ->
t =
fun pos f expressions _type_of ->
ignore pos;
ignore f;
let exprs =
List.fold_left ~init:[] expressions ~f:(fun acc el ->
List.rev_append (snd el) acc)
in
exprs
let uoperator :
S.pos -> T.uoperator -> Get_type.t Lazy.t * t -> Get_type.t Lazy.t -> t =
fun pos op r _type_of ->
ignore op;
ignore pos;
snd r
let boperator :
S.pos ->
T.boperator ->
Get_type.t Lazy.t * t ->
Get_type.t Lazy.t * t ->
Get_type.t Lazy.t ->
t =
fun pos op (_, r1) (_, r2) _type_of ->
ignore pos;
ignore op;
r1 @ r2
end)
module Instruction :
S.Instruction with type t' = Report.t list and type expression = Expression.t' =
struct
type t = Report.t list
(** Internal type used in the evaluation *)
type t' = t
let v : t -> t' = Fun.id
type expression = Expression.t'
let call : S.pos -> T.keywords -> expression list -> t =
fun pos k exprs ->
ignore pos;
ignore k;
List.concat exprs
let location : S.pos -> string -> t = fun _ _ -> []
let comment : S.pos -> t = fun _ -> []
let expression : expression -> t = Fun.id
let act : S.pos -> label:expression -> t list -> t =
fun pos ~label instructions ->
ignore pos;
List.concat (label :: instructions)
let fold_clause : (expression, t) S.clause -> t =
fun (_pos1, expression, ts) -> List.concat (expression :: ts)
let if_ :
S.pos ->
(expression, t) S.clause ->
elifs:(expression, t) S.clause list ->
else_:(S.pos * t list) option ->
t =
fun pos clause ~elifs ~else_ ->
ignore pos;
let init =
match else_ with
| None -> fold_clause clause
| Some (_, ts) -> List.rev_append (fold_clause clause) (List.concat ts)
in
List.fold_left elifs ~init ~f:(fun t clause ->
List.rev_append (fold_clause clause) t)
let assign :
S.pos ->
(S.pos, expression) S.variable ->
T.assignation_operator ->
expression ->
t =
fun pos variable op expression ->
ignore pos;
ignore op;
match variable.index with
| None -> expression
| Some v -> List.rev_append v expression
end
module Location = struct
type t = Report.t list
type instruction = Instruction.t'
let v = Fun.id
let location : S.pos -> instruction list -> t =
fun pos intructions ->
ignore pos;
List.concat intructions
end
|
