internal static bool IsKnownType(this SyntaxNode syntaxNode, KnownType knownType, SemanticModel semanticModel)
{
var symbolType = semanticModel.GetSymbolInfo(syntaxNode).Symbol.GetSymbolType();
return(symbolType.Is(knownType) || symbolType?.OriginalDefinition?.Is(knownType) == true);
}
public static IEnumerable <AttributeSyntax> GetAttributes(this SyntaxList <AttributeListSyntax> attributeLists,
KnownType attributeKnownType, SemanticModel semanticModel) =>
GetAttributes(attributeLists, new HashSet <KnownType> {
attributeKnownType
}, semanticModel);
public static bool Is(this ITypeSymbol typeSymbol, KnownType type)
{
return(typeSymbol != null && IsMatch(typeSymbol, type));
}
public static bool IsInType(this ISymbol symbol, KnownType type)
{
return(symbol != null && symbol.ContainingType.Is(type));
}
public static bool TryGetAttribute(this SyntaxList <AttributeListSyntax> attributeLists, KnownType attributeKnownType,
SemanticModel semanticModel, out AttributeSyntax searchedAttribute)
{
searchedAttribute = null;
if (!attributeLists.Any())
{
return(false);
}
foreach (var attribute in attributeLists.SelectMany(attributeList => attributeList.Attributes))
{
var attributeType = semanticModel.GetTypeInfo(attribute).Type;
if (attributeType.Is(attributeKnownType))
{
searchedAttribute = attribute;
return(true);
}
}
return(false);
}
public static bool DerivesOrImplements(this ITypeSymbol type, KnownType baseType)
{
return(type.Implements(baseType) ||
type.DerivesFrom(baseType));
}
internal static IEnumerable <ISymbol> GetSymbolsOfKnownType(this SeparatedSyntaxList <ArgumentSyntax> syntaxList, KnownType knownType, SemanticModel semanticModel) => syntaxList .GetArgumentsOfKnownType(knownType, semanticModel) .Select(argument => semanticModel.GetSymbolInfo(argument.Expression).Symbol);
internal static bool AnyAttributeDerivesFrom(this ISymbol symbol, KnownType attributeType) => symbol?.GetAttributes().Any(a => a.AttributeClass.DerivesFrom(attributeType)) ?? false;
internal MemberDescriptor(KnownType containingType, string name)
{
ContainingType = containingType;
Name = name;
}
internal static IEnumerable <ArgumentSyntax> GetArgumentsOfKnownType(this SeparatedSyntaxList <ArgumentSyntax> syntaxList, KnownType knownType, SemanticModel semanticModel) => syntaxList .Where(argument => semanticModel.GetTypeInfo(argument.Expression).Type.Is(knownType));
public static IEnumerable <ArgumentSyntax> GetArgumentsOfKnownType(this ObjectCreationExpressionSyntax objectCreation, KnownType knownType, SemanticModel semanticModel) => objectCreation?.ArgumentList?.Arguments.GetArgumentsOfKnownType(knownType, semanticModel) ?? Enumerable.Empty <ArgumentSyntax>();
internal static IEnumerable <ISymbol> GetArgumentSymbolsOfKnownType(this InvocationExpressionSyntax invocation, KnownType knownType, SemanticModel semanticModel) => invocation.ArgumentList.Arguments.GetSymbolsOfKnownType(knownType, semanticModel);
internal static bool HasAttribute(this ISymbol symbol, KnownType attributeType) => symbol?.GetAttributes().Any(a => a.AttributeClass.Is(attributeType)) ?? false;
internal ObjectCreationCondition WhenDerivesFrom(KnownType baseType) => (context) => context.InvokedConstructorSymbol.Value != null && context.InvokedConstructorSymbol.Value.IsConstructor() && context.InvokedConstructorSymbol.Value.ContainingType.DerivesFrom(baseType);
internal static bool IsKnownType(this SyntaxNode syntaxNode, KnownType knownType, SemanticModel semanticModel)
{
var symbolType = semanticModel.GetSymbolInfo(syntaxNode).Symbol.GetSymbolType();
return(symbolType.Is(knownType));
}
internal static IEnumerable <AttributeData> GetAttributes(this ISymbol symbol, KnownType attributeType) => symbol?.GetAttributes().Where(a => a.AttributeClass.Is(attributeType)) ?? Enumerable.Empty <AttributeData>();
internal static bool IsMemberAccessOnKnownType(this InvocationExpressionSyntax invocation, string identifierName, KnownType knownType, SemanticModel semanticModel) => invocation.Expression is MemberAccessExpressionSyntax memberAccessExpressionSyntax &&
public static bool HasAttribute(this ISymbol symbol, KnownType type) => symbol.GetAttributes(type).Any();
internal MethodSignature(KnownType containingType, string name)
{
ContainingType = containingType;
Name = name;
}
public static IEnumerable <AttributeSyntax> GetAttributes(this SyntaxList <AttributeListSyntax> attributeLists,
KnownType attributeKnownType, SemanticModel semanticModel) =>
attributeLists.SelectMany(list => list.Attributes)
.Where(a => semanticModel.GetTypeInfo(a).Type.Is(attributeKnownType));
internal InvocationCondition ArgumentAtIndexIs(int index, KnownType requiredType) => (context) => context.MethodSymbol.Value != null && context.MethodSymbol.Value.Parameters.Length > index && context.MethodSymbol.Value.Parameters[index].IsType(requiredType);
private static bool IsMatch(ITypeSymbol typeSymbol, KnownType type)
{
return(type.Matches(typeSymbol.SpecialType) || type.Matches(typeSymbol.ToDisplayString()));
}
internal InvocationCondition MethodReturnTypeIs(KnownType returnType) => (context) => context.MethodSymbol.Value != null && context.MethodSymbol.Value.ReturnType.DerivesFrom(returnType);
public static bool IsType(this IParameterSymbol parameter, KnownType type)
{
return(parameter != null && parameter.Type.Is(type));
}
public static bool IsMethodInvocation(this InvocationExpressionSyntax expression, KnownType type, string methodName, SemanticModel semanticModel) => expression.NameIs(methodName) && semanticModel.GetSymbolInfo(expression).Symbol is IMethodSymbol methodSymbol &&
public static bool Implements(this ITypeSymbol typeSymbol, KnownType type)
{
return(typeSymbol != null &&
typeSymbol.AllInterfaces.Any(symbol => symbol.ConstructedFrom.Is(type)));
}
internal ObjectCreationCondition ArgumentAtIndexIs(int index, KnownType type) => (context) => context.InvokedConstructorSymbol.Value != null && context.InvokedConstructorSymbol.Value.Parameters.Length > index && context.InvokedConstructorSymbol.Value.Parameters[index].Type.Is(type);
internal static bool IsDeclarationKnownType(this SyntaxNode syntaxNode, KnownType knownType, SemanticModel semanticModel)
{
var symbolType = semanticModel.GetDeclaredSymbol(syntaxNode)?.GetSymbolType();
return(symbolType.Is(knownType));
}
public static bool IsMemberAccessOnKnownType(this MemberAccessExpressionSyntax memberAccess, string name, KnownType knownType, SemanticModel semanticModel) =>
memberAccess.NameIs(name) &&
semanticModel.GetSymbolInfo(memberAccess).Symbol is
{