public static IMethodSymbol GetExplictCoversionOp(this ITypeSymbol type, ITypeSymbol returnTypeSymbol,
ITypeSymbol originalTypeSymbol, bool allowNarrowing = false)
{
if (!returnTypeSymbol.IsPrimitiveInteger())
allowNarrowing = false;
if (!allowNarrowing)
{
return
type.GetMembers("op_Explicit")
.OfType<IMethodSymbol>()
.FirstOrDefault(
h =>
returnTypeSymbol.IsAssignableFrom(h.ReturnType) &&
h.Parameters[0].Type.IsAssignableFrom(originalTypeSymbol));
}
IMethodSymbol bestMatch = null;
int lastSizeDiff = 1000;
foreach (var member in type.GetMembers("op_Explicit")
.OfType<IMethodSymbol>().Where(h =>
h.Parameters[0].Type.IsAssignableFrom(originalTypeSymbol)))
{
var sizediff = member.ReturnType.SizeOf() - returnTypeSymbol.SizeOf();
if (sizediff <= lastSizeDiff)
{
lastSizeDiff = sizediff;
bestMatch = member;
}
}
return bestMatch;
}
private SyntaxNode FixMethod(
bool keepVoid, IMethodSymbol methodSymbol, MethodDeclarationSyntax method,
ITypeSymbol taskType, INamedTypeSymbol taskOfTType)
{
var newReturnType = method.ReturnType;
if (methodSymbol.ReturnsVoid)
{
if (!keepVoid)
{
newReturnType = taskType.GenerateTypeSyntax();
}
}
else
{
if (!IsTaskLike(methodSymbol.ReturnType, taskType, taskOfTType))
{
// If it's not already Task-like, then wrap the existing return type
// in Task<>.
newReturnType = taskOfTType.Construct(methodSymbol.ReturnType).GenerateTypeSyntax();
}
}
var newModifiers = method.Modifiers.Add(s_asyncToken);
return method.WithReturnType(newReturnType).WithModifiers(newModifiers);
}
public EventCreationCompletionData (ICompletionDataKeyHandler keyHandler, RoslynCodeCompletionFactory factory, ITypeSymbol delegateType, string varName, INamedTypeSymbol curType) : base (factory, keyHandler)
{
this.DisplayText = varName;
this.delegateType = delegateType;
this.factory = factory;
this.Icon = "md-newmethod";
}
private static async Task<Document> ChangeToImmutableArrayCreateRange(
ObjectCreationExpressionSyntax objectCreation,
InitializerExpressionSyntax initializer,
INamedTypeSymbol immutableArrayType,
ITypeSymbol elementType,
Document document,
CancellationToken cancellationToken)
{
var generator = SyntaxGenerator.GetGenerator(document);
var arrayElementType = (TypeSyntax)generator.TypeExpression(elementType);
var arrayType = SyntaxFactory.ArrayType(arrayElementType,
SyntaxFactory.SingletonList(
SyntaxFactory.ArrayRankSpecifier(
SyntaxFactory.SingletonSeparatedList(
(ExpressionSyntax)SyntaxFactory.OmittedArraySizeExpression()))));
var arrayCreationExpression = SyntaxFactory.ArrayCreationExpression(
type: arrayType,
initializer: SyntaxFactory.InitializerExpression(
kind: SyntaxKind.ArrayInitializerExpression,
expressions: initializer.Expressions))
.WithAdditionalAnnotations(Formatter.Annotation);
var type = generator.TypeExpression(immutableArrayType);
var memberAccess = generator.MemberAccessExpression(type, "CreateRange");
var invocation = generator.InvocationExpression(memberAccess, arrayCreationExpression);
var oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
var newRoot = oldRoot.ReplaceNode(objectCreation, invocation);
return document.WithSyntaxRoot(newRoot);
}
private static IEnumerable<string> GetContainingTypeName(ITypeSymbol symbol)
{
for (var typeSymbol = symbol; typeSymbol != null; typeSymbol = typeSymbol.ContainingSymbol as ITypeSymbol)
{
yield return typeSymbol.Name;
}
}
public AnalyzerResult(
SemanticDocument document,
IEnumerable<ITypeParameterSymbol> typeParametersInDeclaration,
IEnumerable<ITypeParameterSymbol> typeParametersInConstraintList,
IList<VariableInfo> variables,
VariableInfo variableToUseAsReturnValue,
ITypeSymbol returnType,
bool awaitTaskReturn,
bool instanceMemberIsUsed,
bool endOfSelectionReachable,
OperationStatus status)
{
var semanticModel = document.SemanticModel;
this.UseInstanceMember = instanceMemberIsUsed;
this.EndOfSelectionReachable = endOfSelectionReachable;
this.AwaitTaskReturn = awaitTaskReturn;
this.SemanticDocument = document;
_typeParametersInDeclaration = typeParametersInDeclaration.Select(s => semanticModel.ResolveType(s)).ToList();
_typeParametersInConstraintList = typeParametersInConstraintList.Select(s => semanticModel.ResolveType(s)).ToList();
_variables = variables;
this.ReturnType = semanticModel.ResolveType(returnType);
_variableToUseAsReturnValue = variableToUseAsReturnValue;
this.Status = status;
}
/// <summary>
/// Is this a method on <see cref="Enumerable" /> which takes only a single parameter?
/// </summary>
/// <remarks>
/// Many of the methods we target, like Last, have overloads that take a filter delegate. It is
/// completely appropriate to use such methods even with <see cref="IReadOnlyList{T}" />. Only the single parameter
/// ones are suspect
/// </remarks>
private static bool IsSingleParameterLinqMethod(IMethodSymbol methodSymbol, ITypeSymbol enumerableType)
{
Debug.Assert(methodSymbol.ReducedFrom == null);
return
methodSymbol.ContainingSymbol.Equals(enumerableType) &&
methodSymbol.Parameters.Length == 1;
}
/// <summary>
/// Analyzes if type information is obvious to the reader by simply looking at the assignment expression.
/// </summary>
/// <remarks>
/// <paramref name="typeInDeclaration"/> accepts null, to be able to cater to codegen features
/// that are about to generate a local declaration and do not have this information to pass in.
/// Things (like analyzers) that do have a local declaration already, should pass this in.
/// </remarks>
public static bool IsTypeApparentInAssignmentExpression(
TypeStylePreference stylePreferences,
ExpressionSyntax initializerExpression,
SemanticModel semanticModel,
CancellationToken cancellationToken,
ITypeSymbol typeInDeclaration = null)
{
// default(type)
if (initializerExpression.IsKind(SyntaxKind.DefaultExpression))
{
return true;
}
// literals, use var if options allow usage here.
if (initializerExpression.IsAnyLiteralExpression())
{
return stylePreferences.HasFlag(TypeStylePreference.ImplicitTypeForIntrinsicTypes);
}
// constructor invocations cases:
// = new type();
if (initializerExpression.IsKind(SyntaxKind.ObjectCreationExpression) &&
!initializerExpression.IsKind(SyntaxKind.AnonymousObjectCreationExpression))
{
return true;
}
// explicit conversion cases:
// (type)expr, expr is type, expr as type
if (initializerExpression.IsKind(SyntaxKind.CastExpression) ||
initializerExpression.IsKind(SyntaxKind.IsExpression) ||
initializerExpression.IsKind(SyntaxKind.AsExpression))
{
return true;
}
// other Conversion cases:
// a. conversion with helpers like: int.Parse methods
// b. types that implement IConvertible and then invoking .ToType()
// c. System.Convert.Totype()
var memberName = GetRightmostInvocationExpression(initializerExpression).GetRightmostName();
if (memberName == null)
{
return false;
}
var methodSymbol = semanticModel.GetSymbolInfo(memberName, cancellationToken).Symbol as IMethodSymbol;
if (methodSymbol == null)
{
return false;
}
if (memberName.IsRightSideOfDot())
{
var containingTypeName = memberName.GetLeftSideOfDot();
return IsPossibleCreationOrConversionMethod(methodSymbol, typeInDeclaration, semanticModel, containingTypeName, cancellationToken);
}
return false;
}
public CreatePartialCompletionData (ICompletionDataKeyHandler keyHandler, RoslynCodeCompletionFactory factory, int declarationBegin, ITypeSymbol currentType, ISymbol member, bool afterKeyword) : base (keyHandler, factory, member)
{
this.afterKeyword = afterKeyword;
this.currentType = currentType;
this.declarationBegin = declarationBegin;
this.GenerateBody = true;
}
public static string ConvertPInvokeType(ITypeSymbol returnType, PInvokeMode mode = PInvokeMode.None)
{
var dType = TypeProcessor.ConvertType(returnType);
if (returnType.TypeKind == TypeKind.Delegate)
{
return GetDelegateRawType(dType);
// var dlg =returnType.OriginalDefinition as IMethodSymbol;
// if (dlg.Parameters.Length == 0)
//// return "() => " + TryConvertType (dlg.ReturnType);
//// else
//// return "(" + string.Join (", ", dlg.Parameters.ToList ().Select (o => TryConvertType (o.Type))) + ") => " + TryConvertType (dlg.ReturnType);
//
//
//
// return TypeProcessor.ConvertType (dlg.ReturnType) + " delegate" +
// dlg.Parameters.ToList ().Select (o => ConvertPInvokeType (o.Type)) + ")";
// return dType.RemoveFromStartOfString("Delegate!(").SubstringBeforeLast(')');
}
//TODO this should become a class with different options like CharSet etc ..
switch (dType)
{
case "String":
return "char *"; //TODO: Should be dependent on the charset
case "Array_T!(String)":
return "char**";
}
return dType;
}
private static string ResolveTypeName(ITypeSymbol symbol)
{
INamedTypeSymbol symbol3;
var builder = new StringBuilder();
var flag = false;
var symbol2 = symbol as IArrayTypeSymbol;
if (symbol2 != null)
{
flag = true;
symbol = symbol2.ElementType;
}
builder.Append(symbol.Name);
if (((symbol3 = symbol as INamedTypeSymbol) != null) && symbol3.TypeArguments.Any())
{
IEnumerable<string> values = (from x in symbol3.TypeArguments.AsEnumerable() select ResolveTypeName(x)).ToArray<string>();
builder.AppendFormat("<{0}>", string.Join(", ", values));
}
if (flag)
{
builder.Append("[]");
}
return builder.ToString();
}
private static bool TryGetAllEnumMembers(
ITypeSymbol enumType,
Dictionary<long, ISymbol> enumValues)
{
foreach (var member in enumType.GetMembers())
{
// skip `.ctor` and `__value`
var fieldSymbol = member as IFieldSymbol;
if (fieldSymbol == null || fieldSymbol.Type.SpecialType != SpecialType.None)
{
continue;
}
if (fieldSymbol.ConstantValue == null)
{
// We have an enum that has problems with it (i.e. non-const members). We won't
// be able to determine properly if the switch is complete. Assume it is so we
// don't offer to do anything.
return false;
}
// Multiple enum members may have the same value. Only consider the first one
// we run int.
var enumValue = IntegerUtilities.ToInt64(fieldSymbol.ConstantValue);
if (!enumValues.ContainsKey(enumValue))
{
enumValues.Add(enumValue, fieldSymbol);
}
}
return true;
}
public Property(string name, ITypeSymbol type, bool hasGetter, bool hasSetter)
{
Name = name;
Type = type;
HasSetter = hasSetter;
HasGetter = hasGetter;
}
protected override bool IsAssignableTo(Compilation compilation, ITypeSymbol fromSymbol, ITypeSymbol toSymbol)
{
return
fromSymbol != null &&
toSymbol != null &&
((CSharpCompilation)compilation).ClassifyConversion(fromSymbol, toSymbol).IsImplicit;
}
private bool TypeHasWeakIdentity(ITypeSymbol type, SemanticModel model)
{
switch (type.TypeKind)
{
case TypeKind.ArrayType:
var arrayType = type as IArrayTypeSymbol;
return arrayType != null && arrayType.ElementType.IsPrimitiveType();
case TypeKind.Class:
case TypeKind.TypeParameter:
Compilation compilation = model.Compilation;
INamedTypeSymbol marshalByRefObjectTypeSymbol = compilation.GetTypeByMetadataName("System.MarshalByRefObject");
INamedTypeSymbol executionEngineExceptionTypeSymbol = compilation.GetTypeByMetadataName("System.ExecutionEngineException");
INamedTypeSymbol outOfMemoryExceptionTypeSymbol = compilation.GetTypeByMetadataName("System.OutOfMemoryException");
INamedTypeSymbol stackOverflowExceptionTypeSymbol = compilation.GetTypeByMetadataName("System.StackOverflowException");
INamedTypeSymbol memberInfoTypeSymbol = compilation.GetTypeByMetadataName("System.Reflection.MemberInfo");
INamedTypeSymbol parameterInfoTypeSymbol = compilation.GetTypeByMetadataName("System.Reflection.ParameterInfo");
INamedTypeSymbol threadTypeSymbol = compilation.GetTypeByMetadataName("System.Threading.Thread");
return
type.SpecialType == SpecialType.System_String ||
type.Equals(executionEngineExceptionTypeSymbol) ||
type.Equals(outOfMemoryExceptionTypeSymbol) ||
type.Equals(stackOverflowExceptionTypeSymbol) ||
type.Inherits(marshalByRefObjectTypeSymbol) ||
type.Inherits(memberInfoTypeSymbol) ||
type.Inherits(parameterInfoTypeSymbol) ||
type.Inherits(threadTypeSymbol);
// What about struct types?
default:
return false;
}
}
/// <summary>
/// The Enumerable.Last method will only special case indexable types that implement <see cref="IList{T}" />. Types
/// which implement only <see cref="IReadOnlyList{T}"/> will be treated the same as IEnumerable{T} and go through a
/// full enumeration. This method identifies such types.
///
/// At this point it only identifies <see cref="IReadOnlyList{T}"/> directly but could easily be extended to support
/// any type which has an index and count property.
/// </summary>
private bool IsTypeWithInefficientLinqMethods(SyntaxNodeAnalysisContext context, ExpressionSyntax targetSyntax, ITypeSymbol readonlyListType, ITypeSymbol listType)
{
var targetTypeInfo = context.SemanticModel.GetTypeInfo(targetSyntax);
if (targetTypeInfo.Type == null)
{
return false;
}
var targetType = targetTypeInfo.Type;
// If this type is simply IReadOnlyList<T> then no further checking is needed.
if (targetType.TypeKind == TypeKind.Interface && targetType.OriginalDefinition.Equals(readonlyListType))
{
return true;
}
bool implementsReadOnlyList = false;
bool implementsList = false;
foreach (var current in targetType.AllInterfaces)
{
if (current.OriginalDefinition.Equals(readonlyListType))
{
implementsReadOnlyList = true;
}
if (current.OriginalDefinition.Equals(listType))
{
implementsList = true;
}
}
return implementsReadOnlyList && !implementsList;
}
internal static IPropertySymbol CreatePropertySymbol(
INamedTypeSymbol containingType,
IList<AttributeData> attributes,
Accessibility accessibility,
DeclarationModifiers modifiers,
ITypeSymbol type,
IPropertySymbol explicitInterfaceSymbol,
string name,
IList<IParameterSymbol> parameters,
IMethodSymbol getMethod,
IMethodSymbol setMethod,
bool isIndexer = false,
SyntaxNode initializer = null)
{
var result = new CodeGenerationPropertySymbol(
containingType,
attributes,
accessibility,
modifiers,
type,
explicitInterfaceSymbol,
name,
isIndexer,
parameters,
getMethod,
setMethod);
CodeGenerationPropertyInfo.Attach(result, modifiers.IsNew, modifiers.IsUnsafe, initializer);
return result;
}
/// <summary>
/// Gets the reference to the declaration of the base or interface type as part of the symbol's declaration.
/// </summary>
public static async Task<SyntaxNode> GetBaseOrInterfaceDeclarationReferenceAsync(
this SymbolEditor editor,
ISymbol symbol,
ITypeSymbol baseOrInterfaceType,
CancellationToken cancellationToken = default(CancellationToken))
{
if (baseOrInterfaceType == null)
{
throw new ArgumentNullException(nameof(baseOrInterfaceType));
}
if (baseOrInterfaceType.TypeKind != TypeKind.Error)
{
baseOrInterfaceType = (ITypeSymbol)(await editor.GetCurrentSymbolAsync(baseOrInterfaceType, cancellationToken).ConfigureAwait(false));
}
// look for the base or interface declaration in all declarations of the symbol
var currentDecls = await editor.GetCurrentDeclarationsAsync(symbol, cancellationToken).ConfigureAwait(false);
foreach (var decl in currentDecls)
{
var doc = editor.OriginalSolution.GetDocument(decl.SyntaxTree);
var model = await doc.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var gen = SyntaxGenerator.GetGenerator(doc);
var typeRef = gen.GetBaseAndInterfaceTypes(decl).FirstOrDefault(r => model.GetTypeInfo(r, cancellationToken).Type.Equals(baseOrInterfaceType));
if (typeRef != null)
{
return typeRef;
}
}
return null;
}
/// <summary>
/// Checks if 'symbol' is accessible from within name type 'within', with an optional
/// qualifier of type "throughTypeOpt".
/// </summary>
public static bool IsAccessibleWithin(
this ISymbol symbol,
INamedTypeSymbol within,
ITypeSymbol throughTypeOpt = null)
{
return IsSymbolAccessible(symbol, within, throughTypeOpt, out var failedThroughTypeCheck);
}
private static bool IsDerivedTypeRecursive(ITypeSymbol derivedType, ITypeSymbol type)
{
if (derivedType == type) return true;
if (derivedType.BaseType == null) return false;
return IsDerivedTypeRecursive(derivedType.BaseType, type);
}
private async Task<Document> ReplaceVarWithExplicitType(Document document, SyntaxNode varNode, ITypeSymbol explicitTypeSymbol, CancellationToken cancellationToken)
{
DocumentEditor documentEditor = await DocumentEditor.CreateAsync(document, cancellationToken);
SyntaxNode explicitTypeNode = documentEditor.Generator.TypeExpression(explicitTypeSymbol).WithAdditionalAnnotations(Simplifier.Annotation);
documentEditor.ReplaceNode(varNode, explicitTypeNode);
return documentEditor.GetChangedDocument();
}
private static bool IsRequiredCastForReferenceEqualityComparison(ITypeSymbol outerType, CastExpressionSyntax castExpression, SemanticModel semanticModel, out ExpressionSyntax other)
{
if (outerType.SpecialType == SpecialType.System_Object)
{
var expression = castExpression.WalkUpParentheses();
var parentNode = expression.Parent;
if (parentNode.IsKind(SyntaxKind.EqualsExpression) || parentNode.IsKind(SyntaxKind.NotEqualsExpression))
{
// Reference comparison.
var binaryExpression = (BinaryExpressionSyntax)parentNode;
other = binaryExpression.Left == expression ?
binaryExpression.Right :
binaryExpression.Left;
// Explicit cast not required if we are comparing with type parameter with a class constraint.
var otherType = semanticModel.GetTypeInfo(other).Type;
if (otherType != null && otherType.TypeKind != TypeKind.TypeParameter)
{
return !other.WalkDownParentheses().IsKind(SyntaxKind.CastExpression);
}
}
}
other = null;
return false;
}
internal static string GetType(ITypeSymbol typeSymbol, IEnumerable<string> knownClassNames)
{
string typeName;
var success = GetKnownTypeName(typeSymbol, out typeName);
if (success) { return typeName; }
if (IsCollection(typeSymbol))
{
return GetCollectionTypeName(typeSymbol, knownClassNames);
}
if (typeSymbol.Name == "Task")
{
var namedTypeSymbol = typeSymbol as INamedTypeSymbol;
var typeArgument = namedTypeSymbol?.TypeArguments.FirstOrDefault();
if (typeArgument != null)
{
return GetType(typeArgument, knownClassNames);
}
return Constants.VoidType;
}
if (typeSymbol.Name.Equals("void", StringComparison.OrdinalIgnoreCase))
{
return Constants.VoidType;
}
return knownClassNames.Contains(typeSymbol.Name) ? typeSymbol.Name : Constants.AnyType;
}
public IndexerProperty(
ITypeSymbol type,
bool hasGetter,
bool hasSetter):
base("Item",type,hasGetter, hasSetter)
{
}
protected void FilterTypeSymbol(ITypeSymbol symbol)
{
switch (symbol.TypeKind)
{
case TypeKind.Class:
case TypeKind.Delegate:
case TypeKind.Enum:
case TypeKind.Interface:
{
var qualifiedName = symbol.GetQualifiedName().ToString();
if (!_types.ContainsKey(qualifiedName))
{
_types.Add(qualifiedName, symbol);
}
break;
}
case TypeKind.Dynamic:
case TypeKind.Error:
case TypeKind.TypeParameter:
break;
default:
return;
}
}
public static BinaryOperationKind DeriveAdditionKind(ITypeSymbol type)
{
switch (type.SpecialType)
{
case SpecialType.System_Int32:
case SpecialType.System_Int64:
case SpecialType.System_Int16:
case SpecialType.System_SByte:
return BinaryOperationKind.IntegerAdd;
case SpecialType.System_UInt32:
case SpecialType.System_UInt64:
case SpecialType.System_UInt16:
case SpecialType.System_Byte:
case SpecialType.System_Char:
case SpecialType.System_Boolean:
return BinaryOperationKind.UnsignedAdd;
case SpecialType.System_Single:
case SpecialType.System_Double:
return BinaryOperationKind.FloatingAdd;
case SpecialType.System_Object:
return BinaryOperationKind.ObjectAdd;
}
if (type.TypeKind == TypeKind.Enum)
{
return Semantics.BinaryOperationKind.EnumAdd;
}
return Semantics.BinaryOperationKind.None;
}
public static IEnumerable<ITypeParameterSymbol> Collect(ITypeSymbol typeSymbol)
{
var collector = new TypeParameterCollector();
typeSymbol.Accept(collector);
return collector._typeParameters;
}
private CodeTypeRef(CodeModelState state, object parent, ProjectId projectId, ITypeSymbol typeSymbol)
: base(state)
{
_parentHandle = new ParentHandle<object>(parent);
_projectId = projectId;
_symbolId = typeSymbol.GetSymbolKey();
}
private static MemberDeclarationSyntax GenerateBackingField(ITypeSymbol typeSymbol, string backingFieldName, Workspace workspace)
{
var generator = SyntaxGenerator.GetGenerator(workspace, LanguageNames.CSharp);
SyntaxNode type = generator.TypeExpression(typeSymbol);
FieldDeclarationSyntax fieldDecl = ParseMember($"private _field_Type_ {backingFieldName};") as FieldDeclarationSyntax;
return fieldDecl.ReplaceNode(fieldDecl.Declaration.Type, type.WithAdditionalAnnotations(Simplifier.SpecialTypeAnnotation));
}
public List<IMethodSymbol> GetExtensionMethods(string name, ITypeSymbol type)
{
List<IMethodSymbol> methods;
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (!extensionMethodsByName.TryGetValue(name, out methods))
{
return new List<IMethodSymbol>();
}
var retval = new List<KeyValuePair<IMethodSymbol, int>>();
foreach (var method in methods)
{
var depth = method.Parameters[0].Type?.IsAssignableFrom(type, 0);
if (depth > -1)
{
retval.Add(new KeyValuePair<IMethodSymbol, int>(method, depth.Value));
}
}
return retval.OrderBy(c => c.Key.ContainingAssembly.Equals(this.compilation.Assembly) ? 0 : c.Value + 1).Select(c => c.Key).ToList();
}
private static async Task RenameMethodAccoringToTypeNameAsync(
RefactoringContext context,
MethodDeclarationSyntax methodDeclaration)
{
TypeSyntax returnType = methodDeclaration.ReturnType;
if (returnType?.IsVoid() != false)
{
return;
}
SyntaxToken identifier = methodDeclaration.Identifier;
if (!context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(identifier))
{
return;
}
SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);
IMethodSymbol methodSymbol = semanticModel.GetDeclaredSymbol(methodDeclaration, context.CancellationToken);
ITypeSymbol typeSymbol = GetType(returnType, semanticModel, context.CancellationToken);
if (typeSymbol == null)
{
return;
}
string newName = NameGenerator.CreateName(typeSymbol);
if (string.IsNullOrEmpty(newName))
{
return;
}
newName = "Get" + newName;
if (methodSymbol.IsAsync)
{
newName += "Async";
}
string oldName = identifier.ValueText;
if (string.Equals(oldName, newName, StringComparison.Ordinal))
{
return;
}
if (!await MemberNameGenerator.IsUniqueMemberNameAsync(
newName,
methodSymbol,
context.Solution,
cancellationToken: context.CancellationToken).ConfigureAwait(false))
{
return;
}
context.RegisterRefactoring(
$"Rename '{oldName}' to '{newName}'",
cancellationToken => Renamer.RenameSymbolAsync(context.Solution, methodSymbol, newName, default(OptionSet), cancellationToken),
RefactoringIdentifiers.RenameMethodAccordingToTypeName);
}
protected override void SetAbstractValueForArrayElementInitializer(IArrayCreationOperation arrayCreation, ImmutableArray <AbstractIndex> indices, ITypeSymbol elementType, IOperation initializer, DisposeAbstractValue value)
{
// Escaping from array element assignment is handled in PointsTo analysis.
// We do not need to do anything here.
}
private static void AssertTypeInfo(SemanticModel model, TypeSyntax typeSyntax, ITypeSymbol expectedType)
{
TypeInfo typeInfo = model.GetTypeInfo(typeSyntax);
Assert.Equal(expectedType, typeInfo.Type);
Assert.Equal(expectedType, typeInfo.ConvertedType);
Assert.Equal(typeInfo, ((CSharpSemanticModel)model).GetTypeInfo(typeSyntax));
Assert.True(model.GetConversion(typeSyntax).IsIdentity);
}
public abstract bool TryDetermineReturnType(
SyntaxToken startToken,
SemanticModel semanticModel,
CancellationToken cancellationToken,
out ITypeSymbol returnType,
out SyntaxToken nextToken);
public abstract ISet <ISymbol> FilterOverrides(ISet <ISymbol> members, ITypeSymbol returnType);
public static bool TypeIsString(ITypeSymbol type) => type.Name == "String" && type.ContainingNamespace.Name == "System";
public static bool TypeIsNodePath(ITypeSymbol type) => type.Name == "NodePath" && type.ContainingNamespace.Name == "Godot";
public abstract void ReportInvalidNamedArgument(DiagnosticBag diagnostics, SyntaxNode attributeSyntax, int namedArgumentIndex, ITypeSymbol attributeClass, string parameterName);
private static void CheckTypes(SyntaxNodeAnalysisContext context, ITypeSymbol oldType, ITypeSymbol newType, Location location = null)
{
if (newType.IsLite() && oldType.IsEntity())
{
context.ReportDiagnostic(Diagnostic.Create(RuleCastToLiteEntity1, location ?? context.Node.GetLocation()));
}
else if (newType.IsEntity() && oldType.IsLite())
{
context.ReportDiagnostic(Diagnostic.Create(RuleCastToEntityEntity, location ?? context.Node.GetLocation()));
}
}
public static bool HasOnlyBlittableFields(this ITypeSymbol type) => HasOnlyBlittableFields(type, ImmutableHashSet.Create <ITypeSymbol>(SymbolEqualityComparer.Default));
protected override bool CanBeConvertedTo(ExpressionSyntax expression, ITypeSymbol type, SemanticModel semanticModel)
{
var conversion = semanticModel.ClassifyConversion(expression, type);
return(conversion.Exists && (conversion.IsIdentity || conversion.IsImplicit));
}
public CompositeMethodNames AddComponent(ITypeSymbol symbol)
{
_symbols.Add(symbol);
return(CompositeMethodNames.AppendDefault($"Member_{symbol}"));
}
private TypeInfo(ITypeSymbol type, int startIndex)
{
this.Type = type;
this.StartIndex = startIndex;
}
private static void CheckPattern(SyntaxNodeAnalysisContext context, ITypeSymbol oldType, PatternSyntax syntax)
{
switch (syntax)
{
case BinaryPatternSyntax bp:
CheckPattern(context, oldType, bp.Left);
CheckPattern(context, oldType, bp.Right);
break;
case ConstantPatternSyntax cp:
CheckTypes(context, oldType, context.SemanticModel.GetTypeInfo(cp.Expression).Type);
break;
case DeclarationPatternSyntax dp:
CheckTypes(context, oldType, context.SemanticModel.GetTypeInfo(dp.Type).Type, dp.GetLocation());
break;
case DiscardPatternSyntax: break;
case ParenthesizedPatternSyntax p:
CheckPattern(context, oldType, p.Pattern);
break;
case RecursivePatternSyntax rp:
ITypeSymbol ti;
if (rp.Type != null)
{
ti = context.SemanticModel.GetTypeInfo(rp.Type).Type;
CheckTypes(context, oldType, ti, rp.GetLocation());
}
else
{
ti = oldType;
}
if (rp.PropertyPatternClause != null)
{
foreach (var sp in rp.PropertyPatternClause.Subpatterns)
{
var member = ti.GetMembers(sp.NameColon.Name.Identifier.ToString()).Only();
if (member is IPropertySymbol ps)
{
CheckPattern(context, ps.Type, sp.Pattern);
}
else if (member is IFieldSymbol fi)
{
CheckPattern(context, fi.Type, sp.Pattern);
}
}
}
break;
case TypePatternSyntax tp:
CheckTypes(context, oldType, context.SemanticModel.GetTypeInfo(tp.Type).Type, tp.GetLocation());
break;
case UnaryPatternSyntax up:
CheckPattern(context, oldType, up.Pattern);
break;
case VarPatternSyntax: break;
default:
break;
}
}
internal abstract Cci.ITypeReference Translate(ITypeSymbol symbol, SyntaxNode syntaxOpt, DiagnosticBag diagnostics);
public static TypeInfo Create(ITypeSymbol type)
{
Debug.Assert(type != null);
return(new TypeInfo(type, -1));
}
internal sealed override Cci.ITypeReference EncTranslateType(ITypeSymbol type, DiagnosticBag diagnostics)
{
return(EncTranslateLocalVariableType((TTypeSymbol)type, diagnostics));
}
internal static ExpressionSyntax?ShouldCast(InvocationExpressionSyntax invocation, ITypeSymbol returnType, SemanticModel semanticModel)
{
if (returnType != KnownSymbol.Object &&
semanticModel.IsAccessible(invocation.SpanStart, returnType))
{
return(Expression(invocation));
public static TDeclarationNode UpdateDeclarationType <TDeclarationNode>(TDeclarationNode destination, Workspace workspace, ITypeSymbol newType, CodeGenerationOptions options = null, CancellationToken cancellationToken = default) where TDeclarationNode : SyntaxNode
{
return(GetCodeGenerationService(workspace, destination.Language).UpdateDeclarationType(destination, newType, options ?? new CodeGenerationOptions(reuseSyntax: true), cancellationToken));
}
internal sealed override Cci.ITypeReference Translate(ITypeSymbol symbol, SyntaxNode syntaxNodeOpt, DiagnosticBag diagnostics)
{
return(Translate((TTypeSymbol)symbol, (TSyntaxNode)syntaxNodeOpt, diagnostics));
}
private static bool HasSerializableAttribute(ITypeSymbol typeSymbol) => typeSymbol.GetAttributes() .Any(a => a.AttributeClass.Is(KnownType.System_SerializableAttribute));
internal abstract Cci.ITypeReference EncTranslateType(ITypeSymbol type, DiagnosticBag diagnostics);
internal static ITypeSymbol GetNullableUnderlyingType(ITypeSymbol type)
{
Debug.Assert(IsNullableType(type));
return(((INamedTypeSymbol)type).TypeArguments[0]);
}
private static bool IsOrImplementsISerializable(ITypeSymbol typeSymbol) => typeSymbol.Is(KnownType.System_Runtime_Serialization_ISerializable) || typeSymbol.Implements(KnownType.System_Runtime_Serialization_ISerializable);
protected override bool IsImplicitReferenceConversion(Compilation compilation, ITypeSymbol sourceType, ITypeSymbol targetType)
{
var conversion = compilation.ClassifyConversion(sourceType, targetType);
return(conversion.IsImplicit && conversion.IsReference);
}
private static bool ImplementsISerializable(ITypeSymbol typeSymbol) => typeSymbol != null && typeSymbol.IsPubliclyAccessible() && typeSymbol.AllInterfaces.Any(IsOrImplementsISerializable);
public static IEnumerable <IEventSymbol> GetEventsOnTypeHierarchy(this ITypeSymbol thisType, Func <IEventSymbol, bool>?filter, BindingFlags?bindingFlags = BindingFlags.Default)
{
ITypeSymbol?type = thisType;
bool onBaseType = false;
while (type != null)
{
foreach (var @event in type.GetMembers().OfType <IEventSymbol> ())
{
// Ignore private properties on a base type - those are completely ignored by reflection
// (anything private on the base type is not visible via the derived type)
// Note that properties themselves are not actually private, their accessors are
if (onBaseType &&
(@event.AddMethod == null || @event.AddMethod.DeclaredAccessibility == Accessibility.Private) &&
(@event.RemoveMethod == null || @event.RemoveMethod.DeclaredAccessibility == Accessibility.Private))
{
continue;
}
if (filter != null && !filter(@event))
{
continue;
}
if ((bindingFlags & (BindingFlags.Instance | BindingFlags.Static)) == BindingFlags.Static)
{
if ((@event.AddMethod != null) && [email protected])
{
continue;
}
if ((@event.RemoveMethod != null) && [email protected])
{
continue;
}
}
if ((bindingFlags & (BindingFlags.Instance | BindingFlags.Static)) == BindingFlags.Instance)
{
if ((@event.AddMethod != null) && @event.AddMethod.IsStatic)
{
continue;
}
if ((@event.RemoveMethod != null) && @event.RemoveMethod.IsStatic)
{
continue;
}
}
if ((bindingFlags & (BindingFlags.Public | BindingFlags.NonPublic)) == BindingFlags.Public)
{
if ((@event.AddMethod == null || (@event.AddMethod.DeclaredAccessibility != Accessibility.Public)) &&
(@event.RemoveMethod == null || (@event.RemoveMethod.DeclaredAccessibility != Accessibility.Public)))
{
continue;
}
}
if ((bindingFlags & (BindingFlags.Public | BindingFlags.NonPublic)) == BindingFlags.NonPublic)
{
if ((@event.AddMethod != null) && @event.AddMethod.DeclaredAccessibility == Accessibility.Public)
{
continue;
}
if ((@event.RemoveMethod != null) && @event.RemoveMethod.DeclaredAccessibility == Accessibility.Public)
{
continue;
}
}
yield return(@event);
}
if ((bindingFlags & BindingFlags.DeclaredOnly) == BindingFlags.DeclaredOnly)
{
yield break;
}
type = type.BaseType;
onBaseType = true;
}
}
public static string ToDisplayStringNullable(this ITypeSymbol typeSymbol) => typeSymbol.ToDisplayString(ToNullableFlowState(typeSymbol.NullableAnnotation));
public static IEnumerable <IMethodSymbol> GetMethodsOnTypeHierarchy(this ITypeSymbol thisType, Func <IMethodSymbol, bool>?filter, BindingFlags?bindingFlags = null)
{
ITypeSymbol?type = thisType;
bool onBaseType = false;
while (type != null)
{
foreach (var method in type.GetMembers().OfType <IMethodSymbol> ())
{
// Ignore constructors as those are not considered methods from a reflection's point of view
if (method.MethodKind == MethodKind.Constructor)
{
continue;
}
// Ignore private methods on a base type - those are completely ignored by reflection
// (anything private on the base type is not visible via the derived type)
if (onBaseType && method.DeclaredAccessibility == Accessibility.Private)
{
continue;
}
// Note that special methods like property getter/setter, event adder/remover will still get through and will be marked.
// This is intentional as reflection treats these as methods as well.
if (filter != null && !filter(method))
{
continue;
}
if ((bindingFlags & (BindingFlags.Instance | BindingFlags.Static)) == BindingFlags.Static && !method.IsStatic)
{
continue;
}
if ((bindingFlags & (BindingFlags.Instance | BindingFlags.Static)) == BindingFlags.Instance && method.IsStatic)
{
continue;
}
if ((bindingFlags & (BindingFlags.Public | BindingFlags.NonPublic)) == BindingFlags.Public && method.DeclaredAccessibility != Accessibility.Public)
{
continue;
}
if ((bindingFlags & (BindingFlags.Public | BindingFlags.NonPublic)) == BindingFlags.NonPublic && method.DeclaredAccessibility == Accessibility.Public)
{
continue;
}
yield return(method);
}
if ((bindingFlags & BindingFlags.DeclaredOnly) == BindingFlags.DeclaredOnly)
{
yield break;
}
type = type.BaseType;
onBaseType = true;
}
}
// Can not pass SymbolEqualityComparer to HashSet since the collection type is ITypeSymbol and not ISymbol.
#pragma warning disable RS1024
// declaredOnly will cause this to retrieve only members of the type, not of its base types. This includes interfaces recursively
// required by this type (but not members of these interfaces, or interfaces required only by base types).
public static void GetAllOnType(this ITypeSymbol type, bool declaredOnly, List <ISymbol> members) => GetAllOnType(type, declaredOnly, members, new HashSet <ITypeSymbol> (SymbolEqualityComparer.Default));
