private void AppendTypeElement([NotNull] ITypeElement typeElement, [NotNull] ISubstitution substitution, QualifierDisplays expectedQualifierDisplay, Context context) { if (!(typeElement is ITypeParameter) && (context.Options.ShowQualifiers & expectedQualifierDisplay) != QualifierDisplays.None) { INamespace containingNamespace = typeElement.GetContainingNamespace(); AppendNamespace(containingNamespace); if (!containingNamespace.IsRootNamespace) { AppendText(".", _highlighterIdProvider.Operator); } ITypeElement containingType = typeElement.GetContainingType(); if (containingType != null && !(typeElement is IDelegate && context.Options.FormatDelegatesAsLambdas)) { AppendDeclaredType(TypeFactory.CreateType(containingType, substitution), QualifierDisplays.None, context); AppendText(".", _highlighterIdProvider.Operator); } } var deleg = typeElement as IDelegate; if (deleg != null && context.Options.FormatDelegatesAsLambdas && expectedQualifierDisplay == QualifierDisplays.Parameters) { AppendParameters(deleg.InvokeMethod, substitution, false, context); AppendText(" => ", _highlighterIdProvider.Operator); AppendTypeWithoutModule(substitution.Apply(deleg.InvokeMethod.ReturnType), expectedQualifierDisplay, context); return; } string highlighterId = _highlighterIdProvider.GetForTypeElement(typeElement); AppendText(FormatShortName(typeElement.ShortName), highlighterId); AppendTypeParameters(typeElement, substitution, context); }
private void AppendTypeElement([NotNull] ITypeElement typeElement, [NotNull] ISubstitution substitution, NamespaceDisplays expectedNamespaceDisplay) { if (!(typeElement is ITypeParameter)) { if ((_options.ShowNamespaces & expectedNamespaceDisplay) != NamespaceDisplays.None) { AppendNamespace(typeElement.GetContainingNamespace()); AppendText(".", VsHighlightingAttributeIds.Operator); } ITypeElement containingType = typeElement.GetContainingType(); if (containingType != null && !(typeElement is IDelegate && _options.FormatDelegatesAsLambdas)) { AppendDeclaredType(TypeFactory.CreateType(containingType, substitution), NamespaceDisplays.None); AppendText(".", VsHighlightingAttributeIds.Operator); } } var deleg = typeElement as IDelegate; if (deleg != null && _options.FormatDelegatesAsLambdas && expectedNamespaceDisplay == NamespaceDisplays.Parameters) { AppendParameters(deleg.InvokeMethod, substitution, false); AppendText(" => ", VsHighlightingAttributeIds.Operator); AppendType(substitution.Apply(deleg.InvokeMethod.ReturnType), expectedNamespaceDisplay); return; } string attributeId = _options.UseReSharperColors ? HighlightingAttributeIds.GetHighlightAttributeForTypeElement(typeElement) : VsHighlightingAttributeIds.GetForTypeElement(typeElement); AppendText(FormatShortName(typeElement.ShortName), attributeId); AppendTypeParameters(typeElement, substitution); }
public static Guid?GetGuidFor(MetaFileGuidCache metaFileGuidCache, ITypeElement typeElement) { var sourceFile = typeElement.GetDeclarations().FirstOrDefault()?.GetSourceFile(); if (sourceFile == null || !sourceFile.IsValid()) { return(null); } if (typeElement.TypeParameters.Count != 0) { return(null); } if (typeElement.GetContainingType() != null) { return(null); } if (!typeElement.ShortName.Equals(sourceFile.GetLocation().NameWithoutExtension)) { return(null); } var guid = metaFileGuidCache.GetAssetGuid(sourceFile); return(guid); }
public static Guid?GetGuidFor(MetaFileGuidCache metaFileGuidCache, ITypeElement typeElement) { // partial classes var declarations = typeElement.GetDeclarations(); foreach (var declaration in declarations) { var sourceFile = declaration.GetSourceFile(); if (sourceFile == null || !sourceFile.IsValid()) { continue; } if (!typeElement.ShortName.Equals(sourceFile.GetLocation().NameWithoutExtension)) { continue; } if (typeElement.TypeParameters.Count != 0) { continue; } if (typeElement.GetContainingType() != null) { continue; } var guid = metaFileGuidCache.GetAssetGuid(sourceFile); return(guid); } return(null); }
private int GetGenericArgumentsCount(ITypeElement typeElement) { int count = 0; while (typeElement != null) { count += typeElement.TypeParameters.Count; typeElement = typeElement.GetContainingType(); } return(count); }
private static string GetAssemblyQualifiedName(this ITypeElement type, ISubstitution substitution, IDictionary <DeclaredElementInstance, IName> seenElements) { if (type == null) { return(Names.UnknownType.Identifier); } var clrTypeName = type.GetClrName(); var containingModule = type.Module.ContainingProjectModule; Asserts.NotNull(containingModule, "module is null"); var moduleName = containingModule.GetQualifiedName(); var typeParameters = type.GetTypeParametersList(substitution, seenElements); string myName; var parent = type.GetContainingType(); var myFullName = clrTypeName.FullName; if (parent != null) { var parentName = parent.GetName <ITypeName>(substitution); // including the generic `N ticks var parentFullName = parentName.FullName; // shortName does not include the generic `N ticks, so we have to find it in the fullname... var startOfShortName = myFullName.LastIndexOf("+", StringComparison.Ordinal) + 1; // ... and ignore the leading part var fullShortName = myFullName.Substring(startOfShortName); myName = string.Format("{0}+{1}", parentFullName, fullShortName); } else { myName = myFullName; } return(string.Format( "{0}{1}, {2}", myName, typeParameters, moduleName)); }
private StaticDeclaredTypeWrapper MakeDeclaredType(ITypeElement typeElementHandle, ISubstitution substitutionHandle) { if (typeElementHandle is ITypeParameter) throw new ArgumentException("This method should never be called with a generic parameter as input.", "typeElementHandle"); ITypeElement declaringTypeElementHandle = typeElementHandle.GetContainingType(); StaticDeclaredTypeWrapper type; if (declaringTypeElementHandle != null) { StaticDeclaredTypeWrapper declaringType = MakeDeclaredType(declaringTypeElementHandle, substitutionHandle); type = new StaticDeclaredTypeWrapper(this, typeElementHandle, declaringType, declaringType.Substitution); } else { type = new StaticDeclaredTypeWrapper(this, typeElementHandle, null, StaticTypeSubstitution.Empty); } #if ! RESHARPER_50_OR_NEWER var typeParameterHandles = new List<ITypeParameter>(typeElementHandle.AllTypeParameters); #else var typeParameterHandles = new List<ITypeParameter>(typeElementHandle.GetAllTypeParameters()); #endif #if RESHARPER_31 || RESHARPER_40 || RESHARPER_41 if (substitutionHandle.IsIdempotent(typeParameterHandles)) #else if (substitutionHandle.IsIdempotentAll(typeParameterHandles)) #endif { return type; } ITypeInfo[] genericArguments = GenericCollectionUtils.ConvertAllToArray<ITypeParameter, ITypeInfo>(typeParameterHandles, delegate(ITypeParameter typeParameterHandle) { IType substitutedType = substitutionHandle.Apply(typeParameterHandle); if (substitutedType.IsUnknown) return MakeGenericParameterType(typeParameterHandle); return MakeType(substitutedType); }); return type.MakeGenericType(genericArguments); }
private void BuildTypeGenericParameters(StaticDeclaredTypeWrapper ownerType, ITypeElement typeHandle, List<StaticGenericParameterWrapper> genericParameters) { ITypeElement declaringType = typeHandle.GetContainingType(); if (declaringType != null) BuildTypeGenericParameters(ownerType, declaringType, genericParameters); foreach (ITypeParameter parameterHandle in typeHandle.TypeParameters) genericParameters.Add(StaticGenericParameterWrapper.CreateGenericTypeParameter(this, parameterHandle, ownerType)); }
private XunitTestClassElement GetOrCreateClassElement(ITypeElement testClass, IProject projectElement, ProjectModelElementEnvoy projectEnvoy) { ITypeElement containingType = testClass.GetContainingType(); XunitTestClassElement parent = null; if (containingType != null) parent = GetParent(containingType); return factory.GetOrCreateClassElement(testClass.GetClrName(), projectElement, projectEnvoy, parent); }
private static void CheckMethodGroup( [NotNull] IReferenceExpression methodReference, [NotNull] IMethod method, [NotNull] IHighlightingConsumer consumer) { string message = null; var methodType = method.GetContainingType(); if (methodType is IInterface) { message = string.Format("from interface '{0}' method", methodType.ShortName); consumer.AddHighlighting( new SlowDelegateCreationHighlighting(methodReference, message), methodReference.GetExpressionRange()); return; } // there is not lags if method is instance method if (!method.IsStatic && methodReference.QualifierExpression != null && methodReference.QualifierExpression.IsClassifiedAsVariable) { return; } var substitution = methodReference.Reference.Resolve().Result.Substitution; var typeParameters = new JetHashSet <ITypeParameter>(); // collect all the type parameters from the method reference if (!substitution.IsEmpty()) { foreach (var typeParameter in substitution.Domain) { var substitutionType = substitution.Apply(typeParameter); var targs = TypeParametersCollectingVisitor.Collect(substitutionType); typeParameters.UnionWith(targs); } } // get the delegate creation owner type, if member is not static var delegateCreationMember = methodReference.GetContainingTypeMemberDeclaration(); if (delegateCreationMember == null || delegateCreationMember.DeclaredElement == null) { return; } ITypeElement delegateCreationOwnerType = null; if (!delegateCreationMember.DeclaredElement.IsStatic) { delegateCreationOwnerType = delegateCreationMember.DeclaredElement.GetContainingType(); } // look for implicit qualification with the type parameters ITypeElement lastType = null; for (var qualifier = methodReference; qualifier != null; qualifier = qualifier.QualifierExpression as IReferenceExpression) { if (qualifier.IsClassifiedAsVariable) { lastType = null; break; } var resolveResult = qualifier.Reference.Resolve(); lastType = resolveResult.DeclaredElement as ITypeElement; } if (lastType != null) { for (var hidden = lastType.GetContainingType(); hidden != null; hidden = hidden.GetContainingType()) { if (hidden.TypeParameters.Count > 0) { foreach (var typeParameter in hidden.TypeParameters) { typeParameters.Add(typeParameter); } } } } foreach (var parameter in typeParameters) { if (parameter.IsValueType) { continue; } if (delegateCreationOwnerType != null && delegateCreationOwnerType.TypeParameters.Contains(parameter)) { continue; } if (message == null) { message = "method group parametrized with type parameter "; } if (parameter.OwnerType != null) { message += string.Format("'{0}' of type '{1}'", parameter.ShortName, parameter.OwnerType.ShortName); } else if (parameter.OwnerMethod != null) { message += string.Format("'{0}' of method '{1}'", parameter.ShortName, parameter.OwnerMethod.ShortName); } } if (message != null) { consumer.AddHighlighting( new SlowDelegateCreationHighlighting(methodReference, message), methodReference.GetExpressionRange()); } }