public override void VisitAnonymousFunction(IAnonymousFunctionOperation operation)
{
if (_checkAnonymousFunctions)
{
base.VisitAnonymousFunction(operation);
}
}
private static AbstractExpression ReadAnonymousFunction(IAnonymousFunctionOperation op)
{
var context = CodeReaderContext.GetContextOrThrow();
return(new AnonymousDelegateExpression {
Body = (BlockStatement)ReadBlock(op.Body),
Signature = MethodReaderMechanism.ReadSignature(context.CodeModel, op.Symbol)
});
}
internal static bool TryGetLambdaFromArgument(IInvocationOperation invoke, out IAnonymousFunctionOperation lambdaResult)
{
lambdaResult = default(IAnonymousFunctionOperation);
if (!(invoke.Arguments[1].Value is IDelegateCreationOperation delegateCreation) ||
!(delegateCreation.Target is IAnonymousFunctionOperation lambda))
{
return(false);
}
lambdaResult = lambda;
return(true);
}
private static IMethodSymbol?FindOwningSymbol(IBlockOperation block, ISymbol containingSymbol)
{
return(block.Parent switch
{
ILocalFunctionOperation localFunction => localFunction.Symbol,
IAnonymousFunctionOperation anonymousFunction => anonymousFunction.Symbol,
// Block parent is the method declaration, for vbnet this means a null parent but for C# it's a IMethodBodyOperation
null => containingSymbol as IMethodSymbol,
IMethodBodyOperation _ => containingSymbol as IMethodSymbol,
_ => null,
});
internal static bool TryGetSingleReturnValue <T>(IAnonymousFunctionOperation lambda, out T returnedValue) where T : IOperation
{
returnedValue = default(T);
var anyBlock = lambda.Body.Operations;
if (anyBlock.Length != 1 ||
!(anyBlock[0] is IReturnOperation ret) ||
!(ret.ReturnedValue is T temp))
{
return(false);
}
returnedValue = temp;
return(true);
}
private LocalFunctionStatementSyntax CreateLocalFunction(IAnonymousFunctionOperation operation,
IVariableDeclaratorOperation variableDeclaratorOperation,
ParameterListSyntax param, BlockSyntax block,
ArrowExpressionClauseSyntax arrow)
{
string symbolName = variableDeclaratorOperation.Symbol.Name;
LocalFunctionStatementSyntax localFunc = SyntaxFactory.LocalFunctionStatement(
SyntaxFactory.TokenList(),
CommonConversions.GetTypeSyntax(operation.Symbol.ReturnType),
SyntaxFactory.Identifier(symbolName), null, param,
SyntaxFactory.List <TypeParameterConstraintClauseSyntax>(), block, arrow,
SyntaxFactory.Token(SyntaxKind.SemicolonToken));
if (operation.Symbol.IsAsync)
{
localFunc = localFunc.AddModifiers(SyntaxFactory.Token(SyntaxKind.AsyncKeyword));
}
return(localFunc);
}
private MethodDeclarationSyntax CreateMethodDeclaration(IAnonymousFunctionOperation operation,
IFieldSymbol fieldSymbol,
BlockSyntax block, ArrowExpressionClauseSyntax arrow)
{
MethodDeclarationSyntax methodDecl =
((MethodDeclarationSyntax)CommonConversions.CsSyntaxGenerator.MethodDeclaration(operation.Symbol))
.WithIdentifier(SyntaxFactory.Identifier(fieldSymbol.Name))
.WithBody(block).WithExpressionBody(arrow);
if (operation.Symbol.IsAsync)
{
methodDecl = methodDecl.AddModifiers(SyntaxFactory.Token(SyntaxKind.AsyncKeyword));
}
if (arrow != null)
{
methodDecl = methodDecl.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
}
return(methodDecl);
}
private static bool HasAnyParameterMatchInScope(OperationAnalysisContext context, string stringText)
{
// get the parameters for the containing method
foreach (var parameter in context.ContainingSymbol.GetParameters())
{
if (parameter.Name == stringText)
{
return(true);
}
}
// and loop through the ancestors to find parameters of anonymous functions and local functions
var parentOperation = context.Operation.Parent;
while (parentOperation != null)
{
IMethodSymbol?methodSymbol = parentOperation switch
{
IAnonymousFunctionOperation anonymousOperation => anonymousOperation.Symbol,
ILocalFunctionOperation localFunctionOperation => localFunctionOperation.Symbol,
_ => null
};
if (methodSymbol is not null)
{
foreach (var methodParameter in methodSymbol.Parameters)
{
if (methodParameter.Name == stringText)
{
return(true);
}
}
}
parentOperation = parentOperation.Parent;
}
return(false);
}
}
public override IOperation VisitAnonymousFunction(IAnonymousFunctionOperation operation, object argument)
{
return(new AnonymousFunctionExpression(operation.Symbol, Visit(operation.Body), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
public override void VisitAnonymousFunction(IAnonymousFunctionOperation operation)
{
Assert.Equal(OperationKind.AnonymousFunction, operation.Kind);
Assert.NotNull(operation.Symbol);
Assert.Same(operation.Body, operation.Children.Single());
}
public override void VisitAnonymousFunction(IAnonymousFunctionOperation operation)
{
// for now there doesn't seem to be any way to annotate lambdas with attributes
}
private void InitializeWorker(CompilationStartAnalysisContext context, SymbolCache symbolCache)
{
context.RegisterOperationBlockStartAction(startBlockContext =>
{
var capturedDiagnosticLocations = new HashSet <Location>();
startBlockContext.RegisterOperationAction(context =>
{
var awaitOperation = (IAwaitOperation)context.Operation;
if (awaitOperation.Operation.Kind != OperationKind.Invocation)
{
return;
}
var invocationOperation = (IInvocationOperation)awaitOperation.Operation;
if (!IsTagHelperRunnerRunAsync(invocationOperation.TargetMethod, symbolCache))
{
return;
}
var parent = context.Operation.Parent;
while (parent != null && !IsParentMethod(parent))
{
parent = parent.Parent;
}
if (parent == null)
{
return;
}
var methodSymbol = (IMethodSymbol?)(parent switch
{
ILocalFunctionOperation localFunctionOperation => localFunctionOperation.Symbol,
IAnonymousFunctionOperation anonymousFunctionOperation => anonymousFunctionOperation.Symbol,
IMethodBodyOperation methodBodyOperation => startBlockContext.OwningSymbol,
_ => null,
});
if (methodSymbol == null)
{
// Unsupported operation type.
return;
}
if (!methodSymbol.IsAsync ||
!symbolCache.TaskType.IsAssignableFrom(methodSymbol.ReturnType))
{
capturedDiagnosticLocations.Add(parent.Syntax.GetLocation());
}
}, OperationKind.Await);
startBlockContext.RegisterOperationBlockEndAction(context =>
{
foreach (var location in capturedDiagnosticLocations)
{
context.ReportDiagnostic(
Diagnostic.Create(TagHelperInCodeBlockDiagnostic, location));
}
});
});
public virtual void VisitAnonymousFunction(IAnonymousFunctionOperation operation)
{
DefaultVisit(operation);
}
public override void VisitAnonymousFunction(IAnonymousFunctionOperation operation)
{
// Include lamdas but don't include statements inside them,
// because they don't belong to the lambda's containing method.
}
public override void VisitAnonymousFunction(IAnonymousFunctionOperation operation)
{
var signature = operation.Symbol;
base.VisitAnonymousFunction(operation);
}
public override NullAbstractValue VisitAnonymousFunction(IAnonymousFunctionOperation operation, object argument)
{
var _ = base.VisitAnonymousFunction(operation, argument);
return(NullAbstractValue.NotNull);
}
public override void VisitAnonymousFunction([NotNull] IAnonymousFunctionOperation operation)
{
scopeDepth++;
base.VisitAnonymousFunction(operation);
scopeDepth--;
}
public override void VisitAnonymousFunction([NotNull] IAnonymousFunctionOperation operation)
{
}
public override bool VisitAnonymousFunction([NotNull] IAnonymousFunctionOperation operation1,
[CanBeNull] IOperation argument)
{
return(argument is IAnonymousFunctionOperation operation2 && AreBaseOperationsEqual(operation1, operation2) &&
AreSymbolsEqual(operation1.Symbol, operation2.Symbol));
}
