public void ProcessMembers(CSharpCodeCompletionContext context, GroupedItemsCollector collector, ISymbolTable symbols)
{
symbols.ForAllSymbolInfos(symbol =>
{
var member = symbol.GetDeclaredElement() as ITypeMember;
if (member != null && member.GetElementType() == ExpectedMemberType)
{
string nameArgument = string.Format("\"{0}\"", symbol.ShortName);
var declaredElementInstance = new DeclaredElementInstance <ITypeMember>((ITypeMember)symbol.GetDeclaredElement(),
symbol.GetSubstitution());
if (!IncludeSymbol(declaredElementInstance))
{
return;
}
IList <string> arguments = new List <string>();
if (IncludeNameArgument)
{
arguments.Add(nameArgument);
}
if (NeedsBindingFlags(member))
{
arguments.Add(GetExpectedBindingFlags(member).GetFullString());
}
if (ShouldProvideMemberSpecificArguments(symbols.GetSymbolInfos(member.ShortName))) //additional arguments needs to be provided
{
ProvideMemberSpecificArguments(declaredElementInstance, arguments, NeedsBindingFlags(member));
}
ReflectionMemberLookupItem lookupItem;
if (member is IMethod && ((IMethod)member).TypeParameters.Count != 0)
{
lookupItem = new ReflectionGenericMethodLookupItem(symbol.ShortName,
declaredElementInstance,
context,
context.BasicContext.LookupItemsOwner);
}
else
{
lookupItem = new ReflectionMemberLookupItem(symbol.ShortName,
string.Join(", ", arguments.ToArray()),
declaredElementInstance,
context,
context.BasicContext.LookupItemsOwner);
}
lookupItem.InitializeRanges(context.CompletionRanges, context.BasicContext);
lookupItem.OrderingString = string.Format("__A_MEMBER_{0}", symbol.ShortName); //
collector.AddToTop(lookupItem);
}
});
}
private static void PrintType(CSharpCodeCompletionContext context, CompletionTargetMarker marker)
{
for (var node = context.NodeInFile; node != null; node = node.Parent)
{
var type = node as ITypeDeclaration;
if (type != null)
{
JetbrainsTreeDebugger.Dump(type, marker);
return;
}
}
}
protected override bool AddLookupItems(CSharpCodeCompletionContext context, GroupedItemsCollector collector)
{
Action <Context> onSuccess = kaveContext =>
{
// TODO NameUpdate: untested addition (try/catch)
try
{
_currentQuery = _queryGen.Extract(kaveContext);
}
catch (Exception e)
{
_logger.Error(e, "error while extracting query");
_currentQuery = null;
}
if (_currentQuery != null && IsAvailable())
{
var rec = LoadIfAvailable();
if (rec != null)
{
try
{
var proposals = rec.Query(_currentQuery);
WrapExistingItems(collector, proposals);
WrapNewItems(collector, proposals);
}
catch (AssertException e)
{
_logger.Error(e);
}
}
else
{
_logger.Info("no recommender model found for {0}", _currentQuery.type);
}
}
};
ContextAnalysis.Analyse(
context.NodeInFile,
null,
_logger,
onSuccess,
delegate { },
delegate { });
return(base.AddLookupItems(context, collector));
}
protected override bool AddLookupItems(CSharpCodeCompletionContext context, IItemsCollector collector)
{
var identifier = context.TerminatedContext.TreeNode as IIdentifier;
var expression = identifier.GetParentSafe <IReferenceExpression>();
if (expression == null)
{
return(false);
}
if (!(expression.ConditionalQualifier is IInvocationExpression invocation))
{
return(false);
}
var solution = context.BasicContext.Solution;
var methodIdentifier = solution.GetComponent <IMoqMethodIdentifier>();
if (methodIdentifier.IsMoqCallbackMethod(invocation))
{
invocation = invocation.InvokedExpression?.FirstChild as IInvocationExpression;
}
var mockedMethod = GetMockedMethodFromSetupMethod(solution, invocation);
if (mockedMethod == null || mockedMethod.Parameters.Count == 0 || mockedMethod.ReturnType.IsVoid())
{
return(false);
}
var types = GetMockedMethodParameterTypes(solution, invocation);
var variablesName = mockedMethod.Parameters.Select(p => p.ShortName);
var proposedCallback = $"Returns<{string.Join(",", types)}>(({string.Join(",", variablesName)}) => )";
var item = CSharpLookupItemFactory.Instance.CreateKeywordLookupItem(context,
proposedCallback,
TailType.None,
PsiSymbolsThemedIcons.Method.Id);
item.SetInsertCaretOffset(-1);
item.SetReplaceCaretOffset(-1);
item.WithInitializedRanges(context.CompletionRanges, context.BasicContext);
item.SetTopPriority();
collector.Add(item);
return(true);
}
protected override bool AddLookupItems(CSharpCodeCompletionContext context, IItemsCollector collector)
{
LastException = null;
var analysisResult = ContextAnalysis.Analyze(context.NodeInFile, null, MockLogger());
LastContext = analysisResult.Context;
LastEntryPoints = analysisResult.EntryPoints;
LastCompletionMarker = analysisResult.CompletionMarker;
if (IsPrintingType)
{
PrintType(context, LastCompletionMarker);
}
LastSST = LastContext.SST;
return(base.AddLookupItems(context, collector));
}
public static TextLookupRanges EvaluateRanges([NotNull] this CSharpCodeCompletionContext context)
{
var basicContext = context.BasicContext;
var startOffset = basicContext.CaretDocumentOffset;
var endOffset = basicContext.SelectedRange.EndOffset;
if (basicContext.File.FindTokenAt(basicContext.CaretTreeOffset) is ITokenNode tokenNode &&
tokenNode.IsAnyStringLiteral())
{
startOffset = tokenNode.GetDocumentStartOffset();
endOffset = tokenNode.GetDocumentEndOffset();
}
var replaceRange = new DocumentRange(startOffset, endOffset);
return(new TextLookupRanges(replaceRange, replaceRange));
}
public static bool IsInsideElement([NotNull] this CSharpCodeCompletionContext context, [NotNull] IClrTypeName typeName)
{
var nodeAt = context.BasicContext.File.FindNodeAt(context.BasicContext.CaretDocumentOffset);
if (nodeAt?.Parent == null)
{
return(false);
}
var parentNode = nodeAt.Parent is ICSharpArgument ? nodeAt.Parent : nodeAt.Parent.Parent;
var attribute = (parentNode is ICSharpArgument csharpArgument ? csharpArgument.Parent : nodeAt.Parent) as IAttribute;
if (attribute?.TypeReference?.Resolve().DeclaredElement is ITypeElement typeElement)
{
return(typeElement.GetClrName().Equals(typeName));
}
return(false);
}
protected override bool AddLookupItems(CSharpCodeCompletionContext context, IItemsCollector collector)
{
collector.Add(CreateXamlLookupItem());
return(true);
}
protected override bool IsAvailable(CSharpCodeCompletionContext context)
{
return(Enabled);
}
protected override bool IsAvailable(CSharpCodeCompletionContext context)
{
// necessary to cope wth Registry.Clear() in some test tear downs
RefreshRegistration();
return(true);
}
protected override bool IsAvailable(CSharpCodeCompletionContext context)
{
var codeCompletionType = context.BasicContext.CodeCompletionType;
return(codeCompletionType == CodeCompletionType.SmartCompletion || codeCompletionType == CodeCompletionType.BasicCompletion);
}
public ReflectionMemberLookupItem(string name, string code, DeclaredElementInstance instance, CSharpCodeCompletionContext context, ILookupItemsOwner owner)
: base(name, instance, context, owner)
{
_code = code;
_context = context;
}
public EnumCaseInfo([NotNull] DeclaredElementInstance instance, [NotNull] CSharpCodeCompletionContext context, bool isFlagsEnum, [NotNull] string caseValue)
: base(instance.Element.ShortName, instance, context.BasicContext.LookupItemsOwner, context, context.BasicContext)
{
IsFlagsEnum = isFlagsEnum;
CaseValue = caseValue;
}
protected override bool IsAvailable(CSharpCodeCompletionContext csContext)
{
return(base.IsAvailable(csContext));
}
public ReflectionGenericMethodLookupItem(string name, DeclaredElementInstance instance, CSharpCodeCompletionContext context, ILookupItemsOwner owner)
: base(name, string.Empty, instance, context, owner)
{
_instance = instance;
}
