private static IMethodDeclaration CreateVBInvocator(IEventDeclaration eventDeclaration, IModifiers modifiers,
                                                            IList <IArgument> arguments, IList <IParameter> parameters, IConstructLanguage language)
        {
            IEventInvocation eventInvocation = language.New <IEventInvocation>();

            eventInvocation.DelegateInvocation =
                language.DelegateInvocation(
                    language.VariableAccess(eventDeclaration.Identifier),
                    language.Arguments(arguments));

            IMethodDeclaration method = language.Method(
                language.None <IDocComment>(),
                language.None <IAttributes>(),
                modifiers,
                language.TypeName(eventDeclaration.VoidTypeAtThisLocation()),
                language.None <IMethodTypeParameters>(),
                language.Parameters(parameters),
                language.Block(
                    language.ExpressionStatement(eventInvocation)));

            NamingPolicy methodsNamingPolicy = method.PrimaryNamingPolicy(eventDeclaration.FileModel.UserSettings);
            string       methodName          = methodsNamingPolicy.ChangeNameAccordingToPolicy("Raise" + eventDeclaration.Identifier.Name + "Event",
                                                                                               eventDeclaration.SolutionModel);

            method.Identifier = language.Identifier(methodName);

            return(method);
        }
Exemple #2
0
        private IConstructorDeclaration CreateConstructor(IClassDeclaration classDeclaration, IIdentifier fieldIdentifier, ITypeName typeName)
        {
            IConstructLanguage language = classDeclaration.Language;

            IParameter   parameter             = language.Parameter(typeName);
            NamingPolicy parameterNamingPolicy = parameter.PrimaryNamingPolicy(classDeclaration.FileModel.UserSettings);
            string       parameterName         = parameterNamingPolicy.ChangeNameAccordingToPolicy(classDeclaration.Identifier.Name, classDeclaration.SolutionModel);

            parameter.Identifier = language.Identifier(parameterName);
            Modifiers constructorModifiers = Modifiers.Public;
            Modifiers visibility           = classDeclaration.Modifiers.Modifiers.GetVisibility();

            if (visibility == Modifiers.None || visibility.IsInternal())
            {
                constructorModifiers = Modifiers.Internal;
            }

            IConstructorDeclaration constructor = language.Constructor(language.None <IDocComment>(),
                                                                       language.None <IAttributes>(),
                                                                       language.Modifiers(constructorModifiers),
                                                                       language.Parameters(parameter),
                                                                       language.None <IConstructorInitializer>(),
                                                                       language.Block(
                                                                           language.AssignmentStatement(
                                                                               language.MemberAccess(language.This(), fieldIdentifier),
                                                                               language.VariableAccess(parameter.Identifier))));

            return(constructor);
        }
Exemple #3
0
        private IAccessor CreateSetter(IConstructLanguage language, string propertyName, IFieldDeclaration field)
        {
            string propertyChangedName = language.Name == LanguageNames.CSharp ? "OnPropertyChanged" : "RaisePropertyChangedEvent";

            IMethodInvocation onPropertyChanged = language.MethodInvocation(language.None <IExpression>(),
                                                                            language.Identifier(propertyChangedName),
                                                                            language.None <ITypeArguments>(),
                                                                            language.Arguments(
                                                                                language.Argument(language.StringLiteral(propertyName))));

            IMemberAccess fieldUsage = language.MemberAccess(language.None <IExpression>(), field.Identifier);
            IExpression   valueUsage = language.Expression("value");

            IStatement assignment = language.AssignmentStatement(fieldUsage, valueUsage);

            IIfStatement ifStatement =
                language.IfStatement(
                    language.BinaryExpression(fieldUsage,
                                              Operator.NotEqual,
                                              valueUsage),
                    language.Block(assignment, language.ExpressionStatement(onPropertyChanged)));

            IAccessor setter = language.Setter(language.Block(ifStatement));

            return(setter);
        }
        private static void GenerateSecondParameterAndArgument(IEventDeclaration eventDeclaration, IParameter parameter, IConstructLanguage language, FileModel fileModel, IList <IArgument> arguments, IList <IParameter> parameters)
        {
            NamingPolicy parametersNamingPolicy = language.PrimaryNamingPolicyFor <IParameter>(fileModel.UserSettings);
            IType        parameterType          = eventDeclaration.TypeName.Type.As <IDelegateType>().ReplaceParameterTypesIn(parameter.Type);

            IParameter newParameter = language.Parameter(
                parameter.IsRef,
                parameter.IsOut,
                parameter.IsParams,
                language.TypeName(eventDeclaration.StringTypeAtThisLocation()),
                parameter.DefaultValue);

            string parameterName = parametersNamingPolicy.ChangeNameAccordingToPolicy("propertyName", parameter.SolutionModel);

            newParameter.Identifier = language.Identifier(parameterName);

            IObjectCreation objectCreation = language.ObjectCreation(
                language.TypeName(parameterType), language.Arguments(
                    language.Argument(
                        language.VariableAccess(newParameter.Identifier))));

            arguments.Add(
                language.Argument(
                    objectCreation));

            parameters.Add(newParameter);
        }
