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; }