private void ChangeReference(IArgumentsOwner reference, string recommendedName, IType type) { var csharpOwner = reference as ICSharpArgumentsOwner; if (csharpOwner == null) { return; } var factory = CSharpElementFactory.GetInstance(type.Module); var inField = false; if (csharpOwner.GetContainingNode <IFieldDeclaration>() != null) { inField = true; } var expression = factory.CreateExpression(inField ? "TODO" : recommendedName); var cSharpArgument = factory.CreateArgument(ParameterKind.VALUE, null, expression); csharpOwner.AddArgumentAfter( cSharpArgument, csharpOwner.Arguments.LastOrDefault()); if (!inField) { AddStub(cSharpArgument, reference, recommendedName); } }
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()); }
protected override void AddStub(ICSharpArgument cSharpArgument, IArgumentsOwner reference, string recommendedName) { var referenceExpression = cSharpArgument.Value as IReferenceExpression; var anchor = reference.GetContainingNode<IBlock>(); var containingMethod = anchor.Parent as IMethodDeclaration; if (containingMethod == null) return; if (!containingMethod.Attributes.Select(x => x.Name.QualifiedName).Any(x => x == "SetUp" || x == "Test" || x == "TestCase")) return; var addStub = new AddRhinoStub(recommendedName, referenceExpression, anchor); addStub.Execute(); }
public static IEnumerable <JetTuple <string, string, MvcUtil.DeterminationKind, ICollection <IClass> > > GetModules( [CanBeNull] IArgumentsOwner argumentsOwner) { if ((argumentsOwner == null) || !argumentsOwner.IsValid()) { return(EmptyList <JetTuple <string, string, MvcUtil.DeterminationKind, ICollection <IClass> > > .InstanceList); } CachedPsiValue <ICollection <JetTuple <string, string, MvcUtil.DeterminationKind, ICollection <IClass> > > > cachedData = argumentsOwner.UserData.GetOrCreateData(ourCachedControllersKey, () => argumentsOwner.CreateCachedValue(GetModulesNotCached(argumentsOwner))); return(cachedData.GetValue(argumentsOwner, () => GetModulesNotCached(argumentsOwner))); }
protected override void AddStub(ICSharpArgument cSharpArgument, IArgumentsOwner reference, string recommendedName) { var referenceExpression = cSharpArgument.Value as IReferenceExpression; var anchor = reference.GetContainingNode <IBlock>(); var containingMethod = anchor.Parent as IMethodDeclaration; if (containingMethod == null) { return; } if (!containingMethod.Attributes.Select(x => x.Name.QualifiedName).Any(x => x == "SetUp" || x == "Test" || x == "TestCase")) { return; } var addStub = new AddRhinoStub(recommendedName, referenceExpression, anchor); addStub.Execute(); }
RetrieveArgumentExpressions([CanBeNull] IArgumentsOwner argumentsOwner, MvcKind?kind = null, bool returnAllKinds = false) { if (argumentsOwner == null) { return (EmptyList <Pair <IExpression, ICollection <JetTuple <MvcKind, string, IAttributeInstance> > > > .InstanceList); } return (from argument in argumentsOwner.Arguments where argument != null // just for case let expression = argument.Expression where expression != null let matchingParameter = argument.MatchingParameter where matchingParameter != null let parameter = matchingParameter.Element let mvcKinds = parameter.GetMvcKinds() let allowedMvcKinds = kind.HasValue ? mvcKinds.Where(_ => _.A == kind).ToList() : mvcKinds where allowedMvcKinds.Any() select Pair.Of(expression, returnAllKinds?mvcKinds : allowedMvcKinds)); }
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()); }
protected virtual void AddStub(ICSharpArgument cSharpArgument, IArgumentsOwner reference, string recommendedName) { }
private static void ChangeReference(IArgumentsOwner reference, string recommendedName, IType type) { var csharpOwner = reference as ICSharpArgumentsOwner; if (csharpOwner == null || type.Module == null) return; var factory = CSharpElementFactory.GetInstance(type.Module); var inField = false; if (csharpOwner.GetContainingElement<IFieldDeclaration>(false) != null) inField = true; var expression = factory.CreateExpression(inField ? "TODO" : recommendedName); csharpOwner.AddArgumentAfter( factory.CreateArgument(ParameterKind.VALUE, null, expression), csharpOwner.Arguments.LastOrDefault()); }
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 }; }
public NancyMvcActionReference([NotNull] IExpression owner, IArgumentsOwner argumentsExpression) : base(owner, argumentsExpression) { }