Exemple #5
0
        private IFieldDeclaration CreateFieldToHoldWrappedClass(IConstructLanguage language, ITypeName typeName, IClassDeclaration classDeclaration)
        {
            IFieldDeclaration fieldDeclaration   = language.Field(language.Modifiers(Modifiers.Private | Modifiers.Readonly), typeName);
            NamingPolicy      fieldsNamingPolicy = fieldDeclaration.PrimaryNamingPolicy(classDeclaration.FileModel.UserSettings);
            string            fieldName          = fieldsNamingPolicy.ChangeNameAccordingToPolicy(classDeclaration.Identifier.Name, classDeclaration.SolutionModel);

            fieldDeclaration.Identifier = language.Identifier(fieldName);
            return(fieldDeclaration);
        }
        private static IMethodDeclaration CreateCSInvocator(IEventDeclaration eventDeclaration, IModifiers modifiers, IList<IArgument> arguments,
            IList<IParameter> parameters, IConstructLanguage language)
        {
            IVariableDeclaration variable = language.Variable(
                eventDeclaration.TypeName,
                language.VariableAccess(eventDeclaration.Identifier));

            NamingPolicy variablesNamingPolicy = variable.PrimaryNamingPolicy(eventDeclaration.FileModel.UserSettings);
            string variableName = variablesNamingPolicy.ChangeNameAccordingToPolicy("on" + eventDeclaration.Identifier.Name,
                eventDeclaration.SolutionModel);

            variable.Identifier = language.Identifier(variableName);

            IIfStatement ifStatement = language.IfStatement(
                language.BinaryExpression(
                    language.VariableAccess(variable.Identifier),
                    Operator.NotEqual,
                    language.New<INull>()),
                language.Block(
                    language.ExpressionStatement(
                        language.DelegateInvocation(
                            language.VariableAccess(variable.Identifier),
                            language.Arguments(arguments)))));

            IMethodDeclaration method = language.Method(
                language.None<IDocComment>(),
                language.None<IAttributes>(),
                modifiers,
                language.TypeName(eventDeclaration.VoidTypeAtThisLocation()),
                language.None<IMethodTypeParameters>(),
                language.Parameters(parameters),
                language.Block(
                    variable,
                    ifStatement));

            NamingPolicy methodsNamingPolicy = method.PrimaryNamingPolicy(eventDeclaration.FileModel.UserSettings);
            string methodName = methodsNamingPolicy.ChangeNameAccordingToPolicy("on" + eventDeclaration.Identifier.ToUpperFirstLetter().Name,
                eventDeclaration.SolutionModel);

            method.Identifier = language.Identifier(methodName);

            return method;
        }
        private static IMethodDeclaration CreateCSInvocator(IEventDeclaration eventDeclaration, IModifiers modifiers, IList <IArgument> arguments,
                                                            IList <IParameter> parameters, IConstructLanguage language)
        {
            IVariableDeclaration variable = language.Variable(
                eventDeclaration.TypeName,
                language.VariableAccess(eventDeclaration.Identifier));

            NamingPolicy variablesNamingPolicy = variable.PrimaryNamingPolicy(eventDeclaration.FileModel.UserSettings);
            string       variableName          = variablesNamingPolicy.ChangeNameAccordingToPolicy("on" + eventDeclaration.Identifier.Name,
                                                                                                   eventDeclaration.SolutionModel);

            variable.Identifier = language.Identifier(variableName);

            IIfStatement ifStatement = language.IfStatement(
                language.BinaryExpression(
                    language.VariableAccess(variable.Identifier),
                    Operator.NotEqual,
                    language.New <INull>()),
                language.Block(
                    language.ExpressionStatement(
                        language.DelegateInvocation(
                            language.VariableAccess(variable.Identifier),
                            language.Arguments(arguments)))));

            IMethodDeclaration method = language.Method(
                language.None <IDocComment>(),
                language.None <IAttributes>(),
                modifiers,
                language.TypeName(eventDeclaration.VoidTypeAtThisLocation()),
                language.None <IMethodTypeParameters>(),
                language.Parameters(parameters),
                language.Block(
                    variable,
                    ifStatement));

            NamingPolicy methodsNamingPolicy = method.PrimaryNamingPolicy(eventDeclaration.FileModel.UserSettings);
            string       methodName          = methodsNamingPolicy.ChangeNameAccordingToPolicy("on" + eventDeclaration.Identifier.ToUpperFirstLetter().Name,
                                                                                               eventDeclaration.SolutionModel);

            method.Identifier = language.Identifier(methodName);

            return(method);
        }
