public static InvocationExpressionSyntax CreateInvocationStatement(ArgumentSyntax threadArgument)
{
InvocationExpressionSyntax invocationStatement;
if (threadArgument.ChildNodes().OfType <IdentifierNameSyntax>().Any())
{
var methodName = threadArgument.ChildNodes().OfType <IdentifierNameSyntax>().First();
invocationStatement = CreateInvocationExpressionSyntax(methodName);
}
else
{
var lambda = threadArgument.ChildNodes().OfType <ParenthesizedLambdaExpressionSyntax>().First();
invocationStatement = CreateInvocationExpressionSyntax(lambda);
}
return(invocationStatement);
}
public override void VisitArgument(ArgumentSyntax node)
{
CheckHttpRequests(node);
foreach (var n in node.ChildNodes())
{
Visit(n);
}
}
private void CheckForAllowedSyntaxForConstantBinding(
)
{
var child = _constantClause.ChildNodes().FirstOrDefault();
if (child == null)
{
throw new DpdtException(
DpdtExceptionTypeEnum.InternalError,
$"Unknown error during validation a target in 'constant' binding."
);
}
var cconstant = _semanticModel.GetConstantValue(child);
if (cconstant.HasValue)
{
//it's a true constant, keep going!
return;
}
var ilsymbol = _semanticModel.GetSymbolInfo(child).Symbol;
if (ilsymbol is null)
{
throw new DpdtException(
DpdtExceptionTypeEnum.InternalError,
$"Unknown error during validation a target in 'constant' binding."
);
}
if (ilsymbol.Kind != SymbolKind.Field)
{
throw new DpdtException(
DpdtExceptionTypeEnum.InternalError,
$"Unsupported type of 'constant' binding. Allowed compile-time constants, readonly fields and readonly static fields only."
);
}
var filsymbol = ilsymbol as IFieldSymbol;
if (filsymbol is null)
{
throw new DpdtException(
DpdtExceptionTypeEnum.InternalError,
$"Unknown error during validation a target in 'constant' binding."
);
}
if (!filsymbol.IsReadOnly)
{
throw new DpdtException(
DpdtExceptionTypeEnum.InternalError,
$"Unsupported type of 'constant' binding. Allowed compile-time constants, readonly fields and readonly static fields only."
);
}
}
private object GetDetails(ArgumentSyntax argument)
{
var identifier = argument.ChildNodes().OfType<IdentifierNameSyntax>().FirstOrDefault();
if (identifier == null)
{
// this is really quite crap
var child = argument.ChildNodes().OfType<IdentifierNameSyntax>().FirstOrDefault() ??
(SyntaxNode)argument.ChildNodes().OfType<InvocationExpressionSyntax>().FirstOrDefault();
if (child != null)
{
identifier = child.ChildNodes().OfType<IdentifierNameSyntax>().First();
}
}
if (identifier != null)
{
return identifier.Identifier.ValueText;
}
var lamda = argument.ChildNodes().OfType<SimpleLambdaExpressionSyntax>().FirstOrDefault();
return lamda;
}
/// <summary>
/// Generates an argument
/// </summary>
/// <param name="arg">The argument</param>
public void GenerateArgument(ArgumentSyntax arg)
{
IEnumerable <SyntaxNode> children = arg.ChildNodes();
foreach (ExpressionSyntax child in children)
{
ITypeSymbol type = m_context.Model.GetTypeInfo(child).Type;
if (type != null && !m_context.GenericTypeConvert.IsGeneric(type) && type.TypeKind == TypeKind.Class)
{
m_context.Writer.Append("(void*)");
}
m_context.Generators.Expression.Generate(child);
}
}
private static bool IsThreadWithMethodArgument(ArgumentSyntax argument)
{
return(argument.ChildNodes().OfType <IdentifierNameSyntax>().Any());
}
