public IEnumerable<IStructuralMatchResult> Search(IStructuralPatternHolder pattern, ISearchDomain searchDomain)
{
var results = new List<IStructuralMatchResult>();
var consumer = new FindResultConsumer<IStructuralMatchResult>(result =>
{
var findResultStructural = result as FindResultStructural;
if (findResultStructural != null && findResultStructural.DocumentRange.IsValid())
{
return findResultStructural.MatchResult;
}
return null;
}, match =>
{
if (match != null)
{
results.Add(match);
}
return FindExecution.Continue;
});
DoSearch(pattern.Matcher, consumer, searchDomain);
return results;
}
public IEnumerable <IStructuralMatchResult> Search(IStructuralPatternHolder pattern, ISearchDomain searchDomain)
{
var results = new List <IStructuralMatchResult>();
var consumer = new FindResultConsumer <IStructuralMatchResult>(result =>
{
var findResultStructural = result as FindResultStructural;
if (findResultStructural != null && findResultStructural.DocumentRange.IsValid())
{
return(findResultStructural.MatchResult);
}
return(null);
}, match =>
{
if (match != null)
{
results.Add(match);
}
return(FindExecution.Continue);
});
DoSearch(pattern.Matcher, consumer, searchDomain);
return(results);
}
public ReferencesSearcher(ICollection<IDeclaredElement> elements, FindResultConsumer consumer)
{
this.elements = new HashSet<IDeclaredElement>(elements);
this.consumer = consumer;
foreach (IDeclaredElement element in elements)
{
elementNames.Add(element.ShortName);
}
}
public MappingFileReferenceSearcher(IEnumerable<IDeclaredElement> elements, FindResultConsumer consumer) {
Logger.LogMessage("MappingFileReferenceSearcher ctor");
m_Consumer = consumer;
foreach (IDeclaredElement element in elements) {
m_Elements.Add(element);
m_ElementNames.Add(element.ShortName);
Logger.LogMessage(" Accessability domain {0}", element.GetAccessibilityDomain());
Logger.LogMessage(" ShortName {0}/{1}", element.GetType(), element.ShortName);
Naming.AddOtherNames(m_ElementNames, element);
}
m_ElementNamesArray = m_ElementNames.ToArray();
}
private void DoSearch(IStructuralMatcher matcher, FindResultConsumer<IStructuralMatchResult> consumer)
{
ISolution solution = Shell.Instance.GetComponent<ISolutionManager>().CurrentSolution;
var searchDomain = searchDomainFactory.CreateSearchDomain(solution, false);
var documentManager = solution.GetComponent<DocumentManager>();
// todo add support for VB (eventually)
var structuralSearcher = new StructuralSearcher(documentManager, CSharpLanguage.Instance, matcher);
var searchDomainSearcher = new StructuralSearchDomainSearcher<IStructuralMatchResult>(
NarrowSearchDomain(solution, matcher.Words, matcher.GetExtendedWords(solution), searchDomain),
structuralSearcher, consumer, NullProgressIndicator.Instance, true);
searchDomainSearcher.Run();
}
public InheritedContextFinder()
{
Found = false;
Consumer = new FindResultConsumer(result =>
{
FindResultDeclaredElement foundElement = result as FindResultDeclaredElement;
if (foundElement != null)
{
Found = foundElement.DeclaredElement.IsContext();
}
return(Found ? FindExecution.Stop : FindExecution.Continue);
});
}
public InheritedContextFinder()
{
Found = false;
Consumer = new FindResultConsumer(result =>
{
FindResultDeclaredElement foundElement = result as FindResultDeclaredElement;
if (foundElement != null)
{
Found = foundElement.DeclaredElement.IsContext();
}
return Found ? FindExecution.Stop : FindExecution.Continue;
});
}
private void DoSearch(IStructuralMatcher matcher, FindResultConsumer <IStructuralMatchResult> consumer)
{
#if SDK70
ISolution solution = Shell.Instance.GetComponent <SolutionsManager>().Solution;
#else
ISolution solution = Shell.Instance.GetComponent <ISolutionManager>().CurrentSolution;
#endif
var searchDomain = searchDomainFactory.CreateSearchDomain(solution, false);
var documentManager = solution.GetComponent <DocumentManager>();
// todo add support for VB (eventually)
var structuralSearcher = new StructuralSearcher(documentManager, CSharpLanguage.Instance, matcher);
var searchDomainSearcher = new StructuralSearchDomainSearcher <IStructuralMatchResult>(
NarrowSearchDomain(solution, matcher.Words, matcher.GetExtendedWords(solution), searchDomain),
structuralSearcher, consumer, NullProgressIndicator.Instance, true);
searchDomainSearcher.Run();
}
private static IEnumerable <IArgumentsOwner> FindReferences(ICSharpParametersOwnerDeclaration parametersOwner, IProgressIndicator progressIndicator)
{
var references = new List <IArgumentsOwner>();
var consumer = new FindResultConsumer(
r =>
{
var owners = new HashSet <IArgumentsOwner>();
var reference = r as FindResultReference;
if (reference != null)
{
var ref2 = reference.Reference;
var resolveType = ref2.CheckResolveResult();
if (resolveType == ResolveErrorType.INCORRECT_PARAMETER_NUMBER)
{
return(FindExecution.Continue);
}
var argumentsOwner = ref2.GetTreeNode().GetContainingNode <IArgumentsOwner>(true);
if (argumentsOwner != null)
{
if (owners.Contains(argumentsOwner))
{
return(FindExecution.Continue);
}
owners.Add(argumentsOwner);
references.Add(argumentsOwner);
}
}
return(FindExecution.Continue);
});
var searchAction = new SearchAction(
parametersOwner.GetPsiServices().Finder,
parametersOwner.DeclaredElement,
consumer,
SearchPattern.FIND_USAGES);
searchAction.Task(progressIndicator);
return(references);
}
private static ReflectedTypeResolveResult ResolveReflectedTypeInternal(ICSharpExpression expression, int recursion = 0)
{
if (MaxResolutionRecursion == recursion)
{
return(ReflectedTypeResolveResult.NotResolved);
}
var typeOfExpression = expression as ITypeofExpression;
if (typeOfExpression != null)
{
var type = typeOfExpression.ArgumentType.GetTypeElement <ITypeElement>();
if (type == null)
{
return(ReflectedTypeResolveResult.NotResolved);
}
return(new ReflectedTypeResolveResult(typeOfExpression.ArgumentType, ReflectedTypeResolution.Exact));
}
var methodInvocationExpression = expression as IInvocationExpression;
if (methodInvocationExpression != null)
{
if (IsReflectionTypeMethod(methodInvocationExpression, "MakeGenericType"))
{
var resolvedType = ResolveReflectedType(methodInvocationExpression);
if (resolvedType.ResolvedAs == ReflectedTypeResolution.Exact)
{
IType[] parameters;
if (GetTypeParameters(methodInvocationExpression, out parameters))
{
return
(new ReflectedTypeResolveResult(
TypeFactory.CreateType(resolvedType.TypeElement, parameters),
ReflectedTypeResolution.ExactMakeGeneric));
}
return(resolvedType);
}
}
else if (methodInvocationExpression.InvocationExpressionReference.GetName() == "GetType")
{
var qualifier = ((IReferenceExpression)methodInvocationExpression.InvokedExpression).QualifierExpression;
if (qualifier != null)
{
// ReSharper disable once AssignNullToNotNullAttribute
return(new ReflectedTypeResolveResult(qualifier.GetExpressionType().ToIType(), ReflectedTypeResolution.BaseClass));
}
else
{
var typeDeclaration = methodInvocationExpression.GetContainingTypeDeclaration();
if (typeDeclaration != null && typeDeclaration.DeclaredElement != null)
{
var type = TypeFactory.CreateType(typeDeclaration.DeclaredElement);
return(new ReflectedTypeResolveResult(type, ReflectedTypeResolution.BaseClass));
}
}
}
else if (IsReflectionTypeMethod(methodInvocationExpression, "MakeArrayType"))
{
var resolvedType = ResolveReflectedType(methodInvocationExpression);
if (resolvedType.ResolvedAs != ReflectedTypeResolution.NotResolved)
{
return(new ReflectedTypeResolveResult(TypeFactory.CreateArrayType(resolvedType.Type, 1), ReflectedTypeResolution.Exact));
}
}
}
var reference = expression as IReferenceExpression;
if (reference != null)
{
var resolveResult = reference.Reference.Resolve();
if (resolveResult.ResolveErrorType == ResolveErrorType.OK && resolveResult.DeclaredElement != null)
{
//
var assignmentExpressions = new List <ICSharpExpression>();
var declarations = resolveResult.DeclaredElement.GetDeclarations().OfType <IInitializerOwnerDeclaration>().ToArray();
if (declarations.Length > 0)
{
var expressionInitializer = (IExpressionInitializer)declarations[0].Initializer;
if (expressionInitializer != null)
{
assignmentExpressions.Add(expressionInitializer.Value);
}
}
var findResultConsumer = new FindResultConsumer(result =>
{
var resultReference = result as IFindResultReference;
if (resultReference != null)
{
var assignment = resultReference.Reference.GetTreeNode().GetContainingNode <IAssignmentExpression>();
if (assignment != null)
{
assignmentExpressions.Add(assignment.Source);
}
}
return(FindExecution.Continue);
});
var finder = expression.GetPsiServices().Finder;
finder.FindReferences(resolveResult.DeclaredElement,
resolveResult.DeclaredElement.GetSearchDomain(),
findResultConsumer, NullProgressIndicator.Instance);
if (assignmentExpressions.Count == 1)
{
return(ResolveReflectedTypeInternal(assignmentExpressions[0], recursion + 1));
//Try to resolve appropriate reference
}
}
}
return(ReflectedTypeResolveResult.NotResolved);
}
public ILanguageSpecificSearcher CreateTextOccurenceSeacrher(string subject, FindResultConsumer consumer)
{
return null;
}
public ILanguageSpecificSearcher CreateTextOccurenceSeacrher(ICollection<IDeclaredElement> elements,
FindResultConsumer consumer)
{
return null;
}
public ILanguageSpecificSearcher CreateReferenceSearcher(ICollection<IDeclaredElement> elements,
FindResultConsumer consumer)
{
return new ReferencesSearcher(elements, consumer);
}
public ILanguageSpecificSearcher CreateMethodsReferencedByDelegateSearcher(IDelegate @delegate,
FindResultConsumer consumer)
{
return null;
}
public ILanguageSpecificSearcher CreateConstructorSpecialReferenceSearcher(
ICollection<IConstructor> constructors, FindResultConsumer consumer)
{
return null;
}
public ILanguageSpecificSearcher CreateAnonymousTypeSearcher(IList<Pair<string, IType>> typeDescription,
FindResultConsumer consumer)
{
return null;
}
private static IEnumerable<IArgumentsOwner> FindReferences(ICSharpParametersOwnerDeclaration parametersOwner, IProgressIndicator progressIndicator)
{
var references = new List<IArgumentsOwner>();
var consumer = new FindResultConsumer(
r =>
{
var owners = new HashSet<IArgumentsOwner>();
var reference = r as FindResultReference;
if(reference != null)
{
var ref2 = reference.Reference;
var resolveType = ref2.CheckResolveResult();
if (resolveType == ResolveErrorType.INCORRECT_PARAMETER_NUMBER)
return FindExecution.Continue;
var argumentsOwner = ref2.GetElement().GetContainingElement<IArgumentsOwner>(true);
if(argumentsOwner != null)
{
if (owners.Contains(argumentsOwner))
return FindExecution.Continue;
owners.Add(argumentsOwner);
references.Add(argumentsOwner);
}
}
return FindExecution.Continue;
});
var searchAction = new SearchAction(
parametersOwner.GetManager().Finder,
parametersOwner.DeclaredElement,
consumer,
SearchPattern.FIND_USAGES);
searchAction.Task(progressIndicator);
return references;
}