Exemple #8
0
        private IClassDeclaration ImplementINotifyPropertyChangedInterface(IClassDeclaration viewModel, IClassDeclaration wrappedClass)
        {
            UsingDirectiveHelper.AddUsingDirectiveIfNeeded(wrappedClass, "System", "ComponentModel");

            IConstructLanguage language   = viewModel.Language;
            IIdentifier        identifier = language.Identifier(PropertyChangedSimpleTypeName);
            ITypeName          typeName   = language.SimpleTypeName(identifier, language.None <ITypeArguments>());

            viewModel.IntroduceInterface(typeName);

            wrappedClass.Append(viewModel);
            string name = viewModel.Identifier.Name;

            viewModel = RebuildSolutionModel(wrappedClass, name);

            AddStubsHelper.CreateAllUnimplementedMembers(viewModel, new AddStubsOptions());

            return(RebuildSolutionModel(wrappedClass, name));
        }
Exemple #9
0
        private IClassDeclaration CreateInitialViewModel(IClassDeclaration classDeclaration, IFieldDeclaration fieldDeclaration, IConstructorDeclaration viewModelConstructor)
        {
            IConstructLanguage language  = classDeclaration.Language;
            IClassDeclaration  viewModel = language.Class(
                language.Modifiers(Modifiers.Public),
                language.None <IClassTypeParameters>(),
                language.None <ITypeName>(),
                new List <ITypeName>(),
                new List <IDeclaration>()
            {
                fieldDeclaration, viewModelConstructor
            });

            NamingPolicy classesPolicy = viewModel.PrimaryNamingPolicy(classDeclaration.FileModel.UserSettings);
            string       viewModelName = classesPolicy.MakeTypeNameUniqueInNamespace(classDeclaration, classDeclaration.Identifier.Name + "ViewModel");

            viewModel.Identifier = language.Identifier(viewModelName);
            return(viewModel);
        }
