Skip to content

Commit b5fa7a5

Browse files
BZngrBZngr
committed
Use Lexer for symbol values
1 parent a6fe019 commit b5fa7a5

File tree

6 files changed

+118
-84
lines changed

6 files changed

+118
-84
lines changed

‎Rubberduck.Inspections/Concrete/UnreachableCaseInspection/UCIParseTreeValueVisitor.cs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -299,7 +299,7 @@ private string GetConstantDeclarationValueToken(Declaration valueDeclaration)
299299
{
300300
var contextsOfInterest = new List<ParserRuleContext>();
301301
var contexts = valueDeclaration.Context.children.ToList();
302-
var eqIndex = contexts.FindIndex(ch => ch.GetText().Equals(CompareTokens.EQ));
302+
var eqIndex = contexts.FindIndex(ch => ch.GetText().Equals(LogicSymbols.EQ));
303303
for (int idx = eqIndex + 1; idx < contexts.Count(); idx++)
304304
{
305305
var childCtxt = contexts[idx];

‎Rubberduck.Inspections/Concrete/UnreachableCaseInspection/UCIRangeClauseFilter.cs

Lines changed: 30 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -126,11 +126,11 @@ public void Add(IUCIRangeClauseFilter filter)
126126
var newFilter = (UCIRangeClauseFilter<T>)filter;
127127
if (newFilter.TryGetIsLTValue(out T isLT))
128128
{
129-
AddIsClauseImpl(isLT, CompareTokens.LT);
129+
AddIsClauseImpl(isLT, LogicSymbols.LT);
130130
}
131131
if (newFilter.TryGetIsGTValue(out T isGT))
132132
{
133-
AddIsClauseImpl(isGT, CompareTokens.GT);
133+
AddIsClauseImpl(isGT, LogicSymbols.GT);
134134
}
135135

136136
foreach (var tuple in newFilter.RangeValues)
@@ -243,7 +243,7 @@ public IUCIRangeClauseFilter FilterUnreachableClauses(IUCIRangeClauseFilter filt
243243
public bool TryGetIsLTValue(out T isLT)
244244
{
245245
isLT = default;
246-
if (_isClause.TryGetValue(CompareTokens.LT, out List<T> isLTValues) && isLTValues.Any())
246+
if (_isClause.TryGetValue(LogicSymbols.LT, out List<T> isLTValues) && isLTValues.Any())
247247
{
248248
isLT = isLTValues.Max();
249249
return true;
@@ -254,7 +254,7 @@ public bool TryGetIsLTValue(out T isLT)
254254
public bool TryGetIsGTValue(out T isGT)
255255
{
256256
isGT = default;
257-
if (_isClause.TryGetValue(CompareTokens.GT, out List<T> isGTValues) && isGTValues.Any())
257+
if (_isClause.TryGetValue(LogicSymbols.GT, out List<T> isGTValues) && isGTValues.Any())
258258
{
259259
isGT = isGTValues.Min();
260260
return true;
@@ -295,8 +295,8 @@ public override string ToString()
295295
{
296296
var descriptors = new HashSet<string>
297297
{
298-
GetIsClausesDescriptor(CompareTokens.LT),
299-
GetIsClausesDescriptor(CompareTokens.GT),
298+
GetIsClausesDescriptor(LogicSymbols.LT),
299+
GetIsClausesDescriptor(LogicSymbols.GT),
300300
GetRangesDescriptor(),
301301
GetSinglesDescriptor(),
302302
GetRelOpDescriptor()
@@ -326,8 +326,8 @@ public void AddExtents(IUCIValue min, IUCIValue max)
326326
_hasExtents = true;
327327
_minExtent = _tConverter(min);
328328
_maxExtent = _tConverter(max);
329-
AddIsClauseImpl(_minExtent, CompareTokens.LT);
330-
AddIsClauseImpl(_maxExtent, CompareTokens.GT);
329+
AddIsClauseImpl(_minExtent, LogicSymbols.LT);
330+
AddIsClauseImpl(_maxExtent, LogicSymbols.GT);
331331
}
332332

333333
private bool FiltersAllRelationalOps
@@ -346,9 +346,9 @@ private bool FiltersAllRelationalOps
346346
}
347347
}
348348

349-
private void RemoveIsLTClause() => RemoveIsClauseImpl(CompareTokens.LT);
349+
private void RemoveIsLTClause() => RemoveIsClauseImpl(LogicSymbols.LT);
350350

351-
private void RemoveIsGTClause() => RemoveIsClauseImpl(CompareTokens.GT);
351+
private void RemoveIsGTClause() => RemoveIsClauseImpl(LogicSymbols.GT);
352352

353353
private void RemoveRangeValues(List<Tuple<T, T>> toRemove)
354354
{
@@ -526,25 +526,25 @@ private void AddIsClauseImpl(T val, string opSymbol)
526526
return;
527527
}
528528

529-
if (opSymbol.Equals(CompareTokens.LT) || opSymbol.Equals(CompareTokens.GT))
529+
if (opSymbol.Equals(LogicSymbols.LT) || opSymbol.Equals(LogicSymbols.GT))
530530
{
531531
StoreIsClauseValue(val, opSymbol);
532532
}
533-
else if (opSymbol.Equals(CompareTokens.LTE) || opSymbol.Equals(CompareTokens.GTE))
533+
else if (opSymbol.Equals(LogicSymbols.LTE) || opSymbol.Equals(LogicSymbols.GTE))
534534
{
535535
var ltOrGtSymbol = opSymbol.Substring(0, opSymbol.Length - 1);
536536
StoreIsClauseValue(val, ltOrGtSymbol);
537537

538538
AddSingleValueImpl(val);
539539
}
540-
else if (opSymbol.Equals(CompareTokens.EQ))
540+
else if (opSymbol.Equals(LogicSymbols.EQ))
541541
{
542542
AddSingleValueImpl(val);
543543
}
544-
else if (opSymbol.Equals(CompareTokens.NEQ))
544+
else if (opSymbol.Equals(LogicSymbols.NEQ))
545545
{
546-
StoreIsClauseValue(val, CompareTokens.LT);
547-
StoreIsClauseValue(val, CompareTokens.GT);
546+
StoreIsClauseValue(val, LogicSymbols.LT);
547+
StoreIsClauseValue(val, LogicSymbols.GT);
548548
}
549549

550550
FilterExistingRanges();
@@ -591,21 +591,21 @@ private void AddIsClauseBoolean(T val, string opSymbol)
591591

592592
var bVal = bool.Parse(val.ToString());
593593

594-
if (opSymbol.Equals(CompareTokens.NEQ)
595-
|| opSymbol.Equals(CompareTokens.EQ)
596-
|| (opSymbol.Equals(CompareTokens.GT) && bVal)
597-
|| (opSymbol.Equals(CompareTokens.LT) && !bVal)
598-
|| (opSymbol.Equals(CompareTokens.GTE) && !bVal)
599-
|| (opSymbol.Equals(CompareTokens.LTE) && bVal)
594+
if (opSymbol.Equals(LogicSymbols.NEQ)
595+
|| opSymbol.Equals(LogicSymbols.EQ)
596+
|| (opSymbol.Equals(LogicSymbols.GT) && bVal)
597+
|| (opSymbol.Equals(LogicSymbols.LT) && !bVal)
598+
|| (opSymbol.Equals(LogicSymbols.GTE) && !bVal)
599+
|| (opSymbol.Equals(LogicSymbols.LTE) && bVal)
600600
)
601601
{
602602
AddRelationalOpImpl($"Is {opSymbol} {val}");
603603
}
604-
else if (opSymbol.Equals(CompareTokens.GT) || opSymbol.Equals(CompareTokens.GTE))
604+
else if (opSymbol.Equals(LogicSymbols.GT) || opSymbol.Equals(LogicSymbols.GTE))
605605
{
606606
AddSingleValueImpl(ConvertToContainedGeneric(bVal));
607607
}
608-
else if (opSymbol.Equals(CompareTokens.LT) || opSymbol.Equals(CompareTokens.LTE))
608+
else if (opSymbol.Equals(LogicSymbols.LT) || opSymbol.Equals(LogicSymbols.LTE))
609609
{
610610
AddSingleValueImpl(ConvertToContainedGeneric(!bVal));
611611
}
@@ -678,8 +678,8 @@ private void AddValueRangeImpl(T inputStart, T inputEnd)
678678
return;
679679
}
680680

681-
start = IsLTFiltersValue(start) ? _isClause[CompareTokens.LT].Max() : start;
682-
end = IsGTFiltersValue(end) ? _isClause[CompareTokens.GT].Min() : end;
681+
start = IsLTFiltersValue(start) ? _isClause[LogicSymbols.LT].Max() : start;
682+
end = IsGTFiltersValue(end) ? _isClause[LogicSymbols.GT].Min() : end;
683683

684684
if (!_ranges.Any())
685685
{
@@ -730,8 +730,8 @@ private void TrimExistingRanges(bool trimStart)
730730
foreach (var range in rangesToTrim)
731731
{
732732
var newRange = trimStart ?
733-
new Tuple<T, T>(_isClause[CompareTokens.LT].Max(), range.Item2)
734-
: new Tuple<T, T>(range.Item1, _isClause[CompareTokens.GT].Min());
733+
new Tuple<T, T>(_isClause[LogicSymbols.LT].Max(), range.Item2)
734+
: new Tuple<T, T>(range.Item1, _isClause[LogicSymbols.GT].Min());
735735

736736
replacementRanges.Add(newRange);
737737
}
@@ -862,7 +862,7 @@ private void RemoveIsClauseImpl(string opSymbol)
862862
if (_hasExtents)
863863
{
864864
_isClause.Remove(opSymbol);
865-
var extentVal = opSymbol.Equals(CompareTokens.LT) ? _minExtent : _maxExtent;
865+
var extentVal = opSymbol.Equals(LogicSymbols.LT) ? _minExtent : _maxExtent;
866866
AddIsClauseImpl(extentVal, opSymbol);
867867
}
868868
else
@@ -917,7 +917,7 @@ private string GetIsClausesDescriptor(string opSymbol)
917917
var result = string.Empty;
918918
if (_isClause.TryGetValue(opSymbol, out List<T> values))
919919
{
920-
var isLT = opSymbol.Equals(CompareTokens.LT);
920+
var isLT = opSymbol.Equals(LogicSymbols.LT);
921921
var value = isLT ? values.Max() : values.Min();
922922
var extentToCompare = isLT ? _minExtent : _maxExtent;
923923
var prefix = isLT ? "IsLT=" : "IsGT=";

‎Rubberduck.Inspections/Concrete/UnreachableCaseInspection/UCIValueExpressionEvaluator.cs

Lines changed: 44 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -17,35 +17,35 @@ public class UCIValueExpressionEvaluator : IUCIValueExpressionEvaluator
1717

1818
private static Dictionary<string, Func<double, double, double>> MathOpsBinary = new Dictionary<string, Func<double, double, double>>()
1919
{
20-
[MathTokens.MULT] = delegate (double LHS, double RHS) { return LHS * RHS; },
21-
[MathTokens.DIV] = delegate (double LHS, double RHS) { return LHS / RHS; },
22-
[MathTokens.ADD] = delegate (double LHS, double RHS) { return LHS + RHS; },
23-
[MathTokens.SUBTRACT] = delegate (double LHS, double RHS) { return LHS - RHS; },
24-
[MathTokens.POW] = Math.Pow,
25-
[MathTokens.MOD] = delegate (double LHS, double RHS) { return LHS % RHS; },
20+
[MathSymbols.MULTIPLY] = delegate (double LHS, double RHS) { return LHS * RHS; },
21+
[MathSymbols.DIVIDE] = delegate (double LHS, double RHS) { return LHS / RHS; },
22+
[MathSymbols.PLUS] = delegate (double LHS, double RHS) { return LHS + RHS; },
23+
[MathSymbols.MINUS] = delegate (double LHS, double RHS) { return LHS - RHS; },
24+
[MathSymbols.EXPONENT] = Math.Pow,
25+
[MathSymbols.MODULO] = delegate (double LHS, double RHS) { return LHS % RHS; },
2626
};
2727

2828
private static Dictionary<string, Func<double, double, bool>> LogicOpsBinary = new Dictionary<string, Func<double, double, bool>>()
2929
{
30-
[CompareTokens.EQ] = delegate (double LHS, double RHS) { return LHS == RHS; },
31-
[CompareTokens.NEQ] = delegate (double LHS, double RHS) { return LHS != RHS; },
32-
[CompareTokens.LT] = delegate (double LHS, double RHS) { return LHS < RHS; },
33-
[CompareTokens.LTE] = delegate (double LHS, double RHS) { return LHS <= RHS; },
34-
[CompareTokens.GT] = delegate (double LHS, double RHS) { return LHS > RHS; },
35-
[CompareTokens.GTE] = delegate (double LHS, double RHS) { return LHS >= RHS; },
36-
[Tokens.And] = delegate (double LHS, double RHS) { return Convert.ToBoolean(LHS) && Convert.ToBoolean(RHS); },
37-
[Tokens.Or] = delegate (double LHS, double RHS) { return Convert.ToBoolean(LHS) || Convert.ToBoolean(RHS); },
38-
[Tokens.XOr] = delegate (double LHS, double RHS) { return Convert.ToBoolean(LHS) ^ Convert.ToBoolean(RHS); },
30+
[LogicSymbols.EQ] = delegate (double LHS, double RHS) { return LHS == RHS; },
31+
[LogicSymbols.NEQ] = delegate (double LHS, double RHS) { return LHS != RHS; },
32+
[LogicSymbols.LT] = delegate (double LHS, double RHS) { return LHS < RHS; },
33+
[LogicSymbols.LTE] = delegate (double LHS, double RHS) { return LHS <= RHS; },
34+
[LogicSymbols.GT] = delegate (double LHS, double RHS) { return LHS > RHS; },
35+
[LogicSymbols.GTE] = delegate (double LHS, double RHS) { return LHS >= RHS; },
36+
[LogicSymbols.AND] = delegate (double LHS, double RHS) { return Convert.ToBoolean(LHS) && Convert.ToBoolean(RHS); },
37+
[LogicSymbols.OR] = delegate (double LHS, double RHS) { return Convert.ToBoolean(LHS) || Convert.ToBoolean(RHS); },
38+
[LogicSymbols.XOR] = delegate (double LHS, double RHS) { return Convert.ToBoolean(LHS) ^ Convert.ToBoolean(RHS); },
3939
};
4040

4141
private static Dictionary<string, Func<double, double>> MathOpsUnary = new Dictionary<string, Func<double, double>>()
4242
{
43-
[MathTokens.ADDITIVE_INVERSE] = delegate (double value) { return value * -1.0; }
43+
[MathSymbols.ADDITIVE_INVERSE] = delegate (double value) { return value * -1.0; }
4444
};
4545

4646
private static Dictionary<string, Func<double, bool>> LogicOpsUnary = new Dictionary<string, Func<double, bool>>()
4747
{
48-
[Tokens.Not] = delegate (double value) { return !(Convert.ToBoolean(value)); }
48+
[LogicSymbols.NOT] = delegate (double value) { return !(Convert.ToBoolean(value)); }
4949
};
5050

5151
private static List<string> ResultTypeRanking = new List<string>()
@@ -133,4 +133,31 @@ private static List<double> PrepareOperands(string[] args)
133133
return results;
134134
}
135135
}
136+
137+
internal static class MathSymbols
138+
{
139+
private static string _multiply;
140+
private static string _divide;
141+
private static string _plus;
142+
private static string _minusSign;
143+
private static string _exponent;
144+
145+
public static string MULTIPLY => _multiply ?? LoadSymbols(VBAParser.MULT);
146+
public static string DIVIDE => _divide ?? LoadSymbols(VBAParser.DIV);
147+
public static string PLUS => _plus ?? LoadSymbols(VBAParser.PLUS);
148+
public static string MINUS => _minusSign ?? LoadSymbols(VBAParser.MINUS);
149+
public static string ADDITIVE_INVERSE => MINUS;
150+
public static string EXPONENT => _exponent ?? LoadSymbols(VBAParser.POW);
151+
public static string MODULO => Tokens.Mod;
152+
153+
private static string LoadSymbols(int target)
154+
{
155+
_multiply = VBAParser.DefaultVocabulary.GetLiteralName(VBAParser.MULT).Replace("'", "");
156+
_divide = VBAParser.DefaultVocabulary.GetLiteralName(VBAParser.DIV).Replace("'", "");
157+
_plus = VBAParser.DefaultVocabulary.GetLiteralName(VBAParser.PLUS).Replace("'", "");
158+
_minusSign = VBAParser.DefaultVocabulary.GetLiteralName(VBAParser.MINUS).Replace("'", "");
159+
_exponent = VBAParser.DefaultVocabulary.GetLiteralName(VBAParser.POW).Replace("'", "");
160+
return VBAParser.DefaultVocabulary.GetLiteralName(target).Replace("'", "");
161+
}
162+
}
136163
}

‎Rubberduck.Inspections/Concrete/UnreachableCaseInspection/UCIValueResults.cs

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,7 @@ public bool Contains(ParserRuleContext context)
5050

5151
public bool Any()
5252
{
53-
return _parseTreeValues.Count == 0;
53+
return _parseTreeValues.Count != 0;
5454
}
5555

5656
public bool TryGetValue(ParserRuleContext context, out IUCIValue value)
@@ -60,11 +60,10 @@ public bool TryGetValue(ParserRuleContext context, out IUCIValue value)
6060

6161
public void OnNewValueResult(object sender, ValueResultEventArgs e)
6262
{
63-
if (_parseTreeValues.ContainsKey(e.Context))
63+
if (!_parseTreeValues.ContainsKey(e.Context))
6464
{
65-
return;
65+
_parseTreeValues.Add(e.Context, e.Value);
6666
}
67-
_parseTreeValues.Add(e.Context, e.Value);
6867
}
6968
}
7069
}

‎Rubberduck.Inspections/Concrete/UnreachableCaseInspection/UnreachableCaseInspectionSelectStmt.cs

Lines changed: 27 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@ public class UnreachableCaseInspectionSelectStmt : UnreachableCaseInspectionCont
2020
private readonly VBAParser.SelectCaseStmtContext _selectCaseContext;
2121
private IUnreachableCaseInspectionRangeFactory _inspectionRangeFactory;
2222
private List<ParserRuleContext> _unreachableResults;
23-
private List<ParserRuleContext> _misMatchResults;
23+
private List<ParserRuleContext> _mismatchResults;
2424
private List<ParserRuleContext> _caseElseResults;
2525
private string _evalTypeName;
2626

@@ -29,7 +29,7 @@ public UnreachableCaseInspectionSelectStmt(VBAParser.SelectCaseStmtContext selec
2929
{
3030
_selectCaseContext = selectCaseContext;
3131
_unreachableResults = new List<ParserRuleContext>();
32-
_misMatchResults = new List<ParserRuleContext>();
32+
_mismatchResults = new List<ParserRuleContext>();
3333
_caseElseResults = new List<ParserRuleContext>();
3434
_evalTypeName = null;
3535
_inspectionRangeFactory = factoryFactory.CreateUnreachableCaseInspectionRangeFactory();
@@ -61,7 +61,7 @@ public void InspectForUnreachableCases()
6161

6262
if (inspectedRanges.All(ir => ir.HasIncompatibleType))
6363
{
64-
_misMatchResults.Add(caseClause);
64+
_mismatchResults.Add(caseClause);
6565
}
6666
else if (inspectedRanges.All(ir => ir.IsUnreachable))
6767
{
@@ -76,7 +76,7 @@ public void InspectForUnreachableCases()
7676

7777
public List<ParserRuleContext> UnreachableCases => _unreachableResults;
7878

79-
public List<ParserRuleContext> MismatchTypeCases => _misMatchResults;
79+
public List<ParserRuleContext> MismatchTypeCases => _mismatchResults;
8080

8181
public List<ParserRuleContext> UnreachableCaseElseCases => _caseElseResults;
8282

@@ -178,25 +178,29 @@ private static bool TryDetectTypeHint(string content, out string typeName)
178178
}
179179
}
180180

181-
internal static class MathTokens
181+
internal static class LogicSymbols
182182
{
183-
public static readonly string MULT = "*";
184-
public static readonly string DIV = "/";
185-
public static readonly string ADD = "+";
186-
public static readonly string SUBTRACT = "-";
187-
public static readonly string POW = "^";
188-
public static readonly string MOD = Tokens.Mod;
189-
public static readonly string ADDITIVE_INVERSE = "-";
190-
}
191-
192-
internal static class CompareTokens
193-
{
194-
public static readonly string EQ = "=";
195-
public static readonly string NEQ = "<>";
196-
public static readonly string LT = "<";
197-
public static readonly string LTE = "<=";
198-
public static readonly string GT = ">";
199-
public static readonly string GTE = ">=";
183+
private static string _lessThan;
184+
private static string _greaterThan;
185+
private static string _equalTo;
186+
187+
public static string EQ => _equalTo ?? LoadSymbols(VBAParser.EQ);
188+
public static string NEQ => "<>";
189+
public static string LT => _lessThan ?? LoadSymbols(VBAParser.LT);
190+
public static string LTE => "<=";
191+
public static string GT => _greaterThan ?? LoadSymbols(VBAParser.GT);
192+
public static string GTE => ">=";
193+
public static string AND => Tokens.And;
194+
public static string OR => Tokens.Or;
195+
public static string XOR => Tokens.XOr;
196+
public static string NOT => Tokens.Not;
197+
198+
private static string LoadSymbols(int target)
199+
{
200+
_lessThan = VBAParser.DefaultVocabulary.GetLiteralName(VBAParser.LT).Replace("'", "");
201+
_greaterThan = VBAParser.DefaultVocabulary.GetLiteralName(VBAParser.GT).Replace("'", "");
202+
_equalTo = VBAParser.DefaultVocabulary.GetLiteralName(VBAParser.EQ).Replace("'", "");
203+
return VBAParser.DefaultVocabulary.GetLiteralName(target).Replace("'", "");
204+
}
200205
}
201-
202206
}

0 commit comments

Comments
 (0)