public override void VisitLocalFunction(ILocalFunctionOperation operation)
{
Assert.Equal(OperationKind.LocalFunction, operation.Kind);
Assert.NotNull(operation.Symbol);
if (operation.Body != null)
{
var children = operation.Children.ToImmutableArray();
Assert.Same(operation.Body, children[0]);
if (operation.IgnoredBody != null)
{
Assert.Same(operation.IgnoredBody, children[1]);
Assert.Equal(2, children.Length);
}
else
{
Assert.Equal(1, children.Length);
}
}
else
{
Assert.Null(operation.IgnoredBody);
Assert.Empty(operation.Children);
}
}
public void Add(IMethodSymbol symbol, ILocalFunctionOperation operation)
{
Debug.Assert(Kind != ControlFlowRegionKind.Root);
Debug.Assert(symbol.MethodKind == MethodKind.LocalFunction);
if (LocalFunctions == null)
{
LocalFunctions = ArrayBuilder <(IMethodSymbol, ILocalFunctionOperation)> .GetInstance();
}
LocalFunctions.Add((symbol, operation));
}
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,
});
public override void VisitLocalFunction(ILocalFunctionOperation operation)
{
Assert.Equal(OperationKind.LocalFunction, operation.Kind);
Assert.NotNull(operation.Symbol);
if (operation.Body != null)
{
Assert.Same(operation.Body, operation.Children.Single());
}
else
{
Assert.Empty(operation.Children);
}
}
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 VisitLocalFunction(ILocalFunctionOperation operation, object argument)
{
return(new LocalFunctionStatement(operation.Symbol, Visit(operation.Body), Visit(operation.IgnoredBody), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
}
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 VisitLocalFunction(ILocalFunctionOperation operation)
{
DefaultVisit(operation);
}
public override void VisitLocalFunction(ILocalFunctionOperation operation)
{
// Include local functions but don't include statements inside them,
// because they don't belong to the local function's containing method.
}
public override void VisitLocalFunction([NotNull] ILocalFunctionOperation operation)
{
base.VisitLocalFunction(operation);
}
public override void VisitLocalFunction([NotNull] ILocalFunctionOperation operation)
{
IncrementStatementCount(operation);
base.VisitLocalFunction(operation);
}
public override Location VisitLocalFunction([NotNull] ILocalFunctionOperation operation, [CanBeNull] object argument)
{
return(operation.Symbol.Locations.FirstOrDefault());
}
public override void VisitLocalFunction([NotNull] ILocalFunctionOperation operation)
{
scopeDepth++;
base.VisitLocalFunction(operation);
scopeDepth--;
}
public override void VisitLocalFunction(ILocalFunctionOperation operation)
{
var localFunction = operation.Symbol;
base.VisitLocalFunction(operation);
}
public override bool VisitLocalFunction([NotNull] ILocalFunctionOperation operation1, [CanBeNull] IOperation argument)
{
return(argument is ILocalFunctionOperation operation2 && AreBaseOperationsEqual(operation1, operation2) &&
AreSymbolsEqual(operation1.Symbol, operation2.Symbol));
}
