private void HandleContainerElement( IHighlightingConsumer consumer, [CanBeNull] IAttributesOwner element, [CanBeNull] ITypeUsage typeNodeForHighlighting) { if (typeNodeForHighlighting != null && IsItemNotNull(element)) consumer.AddHighlighting(new StaticNullabilityItemTypeHighlighting(typeNodeForHighlighting, "[ItemNotNull]")); }
public MemberGenerationContext( [NotNull] ITypeDeclaration typeDeclaration, [CanBeNull] IModifiersList modifiersList, [CanBeNull] ITypeUsage expectedReturnTypeUsage, [NotNull] TextLookupRanges memberReplaceRanges) { TypeDeclaration = typeDeclaration; PsiModule = typeDeclaration.GetPsiModule(); ModifiersList = modifiersList; MemberReplaceRanges = memberReplaceRanges; ExpectedAccessRights = ModifiersUtil.GetAccessRightsModifiers(modifiersList); if (expectedReturnTypeUsage != null) { ExpectedReturnType = CSharpTypeFactory.CreateType(expectedReturnTypeUsage); } }
/// <summary> /// Get return type. /// </summary> /// <param name="declaration"> /// The declaration. /// </param> /// <returns> /// An IType for the return type. /// </returns> public static IType GetReturnType(this IMethodDeclaration declaration) { IMethodDeclaration methodDeclarationNode = declaration; if (methodDeclarationNode == null) { return(null); } ITypeUsage typeUsage = methodDeclarationNode.TypeUsage; if (typeUsage == null) { return(null); } return(CSharpTypeFactory.CreateType(typeUsage)); }
private static bool HasExistingReturnType(ITreeNode identifier, [CanBeNull] out ITypeUsage typeUsage) { // Only return true if the user has explicitly typed a return type. // If they haven't, then our completion identifier will be parsed // as a type usage. Return the usage any way, we need it elsewhere. typeUsage = identifier.GetContainingNode <ITypeUsage>(); if (typeUsage == null) { typeUsage = identifier.GetPreviousMeaningfulSibling() as ITypeUsage; if (typeUsage == null) { var fieldDeclaration = identifier.GetContainingNode <IFieldDeclaration>(); typeUsage = fieldDeclaration?.GetPreviousMeaningfulSibling() as ITypeUsage; } return(typeUsage != null); } return(false); }
public override void VisitClassDeclaration(IClassDeclaration classDeclarationParam, IHighlightingConsumer context) { base.VisitClassDeclaration(classDeclarationParam, context); if (!classDeclarationParam.IsSynthetic()) { return; } if (!T4CSharpIntermediateConverterBase.GeneratedClassNameString.Equals( classDeclarationParam.DeclaredName, StringComparison.Ordinal)) { return; } ITypeUsage baseClassNode = classDeclarationParam.SuperTypeUsageNodes.FirstOrDefault(); if (baseClassNode?.IsVisibleInDocument() != true) { return; } if (T4CSharpIntermediateConverterBase.GeneratedBaseClassNameString.Equals( baseClassNode.GetText(), StringComparison.Ordinal)) { return; } ITypeElement baseClass = classDeclarationParam.SuperTypes.FirstOrDefault()?.GetTypeElement(); if (baseClass == null) { return; } if (HasTransformTextMethod(baseClass)) { return; } context.AddHighlighting(new MissingTransformTextMethodError(baseClassNode, baseClass)); }
public ExpressionKind EatCastType([NotNull] ISnapshot snapshot, [NotNull] ITypeUsage typeUsage) { if (snapshot == null) { throw new ArgumentNullException("snapshot"); } if (typeUsage == null) { throw new ArgumentNullException("typeUsage"); } if (typeUsage is IDynamicTypeUsage) { return(ExpressionKind.StubCandidate); } if (typeUsage is IPredefinedTypeUsage) { return(ExpressionKind.StubCandidate); } if (typeUsage is IUserTypeUsage) { var userTypeUsage = typeUsage as IUserTypeUsage; var classType = _eatExpressionHelper.GetUserTypeUsageClass(userTypeUsage); if (snapshot.IsInTestScope(classType.Module.Name)) { return(ExpressionKind.Target); } if (snapshot.IsInTestProject(classType.Module.Name)) { return(ExpressionKind.Mock); } } return(ExpressionKind.StubCandidate); }
/// <summary> /// Swap generic declaration to built in type. /// </summary> /// <param name="node"> /// The node to process. /// </param> private static void SwapGenericDeclarationToBuiltInType(ITypeArgumentList node) { IPsiModule project = node.GetPsiModule(); IList <ITypeUsage> typeUsageNodes = node.TypeArgumentNodes; IList <IType> types = node.TypeArguments; using (WriteLockCookie.Create(true)) { for (int i = 0; i < typeUsageNodes.Count; i++) { if (!types[i].IsUnknown) { ITypeUsage newTypeUsageNode = CSharpElementFactory.GetInstance(project).CreateTypeUsageNode(types[i]); using (WriteLockCookie.Create(true)) { ModificationUtil.ReplaceChild(typeUsageNodes[i], newTypeUsageNode); } } } } }
public ITypeUsage SetTypeUsage(ITypeUsage param) { return(_fieldDeclaration.SetTypeUsage(param)); }
internal AvoidAsyncVoidHighlighting([NotNull] string message, [NotNull] ILocalFunctionDeclaration localFunctionDeclaration) : base(message) { Declaration = localFunctionDeclaration; typeUsage = localFunctionDeclaration.TypeUsage; }
internal AvoidAsyncVoidHighlighting([NotNull] string message, [NotNull] IMethodDeclaration methodDeclaration) : base(message) { Declaration = methodDeclaration; typeUsage = methodDeclaration.TypeUsage; }