Skip to content

Commit 9ef9595

Browse files
rcosta358rcosta358
committed
Improve Switch Cases
1 parent c3d05d1 commit 9ef9595

2 files changed

Lines changed: 203 additions & 240 deletions

File tree

‎liquidjava-verifier/src/main/java/liquidjava/rj_language/opt/ConstantFolding.java‎

Lines changed: 50 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -38,120 +38,74 @@ private static Expression foldBinaryExpression(BinaryExpression binExp) {
3838
int l = ((LiteralInt) left).getValue();
3939
int r = ((LiteralInt) right).getValue();
4040

41-
switch (op) {
42-
case "+":
43-
return new LiteralInt(l + r);
44-
case "-":
45-
return new LiteralInt(l - r);
46-
case "*":
47-
return new LiteralInt(l * r);
48-
case "/":
49-
if (r != 0)
50-
return new LiteralInt(l / r);
51-
break;
52-
case "%":
53-
if (r != 0)
54-
return new LiteralInt(l % r);
55-
break;
56-
case "<":
57-
return new LiteralBoolean(l < r);
58-
case "<=":
59-
return new LiteralBoolean(l <= r);
60-
case ">":
61-
return new LiteralBoolean(l > r);
62-
case ">=":
63-
return new LiteralBoolean(l >= r);
64-
case "==":
65-
return new LiteralBoolean(l == r);
66-
case "!=":
67-
return new LiteralBoolean(l != r);
68-
}
41+
return switch (op) {
42+
case "+" -> new LiteralInt(l + r);
43+
case "-" -> new LiteralInt(l - r);
44+
case "*" -> new LiteralInt(l * r);
45+
case "/" -> r != 0 ? new LiteralInt(l / r) : binExp;
46+
case "%" -> r != 0 ? new LiteralInt(l % r) : binExp;
47+
case "<" -> new LiteralBoolean(l < r);
48+
case "<=" -> new LiteralBoolean(l <= r);
49+
case ">" -> new LiteralBoolean(l > r);
50+
case ">=" -> new LiteralBoolean(l >= r);
51+
case "==" -> new LiteralBoolean(l == r);
52+
case "!=" -> new LiteralBoolean(l != r);
53+
default -> binExp;
54+
};
6955
}
7056

7157
// arithmetic operations with real literals
7258
else if (left instanceof LiteralReal && right instanceof LiteralReal) {
7359
double l = ((LiteralReal) left).getValue();
7460
double r = ((LiteralReal) right).getValue();
75-
switch (op) {
76-
case "+":
77-
return new LiteralReal(l + r);
78-
case "-":
79-
return new LiteralReal(l - r);
80-
case "*":
81-
return new LiteralReal(l * r);
82-
case "/":
83-
if (r != 0.0)
84-
return new LiteralReal(l / r);
85-
break;
86-
case "%":
87-
if (r != 0.0)
88-
return new LiteralReal(l % r);
89-
break;
90-
case "<":
91-
return new LiteralBoolean(l < r);
92-
case "<=":
93-
return new LiteralBoolean(l <= r);
94-
case ">":
95-
return new LiteralBoolean(l > r);
96-
case ">=":
97-
return new LiteralBoolean(l >= r);
98-
case "==":
99-
return new LiteralBoolean(l == r);
100-
case "!=":
101-
return new LiteralBoolean(l != r);
102-
}
61+
return switch (op) {
62+
case "+" -> new LiteralReal(l + r);
63+
case "-" -> new LiteralReal(l - r);
64+
case "*" -> new LiteralReal(l * r);
65+
case "/" -> r != 0.0 ? new LiteralReal(l / r) : binExp;
66+
case "%" -> r != 0.0 ? new LiteralReal(l % r) : binExp;
67+
case "<" -> new LiteralBoolean(l < r);
68+
case "<=" -> new LiteralBoolean(l <= r);
69+
case ">" -> new LiteralBoolean(l > r);
70+
case ">=" -> new LiteralBoolean(l >= r);
71+
case "==" -> new LiteralBoolean(l == r);
72+
case "!=" -> new LiteralBoolean(l != r);
73+
default -> binExp;
74+
};
10375
}
10476

10577
// mixed integer and real operations
10678
else if ((left instanceof LiteralInt && right instanceof LiteralReal) || (left instanceof LiteralReal && right instanceof LiteralInt)) {
10779
double l = left instanceof LiteralInt ? ((LiteralInt) left).getValue() : ((LiteralReal) left).getValue();
10880
double r = right instanceof LiteralInt ? ((LiteralInt) right).getValue() : ((LiteralReal) right).getValue();
109-
switch (op) {
110-
case "+":
111-
return new LiteralReal(l + r);
112-
case "-":
113-
return new LiteralReal(l - r);
114-
case "*":
115-
return new LiteralReal(l * r);
116-
case "/":
117-
if (r != 0.0)
118-
return new LiteralReal(l / r);
119-
break;
120-
case "%":
121-
if (r != 0.0)
122-
return new LiteralReal(l % r);
123-
break;
124-
case "<":
125-
return new LiteralBoolean(l < r);
126-
case "<=":
127-
return new LiteralBoolean(l <= r);
128-
case ">":
129-
return new LiteralBoolean(l > r);
130-
case ">=":
131-
return new LiteralBoolean(l >= r);
132-
case "==":
133-
return new LiteralBoolean(l == r);
134-
case "!=":
135-
return new LiteralBoolean(l != r);
136-
}
81+
return switch (op) {
82+
case "+" -> new LiteralReal(l + r);
83+
case "-" -> new LiteralReal(l - r);
84+
case "*" -> new LiteralReal(l * r);
85+
case "/" -> r != 0.0 ? new LiteralReal(l / r) : binExp;
86+
case "%" -> r != 0.0 ? new LiteralReal(l % r) : binExp;
87+
case "<" -> new LiteralBoolean(l < r);
88+
case "<=" -> new LiteralBoolean(l <= r);
89+
case ">" -> new LiteralBoolean(l > r);
90+
case ">=" -> new LiteralBoolean(l >= r);
91+
case "==" -> new LiteralBoolean(l == r);
92+
case "!=" -> new LiteralBoolean(l != r);
93+
default -> binExp;
94+
};
13795
}
13896

13997
// boolean operations with boolean literals
14098
else if (left instanceof LiteralBoolean && right instanceof LiteralBoolean) {
14199
boolean l = ((LiteralBoolean) left).isBooleanTrue();
142100
boolean r = ((LiteralBoolean) right).isBooleanTrue();
143-
switch (op) {
144-
case "&&":
145-
return new LiteralBoolean(l && r);
146-
case "||":
147-
return new LiteralBoolean(l || r);
148-
case "-->": // implication: !a || b
149-
return new LiteralBoolean(!l || r);
150-
case "==":
151-
return new LiteralBoolean(l == r);
152-
case "!=":
153-
return new LiteralBoolean(l != r);
154-
}
101+
return switch (op) {
102+
case "&&" -> new LiteralBoolean(l && r);
103+
case "||" -> new LiteralBoolean(l || r);
104+
case "-->" -> new LiteralBoolean(!l || r);
105+
case "==" -> new LiteralBoolean(l == r);
106+
case "!=" -> new LiteralBoolean(l != r);
107+
default -> binExp;
108+
};
155109
}
156110
// no folding, return original
157111
return binExp;

0 commit comments

Comments
 (0)