public ContextWrapperBase(ParserRuleContext context, IParseTreeVisitorResults inspValues, IUnreachableCaseInspectionFactoryProvider factoryFactory)
{
_context = context;
_rangeFilterFactory = factoryFactory.CreateIRangeClauseFilterFactory();
_valueFactory = factoryFactory.CreateIParseTreeValueFactory();
_inspValues = inspValues;
}
public UnreachableCaseInspection(RubberduckParserState state) : base(state)
{
var factoryProvider = new UnreachableCaseInspectionFactoryProvider();
_unreachableCaseInspectorFactory = factoryProvider.CreateIUnreachableInspectorFactory();
_valueFactory = factoryProvider.CreateIParseTreeValueFactory();
}
public ImplicitAsTypeNameResolver(IDeclarationFinderProvider declarationFinderProvider,
IParseTreeValueFactory parseTreeValueFactory, Declaration target)
{
_declarationFinderProvider = declarationFinderProvider;
_literalExprContextEvaluator = new LiteralExprContextToAsTypeNameConverter(parseTreeValueFactory);
_target = target;
}
public ParseTreeValueVisitor(RubberduckParserState state, IParseTreeValueFactory valueFactory)
{
_state = state;
_inspValueFactory = valueFactory;
Calculator = new ParseTreeExpressionEvaluator(valueFactory);
_contextValues = new ParseTreeVisitorResults();
OnValueResultCreated += _contextValues.OnNewValueResult;
}
public UnreachableCaseInspection(RubberduckParserState state) : base(state)
{
//TODO_Question: IUnreachableCaseInspectionFactoryFactory - candidate for IoCInstaller?
var factoriesFactory = new UnreachableCaseInspectionFactoryProvider();
_selectStmtFactory = factoriesFactory.CreateISelectStmtContextWrapperFactory();
_valueFactory = factoriesFactory.CreateIParseTreeValueFactory();
_parseTreeVisitorFactory = factoriesFactory.CreateIParseTreeValueVisitorFactory();
}
public ImplicitTypeToExplicitRefactoringAction(
IDeclarationFinderProvider declarationFinderProvider,
IParseTreeValueFactory parseTreeValueFactory,
IRewritingManager rewritingManager)
: base(rewritingManager)
{
_declarationFinderProvider = declarationFinderProvider;
_parseTreeValueFactory = parseTreeValueFactory;
}
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);
}
public IRangeClauseFilter Create(string typeName, IParseTreeValueFactory valueFactory)
{
if (valueFactory is null)
{
throw new ArgumentNullException();
}
if (!(IntegralNumberExtents.Keys.Contains(typeName) ||
typeName.Equals(Tokens.Double) ||
typeName.Equals(Tokens.Single) ||
typeName.Equals(Tokens.Currency) ||
typeName.Equals(Tokens.Boolean) ||
typeName.Equals(Tokens.String)))
{
throw new ArgumentException($"Unsupported TypeName ({typeName})");
}
if (IntegralNumberExtents.Keys.Contains(typeName))
{
var integerTypeFilter = new RangeClauseFilter <long>(typeName, valueFactory, this, ParseTreeValue.TryConvertValue);
var minExtent = valueFactory.Create(IntegralNumberExtents[typeName].Item1.ToString(), typeName);
var maxExtent = valueFactory.Create(IntegralNumberExtents[typeName].Item2.ToString(), typeName);
integerTypeFilter.AddExtents(minExtent, maxExtent);
return(integerTypeFilter);
}
else if (typeName.Equals(Tokens.Double) || typeName.Equals(Tokens.Single))
{
var doubleTypeFilter = new RangeClauseFilter <double>(typeName, valueFactory, this, ParseTreeValue.TryConvertValue);
if (typeName.Equals(Tokens.Single))
{
var minExtent = valueFactory.Create(CompareExtents.SINGLEMIN.ToString(), typeName);
var maxExtent = valueFactory.Create(CompareExtents.SINGLEMAX.ToString(), typeName);
doubleTypeFilter.AddExtents(minExtent, maxExtent);
}
return(doubleTypeFilter);
}
else if (typeName.Equals(Tokens.Boolean))
{
var boolTypeFilter = new RangeClauseFilter <bool>(typeName, valueFactory, this, ParseTreeValue.TryConvertValue);
return(boolTypeFilter);
}
else if (typeName.Equals(Tokens.Currency))
{
var decimalTypeFilter = new RangeClauseFilter <decimal>(typeName, valueFactory, this, ParseTreeValue.TryConvertValue);
var minExtent = valueFactory.Create(CompareExtents.CURRENCYMIN.ToString(), typeName);
var maxExtent = valueFactory.Create(CompareExtents.CURRENCYMAX.ToString(), typeName);
decimalTypeFilter.AddExtents(minExtent, maxExtent);
return(decimalTypeFilter);
}
var filter = new RangeClauseFilter <string>(typeName, valueFactory, this, ParseTreeValue.TryConvertValue);
return(filter);
}
public RangeClauseFilter(string typeName, IParseTreeValueFactory valueFactory, IRangeClauseFilterFactory filterFactory, TryConvertParseTreeValue <T> tConverter)
{
_valueFactory = valueFactory;
_filterFactory = filterFactory;
_valueConverter = tConverter;
_ranges = new List <Tuple <T, T> >();
_singleValues = new HashSet <T>();
_isClause = new Dictionary <string, List <T> >();
_relationalOps = new HashSet <string>();
_variableRanges = new HashSet <string>();
_variableSingles = new HashSet <string>();
_hasExtents = false;
_falseValue = ConvertToContainedGeneric(false);
_trueValue = ConvertToContainedGeneric(true);
TypeName = typeName;
_cachedDescriptor = string.Empty;
_descriptorIsDirty = true;
}
CreateLogicPair(IParseTreeValue value, string opSymbol, IParseTreeValueFactory factory)
{
var operands = value.Token.Split(new string[] { opSymbol }, StringSplitOptions.None);
if (operands.Count() == 2)
{
var lhs = factory.Create(operands[0].Trim());
var rhs = factory.Create(operands[1].Trim());
if (opSymbol.Equals(Tokens.Like))
{
rhs = factory.CreateDeclaredType($"\"{rhs.Token}\"", Tokens.String);
}
return(lhs, rhs);
}
if (operands.Count() == 1)
{
var lhs = factory.Create(operands[0].Trim());
return(lhs, null);
}
return(null, null);
}
public IUnreachableCaseInspector Create(VBAParser.SelectCaseStmtContext selectStmt, IParseTreeVisitorResults results, IParseTreeValueFactory valueFactory, Func <string, ParserRuleContext, string> func = null)
{
return(new UnreachableCaseInspector(selectStmt, results, valueFactory, func));
}
public ParseTreeExpressionEvaluator(IParseTreeValueFactory valueFactory)
{
_valueFactory = valueFactory;
}
public ParseTreeExpressionEvaluator(IParseTreeValueFactory valueFactory, bool isOptionCompareBinary = true)
{
_valueFactory = valueFactory;
_isOptionCompareBinary = isOptionCompareBinary;
}
public IParseTreeValueVisitor Create(RubberduckParserState state, IParseTreeValueFactory valueFactory)
{
return(new ParseTreeValueVisitor(state, valueFactory));
}
public static IParseTreeValueVisitor CreateParseTreeValueVisitor(IParseTreeValueFactory valueFactory, List <VBAParser.EnumerationStmtContext> allEnums, Func <ParserRuleContext, (bool success, IdentifierReference idRef)> func)
public ParseTreeValueVisitor(IParseTreeValueFactory valueFactory, List <VBAParser.EnumerationStmtContext> allEnums, Func <ParserRuleContext, (bool success, IdentifierReference idRef)> idRefRetriever)
public LiteralExprContextToAsTypeNameConverter(IParseTreeValueFactory parseTreeValueFactory)
{
_parseTreeValueFactory = parseTreeValueFactory;
}
