private string DeriveTypeFromCaseClauses(IParseTreeVisitorResults inspValues, VBAParser.SelectCaseStmtContext selectStmt)
{
var caseClauseTypeNames = new List <string>();
foreach (var caseClause in selectStmt.caseClause())
{
foreach (var range in caseClause.rangeClause())
{
if (TryDetectTypeHint(range.GetText(), out string hintTypeName))
{
caseClauseTypeNames.Add(hintTypeName);
}
else
{
var inspRange = _inspectionRangeFactory.Create(range, inspValues);
var types = inspRange.ResultContexts.Select(rc => inspValues.GetTypeName(rc))
.Where(tp => InspectableTypes.Contains(tp));
caseClauseTypeNames.AddRange(types);
}
}
}
if (TryDetermineEvaluationTypeFromTypes(caseClauseTypeNames, out string evalTypeName))
{
return(evalTypeName);
}
return(string.Empty);
}
public ContextWrapperBase(ParserRuleContext context, IParseTreeVisitorResults inspValues, IUnreachableCaseInspectionFactoryProvider factoryFactory)
{
_context = context;
_rangeFilterFactory = factoryFactory.CreateIRangeClauseFilterFactory();
_valueFactory = factoryFactory.CreateIParseTreeValueFactory();
_inspValues = inspValues;
}
private string DeriveTypeFromCaseClauses(IParseTreeVisitorResults inspValues, VBAParser.SelectCaseStmtContext selectStmt)
{
var caseClauseTypeNames = new List <string>();
foreach (var caseClause in selectStmt.caseClause())
{
foreach (var range in caseClause.rangeClause())
{
if (TryDetectTypeHint(range.GetText(), out string hintTypeName))
{
caseClauseTypeNames.Add(hintTypeName);
}
else
{
var typeNames = from context in range.children
where context is ParserRuleContext &&
IsResultContext(context)
select inspValues.GetValueType(context as ParserRuleContext);
caseClauseTypeNames.AddRange(typeNames);
caseClauseTypeNames.RemoveAll(tp => !InspectableTypes.Contains(tp));
}
}
}
if (TryGetSelectExpressionTypeNameFromTypes(caseClauseTypeNames, out string evalTypeName))
{
return(evalTypeName);
}
return(string.Empty);
}
public ParseTreeValueVisitor(RubberduckParserState state, IParseTreeValueFactory valueFactory)
{
_state = state;
_inspValueFactory = valueFactory;
Calculator = new ParseTreeExpressionEvaluator(valueFactory);
_contextValues = new ParseTreeVisitorResults();
OnValueResultCreated += _contextValues.OnNewValueResult;
}
public RangeClauseContextWrapper(VBAParser.RangeClauseContext context, IParseTreeVisitorResults inspValues, IUnreachableCaseInspectionFactoryProvider factoryFactory)
: base(context, inspValues, factoryFactory)
{
_isValueRange = !(context.TO() is null);
_isLTorGT = !(context.IS() is null);
_isRelationalOp = Context.children.Any(ch => ch is ParserRuleContext && ParseTreeValueVisitor.IsLogicalContext(ch));
_isSingleValue = !(_isValueRange || _isLTorGT || _isRelationalOp);
_evalTypeName = string.Empty;
IsUnreachable = false;
AsFilter = FilterFactory.Create(Tokens.Long, ValueFactory);
}
public UnreachableCaseInspector(VBAParser.SelectCaseStmtContext selectCaseContext,
IParseTreeVisitorResults inspValues,
IParseTreeValueFactory valueFactory,
Func <string, ParserRuleContext, string> GetVariableTypeName = null)
{
_valueFactory = valueFactory;
_caseClauses = selectCaseContext.caseClause();
_caseElseContext = selectCaseContext.caseElseClause();
GetVariableDeclarationTypeName = GetVariableTypeName;
ParseTreeValueResults = inspValues;
SetSelectExpressionTypeName(selectCaseContext as ParserRuleContext, inspValues);
}
private void SetSelectExpressionTypeName(ParserRuleContext context, IParseTreeVisitorResults inspValues)
{
var selectStmt = (VBAParser.SelectCaseStmtContext)context;
if (TryDetectTypeHint(selectStmt.selectExpression().GetText(), out string typeName) &&
InspectableTypes.Contains(typeName))
{
SelectExpressionTypeName = typeName;
}
else if (inspValues.TryGetValue(selectStmt.selectExpression(), out IParseTreeValue result) &&
InspectableTypes.Contains(result.ValueType))
{
_selectExpressionValue = result;
SelectExpressionTypeName = result.ValueType;
}
else
{
SelectExpressionTypeName = DeriveTypeFromCaseClauses(inspValues, selectStmt);
}
}
private void SetEvaluationTypeName(ParserRuleContext context, IParseTreeVisitorResults inspValues, IRangeClauseFilterFactory factory)
{
var selectStmt = (VBAParser.SelectCaseStmtContext)context;
if (TryDetectTypeHint(selectStmt.selectExpression().GetText(), out string evalTypName))
{
EvaluationTypeName = evalTypName;
return;
}
var typeName = string.Empty;
if (inspValues.TryGetValue(selectStmt.selectExpression(), out IParseTreeValue result))
{
EvaluationTypeName = result.TypeName;
}
if (InspectionCanEvaluateTypeName(EvaluationTypeName))
{
return;
}
EvaluationTypeName = DeriveTypeFromCaseClauses(inspValues, selectStmt);
}
public IUnreachableCaseInspector Create(VBAParser.SelectCaseStmtContext selectStmt, IParseTreeVisitorResults results, IParseTreeValueFactory valueFactory, Func <string, ParserRuleContext, string> func = null)
{
return(new UnreachableCaseInspector(selectStmt, results, valueFactory, func));
}
public ISelectCaseStmtContextWrapper Create(VBAParser.SelectCaseStmtContext selectStmt, IParseTreeVisitorResults results)
{
return(new SelectCaseStmtContextWrapper(selectStmt, results, FactoryProvider));
}
public SelectCaseStmtContextWrapper(VBAParser.SelectCaseStmtContext selectCaseContext, IParseTreeVisitorResults inspValues, IUnreachableCaseInspectionFactoryProvider factoryFactory)
: base(selectCaseContext, inspValues, factoryFactory)
{
_selectCaseContext = selectCaseContext;
_unreachableResults = new List <ParserRuleContext>();
_mismatchResults = new List <ParserRuleContext>();
_caseElseResults = new List <ParserRuleContext>();
_inspectionRangeFactory = factoryFactory.CreateIRangeClauseContextWrapperFactory();
SetEvaluationTypeName(Context, ParseTreeValueResults, FilterFactory);
}
public IRangeClauseContextWrapper Create(VBAParser.RangeClauseContext range, string typeName, IParseTreeVisitorResults results)
{
return(new RangeClauseContextWrapper(range, typeName, results, FactoryProvider));
}
