private static void RunCallbackTest <T>( T expected, Func <Action <T>, CallbackVisitor> ctor, Action <CallbackVisitor, T> call, Action <T, T> verifyResults = null ) { // Arrange object actual = null; Action <T> callback = t => actual = t; CallbackVisitor listener = ctor(callback); // Act call(listener, expected); // Assert if (verifyResults == null) { Assert.Equal(expected, actual); } else { verifyResults(expected, (T)actual); } }
private static void RunSyncContextTest <T>( T expected, Func <Action <T>, CallbackVisitor> ctor, Action <CallbackVisitor, T> call ) { // Arrange Mock <SynchronizationContext> mockContext = new Mock <SynchronizationContext>(); mockContext .Setup(c => c.Post(It.IsAny <SendOrPostCallback>(), It.IsAny <object>())) .Callback <SendOrPostCallback, object>( (callback, state) => { callback(expected); } ); // Act/Assert RunCallbackTest <T>( default(T), callback => { CallbackVisitor listener = ctor(callback); listener.SynchronizationContext = mockContext.Object; return(listener); }, call, (original, actual) => { Assert.NotEqual(original, actual); Assert.Equal(expected, actual); } ); }
private static string GetUniqueVariableNameForNewScope(SyntaxBase syntax, string name) { var variableAccesses = new HashSet <string>(LanguageConstants.IdentifierComparer); CallbackVisitor.Visit(syntax, child => { if (child is VariableAccessSyntax variableAccess) { variableAccesses.Add(variableAccess.Name.IdentifierName); } return(true); }); if (!variableAccesses.Contains(name)) { return(name); } var index = 1; while (true) { var newName = $"{name}_{index}"; if (!variableAccesses.Contains(newName)) { return(newName); } } }
public void ListenerConstructedWithSpanCallbackDoesNotThrowOnStartBlockEndBlockOrError() { // Arrange Action <Span> spanCallback = _ => { }; CallbackVisitor listener = new CallbackVisitor(spanCallback); // Act/Assert listener.VisitStartBlock(BlockType.Functions); listener.VisitError(new RazorError("Error", SourceLocation.Zero)); listener.VisitEndBlock(BlockType.Functions); }
protected override SyntaxBase ReplaceForSyntax(ForSyntax syntax) { syntax = (ForSyntax)base.ReplaceForSyntax(syntax); // look for range(0, length(<variable>)) if (!IsLoopIteratorExpression(semanticModel, syntax.Expression, out var arrayVariable)) { return(syntax); } if (syntax.VariableSection is not LocalVariableSyntax indexVariable) { return(syntax); } var arraySymbol = semanticModel.GetSymbolInfo(arrayVariable); var arrayIndexSymbol = semanticModel.GetSymbolInfo(indexVariable); if (arraySymbol is null || arrayIndexSymbol is null) { return(syntax); } var arrayAccesses = new HashSet <ArrayAccessSyntax>(); var independentIndexAccesses = new HashSet <VariableAccessSyntax>(); CallbackVisitor.Visit(syntax, child => { if (child is ArrayAccessSyntax arrayAccess) { if (semanticModel.GetSymbolInfo(arrayAccess.BaseExpression) == arraySymbol && semanticModel.GetSymbolInfo(arrayAccess.IndexExpression) == arrayIndexSymbol) { arrayAccesses.Add(arrayAccess); // we don't want to count the VariableAccessSyntax under this particular node, // so return false to skip visiting children. return(false); } } if (child is VariableAccessSyntax variableAccess) { var accessSymbol = semanticModel.GetSymbolInfo(variableAccess); if (accessSymbol == arrayIndexSymbol) { independentIndexAccesses.Add(variableAccess); } } return(true); }); if (!arrayAccesses.Any()) { // nothing to really simplify here return(syntax); } var itemVarName = GetUniqueVariableNameForNewScope(syntax, "item"); var forBody = CallbackRewriter.Rewrite(syntax.Body, child => { if (arrayAccesses.Contains(child)) { return(new VariableAccessSyntax(SyntaxFactory.CreateIdentifier(itemVarName))); } return(child); }); SyntaxBase forVariableBlockSyntax; if (independentIndexAccesses.Any()) { forVariableBlockSyntax = new ForVariableBlockSyntax( SyntaxFactory.LeftParenToken, new LocalVariableSyntax(SyntaxFactory.CreateIdentifier(itemVarName)), SyntaxFactory.CommaToken, new LocalVariableSyntax(SyntaxFactory.CreateIdentifier(arrayIndexSymbol.Name)), SyntaxFactory.RightParenToken); } else { forVariableBlockSyntax = new LocalVariableSyntax(SyntaxFactory.CreateIdentifier(itemVarName)); } var forExpression = new VariableAccessSyntax(SyntaxFactory.CreateIdentifier(arraySymbol.Name)); return(new ForSyntax( syntax.OpenSquare, syntax.ForKeyword, forVariableBlockSyntax, syntax.InKeyword, forExpression, syntax.Colon, forBody, syntax.CloseSquare)); }