public override IReference BindTo(IDeclaredElement element)
{
if (GetName() != element.ShortName)
{
CSharpElementFactory instance = CSharpElementFactory.GetInstance(myOwner, true);
if (_resolveResult.ResolveErrorType == ResolveErrorType.OK)
{
var elementNameExpression = myOwner.ReplaceBy(instance.CreateExpression("\"$0\"", element.ShortName));
return(new ReflectedMemberReference(elementNameExpression,
new ResolveResultWithInfo(ResolveResultFactory.CreateResolveResult(element), ResolveErrorType.OK),
_typeElement));
}
}
return(this);
}
private ResolveResultWithInfo LocalResolveWithoutCache()
{
List <IDeclaredElement> list = GetReferenceSymbolTable(true).GetAllSymbolInfos().Select(info => info.GetDeclaredElement()).Where(ResolveFilter).ToList();
switch (list.Count)
{
case 0:
return(ResolveResultWithInfo.Unresolved);
case 1:
return(new ResolveResultWithInfo(ResolveResultFactory.CreateResolveResult(list.First()), ResolveErrorType.OK));
default:
return(new ResolveResultWithInfo(ResolveResultFactory.CreateResolveResult(list), ResolveErrorType.MULTIPLE_CANDIDATES));
}
}
public override ResolveResultWithInfo ResolveWithoutCache()
{
var psiServices = myOwner.GetPsiServices();
var specflowStepsDefinitionsCache = psiServices.GetComponent <SpecflowStepsDefinitionsCache>();
var stepKind = myOwner.GetStepKind();
var stepText = myOwner.GetStepText();
var projectReferences = myOwner.GetProject()?.GetAllModuleReferences().OfType <SimpleProjectToProjectReference>().ToList();
foreach (var(sourceFile, cacheEntries) in specflowStepsDefinitionsCache.AllStepsPerFiles)
{
if (!ReferenceEquals(sourceFile.GetProject(), myOwner.GetProject()))
{
if (projectReferences?.Any(x => x.Name == sourceFile.GetProject()?.Name) != true)
{
continue;
}
}
foreach (var cacheEntry in cacheEntries.Where(c => c.StepKind == stepKind))
{
if (cacheEntry.Regex?.IsMatch(stepText) == true)
{
var types = psiServices.Symbols.GetTypesAndNamespacesInFile(sourceFile);
foreach (var decElement in types)
{
if (!(decElement is IClass cl))
{
continue;
}
var method = cl.GetMembers().OfType <IMethod>().FirstOrDefault(x => x.ShortName == cacheEntry.MethodName);
if (method == null)
{
continue;
}
var symbolInfo = new SymbolInfo(method);
var resolveResult = ResolveResultFactory.CreateResolveResult(symbolInfo.GetDeclaredElement(), symbolInfo.GetSubstitution());
return(new ResolveResultWithInfo(resolveResult, ResolveErrorType.OK));
}
}
}
}
return(new ResolveResultWithInfo(EmptyResolveResult.Instance, ResolveErrorType.NOT_RESOLVED));
}
public ResolveResultWithInfo Resolve()
{
var name = GetText();
var file = (NitraFile)this.GetContainingFile();
if (file == null)
{
return(ResolveResultWithInfo.Unresolved);
}
var declaredElement = file.Project.LookupDeclaredElement(name);
if (declaredElement == null)
{
return(ResolveResultWithInfo.Unresolved);
}
var resolveResult = ResolveResultFactory.CreateResolveResult(declaredElement);
return(new ResolveResultWithInfo(resolveResult, ResolveErrorType.OK));;
}
public override ResolveResultWithInfo ResolveWithoutCache()
{
var psiServices = myOwner.GetPsiServices();
var specflowStepsDefinitionsCache = psiServices.GetComponent <SpecflowStepsDefinitionsCache>();
var stepKind = myOwner.EffectiveStepKind;
var stepText = myOwner.GetStepText();
var psiModule = myOwner.GetPsiModule();
var containingScenario = myOwner.GetContainingNode <IGherkinScenario>();
if (containingScenario is GherkinScenarioOutline scenarioOutline)
{
stepText = myOwner.GetStepTextForExample(scenarioOutline.GetExampleData(0));
}
foreach (var(sourceFile, cacheEntries) in specflowStepsDefinitionsCache.AllStepsPerFiles)
{
if (!psiModule.Equals(sourceFile.PsiModule) && !psiModule.References(sourceFile.PsiModule))
{
continue;
}
foreach (var cacheEntry in cacheEntries.Where(c => c.StepKind == stepKind))
{
if (cacheEntry.Regex?.IsMatch(stepText) == true)
{
var types = psiServices.Symbols.GetTypesAndNamespacesInFile(sourceFile);
foreach (var decElement in types)
{
if (!(decElement is IClass cl))
{
continue;
}
var method = cl.GetMembers().OfType <IMethod>().FirstOrDefault(x => x.ShortName == cacheEntry.MethodName);
if (method == null)
{
continue;
}
var symbolInfo = new SymbolInfo(method);
var resolveResult = ResolveResultFactory.CreateResolveResult(symbolInfo.GetDeclaredElement(), symbolInfo.GetSubstitution());
RegexPattern = cacheEntry.Regex;
return(new ResolveResultWithInfo(resolveResult, ResolveErrorType.OK));
}
}
}
}
var assemblyStepDefinitionCache = psiServices.GetComponent <AssemblyStepDefinitionCache>();
var psiAssemblyFileLoader = psiServices.GetComponent <IPsiAssemblyFileLoader>();
foreach (var(psiAssembly, cacheEntries) in assemblyStepDefinitionCache.AllStepsPerAssembly)
{
// FIXME: Should use `assembly` from specflow.json instead
if (!psiModule.Equals(psiAssembly.PsiModule) && !psiModule.References(psiAssembly.PsiModule))
{
continue;
}
foreach (var cacheEntry in cacheEntries.Where(c => c.StepKind == stepKind))
{
if (cacheEntry.Regex?.IsMatch(stepText) == true)
{
var assemblyFile = psiAssemblyFileLoader.GetOrLoadAssembly(psiAssembly, false);
if (assemblyFile == null)
{
continue;
}
foreach (var decElement in assemblyFile.Types)
{
if (!(decElement is IClass cl))
{
continue;
}
var method = cl.GetMembers().OfType <IMethod>().FirstOrDefault(x => x.ShortName == cacheEntry.MethodName);
if (method == null)
{
continue;
}
var symbolInfo = new SymbolInfo(method);
var resolveResult = ResolveResultFactory.CreateResolveResult(symbolInfo.GetDeclaredElement(), symbolInfo.GetSubstitution());
RegexPattern = cacheEntry.Regex;
return(new ResolveResultWithInfo(resolveResult, ResolveErrorType.OK));
}
}
}
}
return(new ResolveResultWithInfo(EmptyResolveResult.Instance, ResolveErrorType.NOT_RESOLVED));
}
public override ReflectionHighlightingBase Validate(ReflectedTypeResolveResult resolvedType, IInvocationExpression invocation)
{
ITypeMember resolvedMember = null;
IExpression nameArgument = NameArgument(invocation);
//We may use TypeElement here as we validate only exact matches
ITypeMember[] resolvedMembers = ResolveMember(resolvedType.TypeElement, invocation);
if (resolvedMembers.Length == 0)
{
return(new ReflectionMemberNotFoundError(nameArgument, ExpectedMemberType, resolvedType.TypeElement,
ArgumentConstantValue <BindingFlags>(BindingFlagsArgument(invocation))));
}
if (resolvedMembers.Length > 1)
{
if (!ProcessAmbigiousMembers(resolvedMembers, out resolvedMember))
{
nameArgument.UserData.PutData(ReflectedMemberReference.Key,
new ReflectedMemberReference(nameArgument,
new ResolveResultWithInfo(ResolveResultFactory.CreateResolveResult(resolvedMembers), ResolveErrorType.MULTIPLE_CANDIDATES), resolvedType.TypeElement));
return(new AmbigiousMemberMatchError(nameArgument, ExpectedMemberType, GetAmbigiuityResolutionSuggestion()));
}
}
else
{
resolvedMember = resolvedMembers[0];
nameArgument.UserData.PutData(ReflectedMemberReference.Key,
new ReflectedMemberReference(nameArgument,
new ResolveResultWithInfo(ResolveResultFactory.CreateResolveResult(resolvedMember), ResolveErrorType.OK), resolvedType.TypeElement));
return(ValidateBindingFlags(resolvedType.TypeElement, resolvedMember, invocation)
?? ValidateCore(resolvedType.TypeElement, resolvedMember, invocation));
}
return(null);
}
