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)); }