private static ICollection <JetTuple <string, string, MvcUtil.DeterminationKind, ICollection <IClass> > > GetModulesNotCached([NotNull] IArgumentsOwner argumentsOwner) { argumentsOwner.AssertIsValid("argumentsOwner is invalid"); IPsiModule psiModule = argumentsOwner.GetPsiModule(); IProject project = argumentsOwner.GetProject(); Assertion.AssertNotNull(project, "project == null"); IProjectFile projectFile = argumentsOwner.GetSourceFile().ToProjectFile(); Assertion.AssertNotNull(projectFile, "projectFile == null"); IList <string> controllerNames = ProcessArgumentsExpression(argumentsOwner, MvcKind.Controller); ICollection <JetTuple <string, string, MvcUtil.DeterminationKind, bool> > moduleNames = new List <JetTuple <string, string, MvcUtil.DeterminationKind, bool> >(); if (controllerNames.IsEmpty()) { // first, try detect implicit controller type by view var typeDeclaration = argumentsOwner.GetContainingNode <ITypeDeclaration>(); IClass declaredElement = (typeDeclaration != null) ? typeDeclaration.DeclaredElement as IClass : null; if (declaredElement == null) { return(EmptyList <JetTuple <string, string, MvcUtil.DeterminationKind, ICollection <IClass> > > .InstanceList); } JetTuple <string, string, MvcUtil.DeterminationKind, ICollection <IClass> > @default = JetTuple.Of(GetControllerArea(declaredElement), GetControllerName(declaredElement), MvcUtil.DeterminationKind.ImplicitByContainingMember, (ICollection <IClass>) new IClass[] { null }); // with inheritors if (declaredElement.IsAbstract) { // with inheritors return(GetAvailableModules(psiModule, argumentsOwner.GetResolveContext(), baseClass: declaredElement) .SelectMany(_ => _.Value) .GroupBy( @class => new { area = GetControllerArea(@class), controller = GetControllerName(@class) }) .Select(_ => JetTuple.Of(_.Key.area, _.Key.controller, MvcUtil.DeterminationKind.ImplicitByContainingMember, (ICollection <IClass>)_.ToList())) .DefaultIfEmpty(@default) .ToList()); } moduleNames = new[] { JetTuple.Of(@default.A, @default.B, MvcUtil.DeterminationKind.ImplicitByContainingMember, true) }; } return((from tuple in moduleNames let availableModules = GetAvailableModules(psiModule, argumentsOwner.GetResolveContext(), includingIntermediateControllers: tuple.D) select JetTuple.Of(tuple.A, tuple.B, tuple.C, tuple.B == null ? (ICollection <IClass>) new IClass[] { null } : availableModules.GetValuesCollection(tuple.B))) .ToList()); }
private static IList <string> ProcessArgumentsExpression(IArgumentsOwner argumentsOwner, MvcKind kind) { #if SDK80 IDeclaredType stringType = TypeFactory.CreateTypeByCLRName(PredefinedType.STRING_FQN, argumentsOwner.GetPsiModule(), argumentsOwner.GetResolveContext()); #else IDeclaredType stringType = TypeFactory.CreateTypeByCLRName(PredefinedType.STRING_FQN, argumentsOwner.GetPsiModule()); #endif var enumerabe1 = from expression in RetrieveArgumentExpressions(argumentsOwner, kind) let finder = new RecursiveElementCollector <IExpression>( literalExpression => { if (!literalExpression.GetExpressionType().IsImplicitlyConvertibleTo( stringType, IntentionLanguageSpecific.GetTypeConversion(literalExpression))) { return(false); } string initializerName; IInvocationInfo invocationInfo; GetMvcLiteral(literalExpression, out invocationInfo, out initializerName); return((invocationInfo == argumentsOwner) && expression.Second.Any(_ => StringComparer.OrdinalIgnoreCase.Equals(_.B, initializerName))); }) select new { finder, expression }; return((from x in enumerabe1 from literal in x.finder.ProcessElement(x.expression.First).GetResults() select literal.ConstantValue.Value as string).ToList()); }
public FormattingFunctionInvocationInfo TryGetByExpression(IArgumentsOwner argumentsOwner) { IFunctionInvocationClrWrapper functionInvocation = FunctionInvocationUtil.GetFunctionInvocationByArgumentsOwner(argumentsOwner); if (functionInvocation == null) { return null; } IList<IFunction> candidates = functionInvocation.InvokedFunction.IfNotNull(_ => new List<IFunction> { _ }) ?? functionInvocation.InvokedFunctionCandidates; if (candidates == null || candidates.IsEmpty()) { return null; } IList<IExpression> arguments = functionInvocation.Arguments; List<IParameter> annotatedParameters = candidates.Select(_ => myCodeAnnotationsCache.GetStringFormatMethodParameter(_)).ToList(); if (annotatedParameters.IsEmpty() || annotatedParameters.Contains(null)) { return null; } IParameter parameter = annotatedParameters.First(); var function = parameter.ContainingParametersOwner as IFunction; if (function == null) { return null; } int index1 = function.Parameters.IndexOf(parameter); if (index1 < 0 || index1 >= arguments.Count) { return null; } int num = index1 + 1; IList<IParameter> parameters = function.Parameters; IDeclaredType typeByClrName = TypeFactory.CreateTypeByCLRName("System.IFormatProvider", argumentsOwner.GetPsiModule(), argumentsOwner.GetResolveContext()); ITypeConversionRule typeConversion = IntentionLanguageSpecific.GetTypeConversion(argumentsOwner); bool flag1 = false; for (int index2 = 0; index2 < index1; ++index2) { IExpression expression = index2 < arguments.Count ? arguments[index2] : null; if (expression != null && expression.GetExpressionType().IsImplicitlyConvertibleTo(typeByClrName, typeConversion)) { flag1 = true; break; } } if (!flag1 && index1 + 1 < parameters.Count && (index1 + 1 < arguments.Count && arguments[index1 + 1] != null) && (parameters[index1 + 1] != null && parameters[index1 + 1].Type.Equals(typeByClrName))) { flag1 = true; ++num; } if (num > arguments.Count) { return null; } IExpression expression1 = arguments[index1]; if (expression1 == null) { return null; } var list3 = new List<IExpression>(); bool flag2 = false; for (int index2 = num; index2 < arguments.Count; ++index2) { if (index2 == parameters.Count - 1 && parameters.Count == arguments.Count && parameters.Last().IsParameterArray && (arguments.Last() == null || arguments.Last().ConstantValue.IsPureNull(argumentsOwner.Language) || arguments.Last().GetExpressionType().ToIType() is IArrayType)) { flag2 = true; break; } list3.Add(arguments[index2]); } IStringConcatenationClrWrapper stringConcatenation = StringConcatenationClrWrapperUtil.CreateStringConcatenation(expression1); if (stringConcatenation == null) { return null; } return new FormattingFunctionInvocationInfo { Invocation = functionInvocation, FormatStringConcatenation = stringConcatenation, FormattingArguments = list3, HasCustomFormatProvider = flag1, HasExplicitParamArrayArgument = flag2 }; }