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;
}