Exemple #10
0
        public override void Execute(SolutionModel solutionModel, SelectionContext context)
        {
            FileModel fileModel;
            CodeSpan  selection;

            if (!solutionModel.IsEditorSelection(context, out fileModel, out selection))
            {
                return;
            }

            IConstructEnumerable <IFieldDeclaration> fields = FindFields(fileModel, selection);

            if (fields.Exist())
            {
                IConstructLanguage language = fields.Language;

                foreach (IFieldDeclaration field in fields)
                {
                    IPropertyDeclaration property = language.Property(
                        language.None <IDocComment>(),
                        language.None <IAttributes>(),
                        language.Modifiers(Modifiers.Public),
                        language.TypeName(field.TypeName.Type),
                        language.None <IIdentifier>());

                    NamingPolicy propertyNamingPolicy = property.PrimaryNamingPolicy(fileModel.UserSettings);
                    string       propertyName         = propertyNamingPolicy.MakeMemberNameUniqueInScope(field, field.Identifier.Name);

                    property.Identifier = language.Identifier(propertyName);

                    IAccessor getter = language.FieldGetter(field.Identifier);
                    IAccessor setter = CreateSetter(language, propertyName, field);

                    property.Accessors = language.Enumerable(new List <IAccessor>()
                    {
                        getter, setter
                    });

                    field.EnclosingClass.Insert(property);
                }
            }
        }
        public override void Execute(SolutionModel solutionModel, SelectionContext context)
        {
            FileModel fileModel;
            CodeSpan  selection;

            if (!solutionModel.IsEditorSelection(context, out fileModel, out selection))
            {
                return;
            }

            IPropertyDeclaration propertyDeclaration = fileModel.InnerMost <IPropertyDeclaration>(selection);

            if (IsFieldBackedPropertyWithSetterInsideClass(propertyDeclaration) && EnclosingClassImplementsINotifyPropertyChanged(propertyDeclaration))
            {
                IConstructLanguage language             = propertyDeclaration.Language;
                string             methodInvocationName = language.Name == LanguageNames.CSharp ? "OnPropertyChanged" : "RaisePropertyChangedEvent";
                IMethodInvocation  methodInvocation     =
                    language.MethodInvocation(
                        language.None <IExpression>(),
                        language.Identifier(methodInvocationName),
                        language.None <ITypeArguments>(),
                        language.Arguments(
                            language.Argument(language.StringLiteral(propertyDeclaration.Identifier.Name))));

                IAccessor         setter            = propertyDeclaration.Setter();
                List <IStatement> ifBlockStatements = new List <IStatement>(setter.Block.ChildStatements);
                ifBlockStatements.Add(language.ExpressionStatement(methodInvocation));

                IIfStatement ifStatement =
                    language.IfStatement(
                        language.BinaryExpression(
                            language.MemberAccess(language.None <IExpression>(),
                                                  propertyDeclaration.BackingField().Identifier),
                            Operator.NotEqual,
                            language.Expression("value")),
                        language.Block(ifBlockStatements));

                IBlock newBlock = language.Block(ifStatement);
                setter.Block = newBlock;
            }
        }
        private IAccessor CreateSetter(IConstructLanguage language, string propertyName, IFieldDeclaration field)
        {
            string propertyChangedName = language.Name == LanguageNames.CSharp ? "OnPropertyChanged" : "RaisePropertyChangedEvent";

            IMethodInvocation onPropertyChanged = language.MethodInvocation(language.None<IExpression>(),
                language.Identifier(propertyChangedName),
                language.None<ITypeArguments>(),
                language.Arguments(
                    language.Argument(language.StringLiteral(propertyName))));

            IMemberAccess fieldUsage = language.MemberAccess(language.None<IExpression>(), field.Identifier);
            IExpression valueUsage = language.Expression("value");

            IStatement assignment = language.AssignmentStatement(fieldUsage, valueUsage);

            IIfStatement ifStatement =
                language.IfStatement(
                    language.BinaryExpression(fieldUsage,
                        Operator.NotEqual,
                        valueUsage),
                    language.Block(assignment, language.ExpressionStatement(onPropertyChanged)));

            IAccessor setter = language.Setter(language.Block(ifStatement));
            return setter;
        }
 private IFieldDeclaration CreateFieldToHoldWrappedClass(IConstructLanguage language, ITypeName typeName, IClassDeclaration classDeclaration)
 {
     IFieldDeclaration fieldDeclaration = language.Field(language.Modifiers(Modifiers.Private | Modifiers.Readonly), typeName);
     NamingPolicy fieldsNamingPolicy = fieldDeclaration.PrimaryNamingPolicy(classDeclaration.FileModel.UserSettings);
     string fieldName = fieldsNamingPolicy.ChangeNameAccordingToPolicy(classDeclaration.Identifier.Name, classDeclaration.SolutionModel);
     fieldDeclaration.Identifier = language.Identifier(fieldName);
     return fieldDeclaration;
 }
        private static IMethodDeclaration CreateVBInvocator(IEventDeclaration eventDeclaration, IModifiers modifiers,
            IList<IArgument> arguments, IList<IParameter> parameters, IConstructLanguage language)
        {
            IEventInvocation eventInvocation = language.New<IEventInvocation>();
            eventInvocation.DelegateInvocation =
                language.DelegateInvocation(
                    language.VariableAccess(eventDeclaration.Identifier),
                    language.Arguments(arguments));

            IMethodDeclaration method = language.Method(
                    language.None<IDocComment>(),
                    language.None<IAttributes>(),
                    modifiers,
                    language.TypeName(eventDeclaration.VoidTypeAtThisLocation()),
                    language.None<IMethodTypeParameters>(),
                    language.Parameters(parameters),
                    language.Block(
                        language.ExpressionStatement(eventInvocation)));

            NamingPolicy methodsNamingPolicy = method.PrimaryNamingPolicy(eventDeclaration.FileModel.UserSettings);
            string methodName = methodsNamingPolicy.ChangeNameAccordingToPolicy("Raise" + eventDeclaration.Identifier.Name + "Event",
                eventDeclaration.SolutionModel);

            method.Identifier = language.Identifier(methodName);

            return method;
        }
        private static void GenerateSecondParameterAndArgument(IEventDeclaration eventDeclaration, IParameter parameter, IConstructLanguage language, FileModel fileModel, IList<IArgument> arguments, IList<IParameter> parameters)
        {
            NamingPolicy parametersNamingPolicy = language.PrimaryNamingPolicyFor<IParameter>(fileModel.UserSettings);
            IType parameterType = eventDeclaration.TypeName.Type.As<IDelegateType>().ReplaceParameterTypesIn(parameter.Type);

            IParameter newParameter = language.Parameter(
                parameter.IsRef,
                parameter.IsOut,
                parameter.IsParams,
                language.TypeName(eventDeclaration.StringTypeAtThisLocation()),
                parameter.DefaultValue);

            string parameterName = parametersNamingPolicy.ChangeNameAccordingToPolicy("propertyName", parameter.SolutionModel);
            newParameter.Identifier = language.Identifier(parameterName);

            IObjectCreation objectCreation = language.ObjectCreation(
                language.TypeName(parameterType), language.Arguments(
                    language.Argument(
                        language.VariableAccess(newParameter.Identifier))));

            arguments.Add(
                language.Argument(
                    objectCreation));

            parameters.Add(newParameter);
        }