public static string GetQualifiedName([NotNull] this IReferenceName referenceName)
{
var qualifier = referenceName.Qualifier;
var shortName = referenceName.ShortName;
return(qualifier == null
? shortName
: qualifier.QualifiedName + "." + shortName);
}
private static string GetNamespaceFromUsingDirective([NotNull] ITreeNode usingDirective)
{
IReferenceName namespaceNode = (usingDirective as IUsingDirective).GetUsedNamespaceNode();
if (namespaceNode == null)
{
throw new FailPsiTransactionException("Cannot create namespace alias.");
}
return(namespaceNode.QualifiedName);
}
private void EndNamespaceQualifier([CanBeNull] IReferenceName referenceName)
{
if (referenceName == null)
{
return;
}
EndNamespaceQualifier(referenceName.Qualifier);
Builder.EndPart();
}
private void StartNamespaceQualifier([CanBeNull] IReferenceName referenceName)
{
if (referenceName == null)
{
return;
}
StartNamespaceQualifier(referenceName.Qualifier);
var qualifierName = Builder.Intern(referenceName.ShortName);
Builder.StartPart(new QualifiedNamespacePart(referenceName.Identifier.GetTreeStartOffset(), qualifierName));
}
public static IReferenceName GetFirstQualifier([NotNull] this IReferenceName referenceName)
{
var qualifier = referenceName.Qualifier;
while (qualifier != null)
{
referenceName = qualifier;
qualifier = referenceName.Qualifier;
}
return(referenceName);
}
public static IList <string> GetNames([CanBeNull] this IReferenceName referenceName)
{
var result = new List <string>();
while (referenceName != null)
{
var shortName = referenceName.ShortName;
if (shortName.IsEmpty() || shortName == SharedImplUtil.MISSING_DECLARATION_NAME)
{
break;
}
result.Insert(0, shortName);
referenceName = referenceName.Qualifier;
}
return(result);
}
private static (NamedElementKinds?, IReferenceName) GetKindAndDeclaration(ILocalVariableDeclaration localVarDeclaration, IFieldDeclaration fieldDeclaration,
IRegularParameterDeclaration regularParameterDeclaration)
{
NamedElementKinds?kind = null;
IReferenceName scalarTypeName = null;
if (localVarDeclaration != null)
{
kind = NamedElementKinds.Locals;
scalarTypeName = localVarDeclaration.GetScalarTypename();
}
else if (fieldDeclaration != null)
{
scalarTypeName = fieldDeclaration.GetScalarTypename();
var isPrivate = fieldDeclaration.GetAccessRights().Has(AccessRights.PRIVATE);
if (fieldDeclaration.IsStatic)
{
if (isPrivate)
{
kind = fieldDeclaration.IsReadonly ? NamedElementKinds.PrivateStaticReadonly : NamedElementKinds.PrivateStaticFields;
}
else
{
kind = fieldDeclaration.IsReadonly ? NamedElementKinds.StaticReadonly : NamedElementKinds.PublicFields;
}
}
else
{
kind = isPrivate ? NamedElementKinds.PrivateInstanceFields : NamedElementKinds.PublicFields;
}
}
else if (regularParameterDeclaration != null)
{
kind = NamedElementKinds.Parameters;
scalarTypeName = regularParameterDeclaration.ScalarTypeName;
}
return(kind, scalarTypeName);
}
public override bool IsAvailable(IDataContext context)
{
// check text control
if (!base.IsAvailable(context))
return false;
var sourceTokenAtCaret = JetBrains.ReSharper.Feature.Services.Util.TextControlToPsi.GetSourceTokenAtCaret(Solution, TextControl);
var usingDirective = sourceTokenAtCaret.FindParent<IUsingDirective>();
if (usingDirective == null || usingDirective.ImportedSymbolName == null)
return false;
// Does not support Linq
if (_ignoredNamespaces.Contains(usingDirective.ImportedSymbolName.QualifiedName, StringComparer.Ordinal))
return false;
ImportedNamespacePointer = usingDirective.ImportedSymbolName;
return true;
}
public static IReferenceName GetScalarTypename(this IDeclaration fieldDeclaration)
{
CompositeElement compositeElement = (CompositeElement)fieldDeclaration;
if (!(compositeElement.parent is IMultipleFieldDeclaration) || compositeElement.parent.GetChildRole((TreeElement)compositeElement) != (short)104)
{
return((IReferenceName)null);
}
CompositeElement parent = compositeElement.parent;
IReferenceName referenceName = (IReferenceName)null;
CompositeElement childByRole1 = (CompositeElement)parent.FindChildByRole((short)19);
if (childByRole1 != null)
{
TreeElement childByRole2 = childByRole1.FindChildByRole((short)19);
if (childByRole2 != null)
{
referenceName = (IReferenceName)childByRole2;
}
}
return(referenceName);
}
private static bool IsInsideSignatureWhereTypeUsageExpected([NotNull] IMethodDeclaration methodDeclaration, [NotNull] IReferenceName referenceName)
{
// require method declaration to at least have a name identifier
if (methodDeclaration.NameIdentifier == null)
{
return(false);
}
var returnTypeUsage = methodDeclaration.TypeUsage;
if (returnTypeUsage != null) // THere M()
{
if (returnTypeUsage.Contains(referenceName))
{
return(true);
}
}
if (methodDeclaration.LPar != null) // void M(int id, THere t, string s)
{
foreach (var parameterDeclaration in methodDeclaration.ParameterDeclarationsEnumerable)
{
if (parameterDeclaration.Contains(referenceName))
{
return(true);
}
}
}
if (methodDeclaration.RPar != null) // void M<T>() where T : THere
{
foreach (var constraintsClause in methodDeclaration.TypeParameterConstraintsClausesEnumerable)
{
if (constraintsClause.Contains(referenceName))
{
return(true);
}
}
}
return(false);
}
public ReferenceNamePostfixTemplateContext([NotNull] IReferenceName reference,
[NotNull] ICSharpExpression expression,
[NotNull] PostfixExecutionContext executionContext)
: base(reference, expression, executionContext)
{
}
public IReferenceName SetScalarTypeName(IReferenceName param)
{
return(_fieldDeclaration.SetScalarTypeName(param));
}
public static IReferenceName GetFirstName([NotNull] this IReferenceName referenceName) => referenceName.GetFirstQualifier() ?? referenceName;
public ReferenceNameCompiler(IReferenceName node, AbstractILCompilerParams myParams) : base(myParams)
{
myReferenceName = node;
}
public static IReferenceName GetByQualifier([CanBeNull] IReferenceName param) => (IReferenceName)ExpressionReferenceNameNavigator.GetByQualifier(param as IExpressionReferenceName) ?? TypeReferenceNameNavigator.GetByQualifier(param as ITypeReferenceName);
private static void AddToCollector(CSharpCodeCompletionContext context, IItemsCollector collector, IReferenceName referenceName, NamedElementKinds elementKinds, ScopeKind localSelfScoped)
{
var referenceNameResolveResult = referenceName.Reference.Resolve();
var referencedElementAsString = referenceNameResolveResult.DeclaredElement.ConvertToString();
if (referencedElementAsString == "Class:Moq.Mock`1")
{
var typeArgumentList = referenceName.TypeArgumentList;
var typeArguments = typeArgumentList.TypeArguments;
if (typeArguments.Count == 1)
{
var typeArgument = typeArguments[0];
var scalarType = typeArgument.GetScalarType();
if (scalarType == null)
{
return;
}
var genericTypeResolveResult = scalarType.Resolve();
var namingManager = typeArgument.GetPsiServices().Naming;
var suggestionOptions = new SuggestionOptions();
string proposedName;
if (genericTypeResolveResult.IsEmpty)
{
proposedName = namingManager.Suggestion.GetDerivedName(typeArgument.GetPresentableName(CSharpLanguage.Instance), elementKinds, localSelfScoped,
CSharpLanguage.Instance, suggestionOptions, referenceName.GetSourceFile());
}
else
{
proposedName = namingManager.Suggestion.GetDerivedName(genericTypeResolveResult.DeclaredElement, elementKinds, localSelfScoped,
CSharpLanguage.Instance, suggestionOptions, referenceName.GetSourceFile());
}
var textLookupItem = new TextLookupItem(proposedName);
textLookupItem.InitializeRanges(context.CompletionRanges, context.BasicContext);
textLookupItem.SetTopPriority();
collector.Add(textLookupItem);
var textLookupItem2 = new TextLookupItem(proposedName + "Mock");
textLookupItem2.InitializeRanges(context.CompletionRanges, context.BasicContext);
textLookupItem2.SetTopPriority();
collector.Add(textLookupItem2);
}
}
}
