public override ResolveResultWithInfo ResolveWithoutCache()
{
ISymbolTable table = this.GetReferenceSymbolTable(true);
IList <DeclaredElementInstance> elements = new List <DeclaredElementInstance>();
{
IList <ISymbolInfo> infos = table.GetSymbolInfos(this.GetName());
foreach (ISymbolInfo info in infos)
{
var element = new DeclaredElementInstance(info.GetDeclaredElement(), EmptySubstitution.INSTANCE);
elements.Add(element);
}
}
if (elements.Count == 0)
{
var ruleName = this.myOwner as Prefix;
// Unresolved namespaces creation
if (ruleName != null)
{
elements = new List <DeclaredElementInstance>
{
new DeclaredElementInstance(
new UnresolvedNamespacePrefixDeclaredElement(
ruleName.GetSourceFile(), this.GetName(), this.myOwner.GetPsiServices()))
};
}
}
return(new ResolveResultWithInfo(ResolveResultFactory.CreateResolveResultFinaly(elements), ResolveErrorType.OK));
}
public override ResolveResultWithInfo ResolveWithoutCache()
{
ISymbolTable table = GetReferenceSymbolTable(true);
IList <DeclaredElementInstance> elements = new List <DeclaredElementInstance>();
{
IList <ISymbolInfo> infos = table.GetSymbolInfos(GetName());
foreach (ISymbolInfo info in infos)
{
var element = new DeclaredElementInstance(info.GetDeclaredElement(), EmptySubstitution.INSTANCE);
elements.Add(element);
}
}
if (elements.Count == 0)
{
var ruleName = myOwner as RuleName;
if (PsiTreeUtil.HasParent <InterfacesDefinition>(myOwner) && (ruleName != null))
{
elements = new List <DeclaredElementInstance> {
new DeclaredElementInstance(new UnresolvedRuleInterfacesDeclaredElement(ruleName.GetSourceFile(), GetName(), myOwner.GetPsiServices()))
};
}
}
return(new ResolveResultWithInfo(ResolveResultFactory.CreateResolveResultFinaly(elements),
ResolveErrorType.OK));
}
private IEnumerable <T> CreateResult <T>(params Object[] source)
=> (IEnumerable <T>)ResolveResultFactory.CreateResult(
typeof(IResolve <T>).GetTypeInfo(),
source,
Mock.Of <IResolveBuilder>(),
Enumerable.Empty <ResolveFailure>()
);
public void Fails_invalid_property_type(Type invalidType)
{
Assert.Throws <ArgumentException>(
() => ResolveResultFactory.CreateResult(
invalidType.GetTypeInfo(),
new[] { "42" },
Mock.Of <IResolveBuilder>(),
Enumerable.Empty <ResolveFailure>()
)
);
}
public void Creates_expected_ResolveResult(Type interfaceType, Type resultType)
{
var result = ResolveResultFactory.CreateResult(
interfaceType.GetTypeInfo(),
new[] { "42" },
Mock.Of <IResolveBuilder>(),
Enumerable.Empty <ResolveFailure>()
);
Assert.IsType(resultType, result);
}
public void Fails_incompatible_IEnumerable()
{
var result = (ResolveResultSingle <Int32>)ResolveResultFactory.CreateResult(
typeof(IResolveSingle <Int32>).GetTypeInfo(),
new[] { "42" },
Mock.Of <IResolveBuilder>(),
Enumerable.Empty <ResolveFailure>()
);
Assert.Throws <InvalidCastException>(
() => result.Value
);
}
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()
{
ISymbolTable table = GetReferenceSymbolTable(true);
IList <DeclaredElementInstance> elements = new List <DeclaredElementInstance>();
{
IList <ISymbolInfo> infos = table.GetSymbolInfos(GetName());
foreach (ISymbolInfo info in infos)
{
var element = new DeclaredElementInstance(info.GetDeclaredElement(), EmptySubstitution.INSTANCE);
elements.Add(element);
}
}
return(new ResolveResultWithInfo(ResolveResultFactory.CreateResolveResultFinaly(elements),
ResolveErrorType.OK));
}
public void Casts_to_derived_type()
{
var expected = new DerivedClass();
var result = (IEnumerable)ResolveResultFactory.CreateResult(
typeof(IResolve <DerivedClass>).GetTypeInfo(),
new BaseClass[] { expected },
Mock.Of <IResolveBuilder>(),
Enumerable.Empty <ResolveFailure>()
);
Assert.IsType(typeof(ResolveResult <DerivedClass>), result);
var actual = Assert.Single(result);
Assert.Same(expected, actual);
}
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);
}
public override ResolveResultWithInfo ResolveWithoutCache()
{
return(new ResolveResultWithInfo(
ResolveResultFactory.CreateResolveResultFinaly(new List <DeclaredElementInstance>()), ResolveErrorType.OK));
}
