IEnumerable <CodeAction> GetActionsFromIdentifier(RefactoringContext context, IdentifierExpression identifier) { if (!(context.Resolve(identifier).IsError)) { yield break; } var methodName = identifier.Identifier; var guessedType = CreateFieldAction.GuessType(context, identifier); if (guessedType.Kind != TypeKind.Delegate) { yield break; } var invocationMethod = guessedType.GetDelegateInvokeMethod(); if (invocationMethod == null) { yield break; } var state = context.GetResolverStateBefore(identifier); if (state.CurrentMember == null || state.CurrentTypeDefinition == null) { yield break; } bool isStatic = state.CurrentMember.IsStatic || state.CurrentTypeDefinition.IsStatic; var service = (NamingConventionService)context.GetService(typeof(NamingConventionService)); if (service != null && !service.IsValidName(methodName, AffectedEntity.Method, Modifiers.Private, isStatic)) { yield break; } yield return(CreateAction( context, methodName, context.CreateShortType(invocationMethod.ReturnType), invocationMethod.Parameters.Select(parameter => new ParameterDeclaration(context.CreateShortType(parameter.Type), parameter.Name) { ParameterModifier = GetModifiers(parameter) }), false, isStatic, null)); }
static IEnumerable <ParameterDeclaration> ConvertParameters(RefactoringContext context, IList <IParameter> parameters) { foreach (var param in parameters) { ParameterModifier mod = ParameterModifier.None; if (param.IsOut) { mod = ParameterModifier.Out; } else if (param.IsRef) { mod = ParameterModifier.Ref; } else if (param.IsParams) { mod = ParameterModifier.Params; } yield return(new ParameterDeclaration(context.CreateShortType(param.Type), param.Name, mod)); } }
static VariableDeclarationStatement GetVariableDeclarationStatement(RefactoringContext context, out AstType resolvedType, CancellationToken cancellationToken = default(CancellationToken)) { var result = context.GetNode <VariableDeclarationStatement> (); if (result != null && result.Variables.Count == 1 && !result.Variables.First().Initializer.IsNull&& result.Variables.First().NameToken.Contains(context.Location.Line, context.Location.Column)) { var type = context.Resolve(result.Variables.First().Initializer).Type; if (type.Equals(SpecialType.NullType) || type.Equals(SpecialType.UnknownType)) { resolvedType = new PrimitiveType("object"); } else { resolvedType = context.CreateShortType(type); } return(result); } resolvedType = null; return(null); }
static Statement BuildAccessorStatement(RefactoringContext context, PropertyDeclaration pdecl) { if (pdecl.Setter.IsNull && !pdecl.Getter.IsNull) { var field = RemoveBackingStoreAction.ScanGetter(context, pdecl); if (field != null) { return(new ExpressionStatement(new AssignmentExpression(new IdentifierExpression(field.Name), AssignmentOperatorType.Assign, new IdentifierExpression("value")))); } } if (!pdecl.Setter.IsNull && pdecl.Getter.IsNull) { var field = RemoveBackingStoreAction.ScanSetter(context, pdecl); if (field != null) { return(new ReturnStatement(new IdentifierExpression(field.Name))); } } return(new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException")))); }
static CodeAction CreateAction(RefactoringContext context, string methodName, AstType returnType, IEnumerable <ParameterDeclaration> parameters, bool createInOtherType, bool isStatic, ResolveResult targetResolveResult) { return(new CodeAction(context.TranslateString("Create method"), script => { var decl = new MethodDeclaration() { ReturnType = returnType, Name = methodName, Body = new BlockStatement() { new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException"))) } }; decl.Parameters.AddRange(parameters); if (isStatic) { decl.Modifiers |= Modifiers.Static; } if (createInOtherType) { if (targetResolveResult.Type.Kind == TypeKind.Interface) { decl.Body = null; decl.Modifiers = Modifiers.None; } else { decl.Modifiers |= Modifiers.Public; } script.InsertWithCursor(context.TranslateString("Create method"), targetResolveResult.Type.GetDefinition(), decl); return; } script.InsertWithCursor(context.TranslateString("Create method"), Script.InsertPosition.Before, decl); })); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var indexer = context.GetNode <IndexerExpression>(); if (indexer == null) { yield break; } if (!(context.Resolve(indexer).IsError)) { yield break; } var state = context.GetResolverStateBefore(indexer); if (state.CurrentTypeDefinition == null) { yield break; } var guessedType = CreateFieldAction.GuessAstType(context, indexer); bool createInOtherType = false; ResolveResult targetResolveResult = null; targetResolveResult = context.Resolve(indexer.Target); createInOtherType = !state.CurrentTypeDefinition.Equals(targetResolveResult.Type.GetDefinition()); bool isStatic; if (createInOtherType) { if (targetResolveResult.Type.GetDefinition() == null || targetResolveResult.Type.GetDefinition().Region.IsEmpty) { yield break; } isStatic = targetResolveResult is TypeResolveResult; if (isStatic && targetResolveResult.Type.Kind == TypeKind.Interface || targetResolveResult.Type.Kind == TypeKind.Enum) { yield break; } } else { isStatic = indexer.Target is IdentifierExpression && state.CurrentMember.IsStatic; } yield return(new CodeAction(context.TranslateString("Create indexer"), script => { var decl = new IndexerDeclaration() { ReturnType = guessedType, Getter = new Accessor() { Body = new BlockStatement() { new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException"))) } }, Setter = new Accessor() { Body = new BlockStatement() { new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException"))) } }, }; decl.Parameters.AddRange(CreateMethodDeclarationAction.GenerateParameters(context, indexer.Arguments)); if (isStatic) { decl.Modifiers |= Modifiers.Static; } if (createInOtherType) { if (targetResolveResult.Type.Kind == TypeKind.Interface) { decl.Getter.Body = null; decl.Setter.Body = null; decl.Modifiers = Modifiers.None; } else { decl.Modifiers |= Modifiers.Public; } script.InsertWithCursor(context.TranslateString("Create indexer"), targetResolveResult.Type.GetDefinition(), decl); return; } script.InsertWithCursor(context.TranslateString("Create indexer"), Script.InsertPosition.Before, decl); })); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { VariableInitializer initializer; var eventDeclaration = GetEventDeclaration(context, out initializer); if (eventDeclaration == null) { yield break; } var type = (TypeDeclaration)eventDeclaration.Parent; var proposedHandlerName = "On" + char.ToUpper(initializer.Name [0]) + initializer.Name.Substring(1); if (type.Members.Any(m => m is MethodDeclaration && ((MethodDeclaration)m).Name == proposedHandlerName)) { yield break; } var resolvedType = context.Resolve(eventDeclaration.ReturnType).Type; if (resolvedType.Kind == TypeKind.Unknown) { yield break; } var invokeMethod = resolvedType.GetDelegateInvokeMethod(); if (invokeMethod == null) { yield break; } yield return(new CodeAction(context.TranslateString("Create event invocator"), script => { bool hasSenderParam = false; IEnumerable <IParameter> pars = invokeMethod.Parameters; if (invokeMethod.Parameters.Any()) { var first = invokeMethod.Parameters [0]; if (first.Name == "sender" /*&& first.Type == "System.Object"*/) { hasSenderParam = true; pars = invokeMethod.Parameters.Skip(1); } } const string handlerName = "handler"; var arguments = new List <Expression>(); if (hasSenderParam) { arguments.Add(eventDeclaration.HasModifier(Modifiers.Static) ? (Expression) new PrimitiveExpression(null) : new ThisReferenceExpression()); } bool useThisMemberReference = false; foreach (var par in pars) { arguments.Add(new IdentifierExpression(par.Name)); useThisMemberReference |= par.Name == initializer.Name; } var methodDeclaration = new MethodDeclaration() { Name = proposedHandlerName, ReturnType = new PrimitiveType("void"), Modifiers = eventDeclaration.HasModifier(Modifiers.Static) ? Modifiers.Static : Modifiers.Protected | Modifiers.Virtual, Body = new BlockStatement() { new VariableDeclarationStatement( UseExplictType ? eventDeclaration.ReturnType.Clone() : new PrimitiveType("var"), handlerName, useThisMemberReference ? (Expression) new MemberReferenceExpression(new ThisReferenceExpression(), initializer.Name) : new IdentifierExpression(initializer.Name) ), new IfElseStatement() { Condition = new BinaryOperatorExpression(new IdentifierExpression(handlerName), BinaryOperatorType.InEquality, new PrimitiveExpression(null)), TrueStatement = new ExpressionStatement(new InvocationExpression(new IdentifierExpression(handlerName), arguments)) } } }; foreach (var par in pars) { var typeName = context.CreateShortType(par.Type); var decl = new ParameterDeclaration(typeName, par.Name); methodDeclaration.Parameters.Add(decl); } script.InsertWithCursor( context.TranslateString("Create event invocator"), Script.InsertPosition.After, methodDeclaration ); })); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { //TODO: implement variable assignment & ctor param var varInit = context.GetNode <VariableInitializer>(); if (varInit != null) { AstType type = varInit.GetPrevNode() as AstType; if (type == null) { yield break; } if (varInit.Parent is FieldDeclaration) { yield break; } if (CannotExtractField(context, varInit)) { yield break; } yield return(new CodeAction(context.TranslateString("Assign to new field"), s => { var name = varInit.Name; AstType extractedType; if (type.IsMatch(varType)) { IType resolvedType = context.Resolve(varInit.Initializer).Type; extractedType = context.CreateShortType(resolvedType); } else { extractedType = (AstType)type.Clone(); } AstNode entityDeclarationNode = varInit.Parent; while (!(entityDeclarationNode is EntityDeclaration) || (entityDeclarationNode is Accessor)) { entityDeclarationNode = entityDeclarationNode.Parent; } var entity = (EntityDeclaration)entityDeclarationNode; bool isStatic = entity.HasModifier(Modifiers.Static); FieldDeclaration field = new FieldDeclaration() { Modifiers = isStatic ? Modifiers.Static : Modifiers.None, ReturnType = extractedType, Variables = { new VariableInitializer(name) } }; AstNode nodeToRemove = RemoveDeclaration(varInit) ? varInit.Parent : type; s.Remove(nodeToRemove, true); s.InsertWithCursor(context.TranslateString("Insert new field"), Script.InsertPosition.Before, field); s.FormatText(varInit.Parent); }, varInit)); } var idntf = context.GetNode <Identifier>(); if (idntf == null) { yield break; } var paramDec = idntf.Parent as ParameterDeclaration; if (paramDec != null) { var ctor = paramDec.Parent as ConstructorDeclaration; if (ctor == null) { yield break; } MemberReferenceExpression thisField = new MemberReferenceExpression(new ThisReferenceExpression(), idntf.Name, new AstType[] {}); var assign = new AssignmentExpression(thisField, AssignmentOperatorType.Assign, new IdentifierExpression(idntf.Name)); var statement = new ExpressionStatement(assign); var type = (idntf.GetPrevNode() as AstType).Clone(); FieldDeclaration field = new FieldDeclaration() { ReturnType = type.Clone(), Variables = { new VariableInitializer(idntf.Name) } }; yield return(new CodeAction(context.TranslateString("Assign to new field"), s => { s.InsertWithCursor(context.TranslateString("Insert new field"), Script.InsertPosition.Before, field); s.AddTo(ctor.Body, statement); }, paramDec)); } }
IEnumerable <CodeAction> GetActionsFromMemberReferenceExpression(RefactoringContext context, MemberReferenceExpression invocation) { if (!(context.Resolve(invocation).IsError)) { yield break; } var methodName = invocation.MemberName; var guessedType = CreateFieldAction.GuessType(context, invocation); if (guessedType.Kind != TypeKind.Delegate) { yield break; } var invocationMethod = guessedType.GetDelegateInvokeMethod(); var state = context.GetResolverStateBefore(invocation); if (state.CurrentTypeDefinition == null) { yield break; } ResolveResult targetResolveResult = context.Resolve(invocation.Target); bool createInOtherType = !state.CurrentTypeDefinition.Equals(targetResolveResult.Type.GetDefinition()); bool isStatic; if (createInOtherType) { if (targetResolveResult.Type.GetDefinition() == null || targetResolveResult.Type.GetDefinition().Region.IsEmpty) { yield break; } isStatic = targetResolveResult is TypeResolveResult; if (isStatic && targetResolveResult.Type.Kind == TypeKind.Interface || targetResolveResult.Type.Kind == TypeKind.Enum) { yield break; } } else { if (state.CurrentMember == null) { yield break; } isStatic = state.CurrentMember.IsStatic || state.CurrentTypeDefinition.IsStatic; } // var service = (NamingConventionService)context.GetService(typeof(NamingConventionService)); // if (service != null && !service.IsValidName(methodName, AffectedEntity.Method, Modifiers.Private, isStatic)) { // yield break; // } yield return(CreateAction( context, methodName, context.CreateShortType(invocationMethod.ReturnType), invocationMethod.Parameters.Select(parameter => new ParameterDeclaration(context.CreateShortType(parameter.Type), parameter.Name) { ParameterModifier = GetModifiers(parameter) }), createInOtherType, isStatic, targetResolveResult)); }
public static IEnumerable <ParameterDeclaration> GenerateParameters(RefactoringContext context, IEnumerable <Expression> arguments) { var nameCounter = new Dictionary <string, int>(); foreach (var argument in arguments) { var direction = ParameterModifier.None; AstNode node; if (argument is DirectionExpression) { var de = (DirectionExpression)argument; direction = de.FieldDirection == FieldDirection.Out ? ParameterModifier.Out : ParameterModifier.Ref; node = de.Expression; } else { node = argument; } var resolveResult = context.Resolve(node); string name = CreateBaseName(argument, resolveResult.Type); if (!nameCounter.ContainsKey(name)) { nameCounter [name] = 1; } else { nameCounter [name]++; name += nameCounter [name].ToString(); } var type = resolveResult.Type.Kind == TypeKind.Unknown || resolveResult.Type.Kind == TypeKind.Null ? new PrimitiveType("object") : context.CreateShortType(resolveResult.Type); yield return(new ParameterDeclaration(type, name) { ParameterModifier = direction }); } }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { if (!context.IsSomethingSelected) { yield break; } var selected = new List <AstNode>(context.GetSelectedNodes()); if (selected.Count != 1 || !(selected [0] is Expression)) { yield break; } var expr = selected [0] as Expression; var visitor = new SearchNodeVisitior(expr); var node = context.GetNode <BlockStatement>(); if (node != null) { node.AcceptVisitor(visitor); } yield return(new CodeAction(context.TranslateString("Declare local variable"), script => { var resolveResult = context.Resolve(expr); var guessedType = resolveResult.Type; if (resolveResult is MethodGroupResolveResult) { guessedType = GetDelegateType(context, ((MethodGroupResolveResult)resolveResult).Methods.First(), expr); } var name = CreateMethodDeclarationAction.CreateBaseName(expr, guessedType); var type = context.UseExplicitTypes ? context.CreateShortType(guessedType) : new SimpleType("var"); var varDecl = new VariableDeclarationStatement(type, name, expr.Clone()); var replaceNode = visitor.Matches.First() as Expression; if (replaceNode.Parent is ExpressionStatement) { script.Replace(replaceNode.Parent, varDecl); script.Select(varDecl.Variables.First().NameToken); } else { var containing = replaceNode.Parent; while (!(containing.Parent is BlockStatement)) { containing = containing.Parent; } script.InsertBefore(containing, varDecl); var identifierExpression = new IdentifierExpression(name); script.Replace(replaceNode, identifierExpression); script.Link(varDecl.Variables.First().NameToken, identifierExpression); } })); if (visitor.Matches.Count > 1) { yield return(new CodeAction(string.Format(context.TranslateString("Declare local variable (replace '{0}' occurrences)"), visitor.Matches.Count), script => { var resolveResult = context.Resolve(expr); var guessedType = resolveResult.Type; if (resolveResult is MethodGroupResolveResult) { guessedType = GetDelegateType(context, ((MethodGroupResolveResult)resolveResult).Methods.First(), expr); } var linkedNodes = new List <AstNode>(); var name = CreateMethodDeclarationAction.CreateBaseName(expr, guessedType); var type = context.UseExplicitTypes ? context.CreateShortType(guessedType) : new SimpleType("var"); var varDecl = new VariableDeclarationStatement(type, name, expr.Clone()); linkedNodes.Add(varDecl.Variables.First().NameToken); var first = visitor.Matches [0]; if (first.Parent is ExpressionStatement) { script.Replace(first.Parent, varDecl); } else { var containing = first.Parent; while (!(containing.Parent is BlockStatement)) { containing = containing.Parent; } script.InsertBefore(containing, varDecl); var identifierExpression = new IdentifierExpression(name); linkedNodes.Add(identifierExpression); script.Replace(first, identifierExpression); } for (int i = 1; i < visitor.Matches.Count; i++) { var identifierExpression = new IdentifierExpression(name); linkedNodes.Add(identifierExpression); script.Replace(visitor.Matches [i], identifierExpression); } script.Link(linkedNodes.ToArray()); })); } }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var property = context.GetNode <PropertyDeclaration>(); var field = RemoveBackingStoreAction.GetBackingField(context); if (field == null) { yield break; } var resolvedType = ReflectionHelper.ParseReflectionName("System.EventHandler").Resolve(context.Compilation); if (resolvedType == null) { yield break; } var type = (TypeDeclaration)property.Parent; yield return(new CodeAction(context.TranslateString("Create changed event"), script => { var eventDeclaration = CreateChangedEventDeclaration(context, property); var methodDeclaration = CreateEventInvocatorAction.CreateEventInvocator(context, type, eventDeclaration, eventDeclaration.Variables.First(), resolvedType.GetDelegateInvokeMethod(), false); var stmt = new ExpressionStatement(new InvocationExpression( new IdentifierExpression(methodDeclaration.Name), new MemberReferenceExpression(new TypeReferenceExpression(context.CreateShortType("System", "EventArgs")), "Empty") )); var task = script.InsertWithCursor( context.TranslateString("Create event invocator"), Script.InsertPosition.After, new AstNode[] { eventDeclaration, methodDeclaration } ); Action <Task> insertInvocation = delegate { script.InsertBefore(property.Setter.Body.RBraceToken, stmt); script.FormatText(stmt); }; if (task.IsCompleted) { insertInvocation(null); } else { task.ContinueWith(insertInvocation, TaskScheduler.FromCurrentSynchronizationContext()); } }, property.NameToken)); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var pexpr = context.GetNode <PrimitiveExpression>(); if (pexpr == null) { yield break; } var statement = context.GetNode <Statement>(); if (statement == null) { yield break; } var visitor = new DeclareLocalVariableAction.SearchNodeVisitior(pexpr); var node = context.GetNode <BlockStatement>(); if (node != null) { node.AcceptVisitor(visitor); } var resolveResult = context.Resolve(pexpr); yield return(new CodeAction(context.TranslateString("Create local constant"), script => { string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type); var service = (NamingConventionService)context.GetService(typeof(NamingConventionService)); if (service != null) { name = service.CheckName(context, name, AffectedEntity.LocalConstant); } var initializer = new VariableInitializer(name, pexpr.Clone()); var decl = new VariableDeclarationStatement() { Type = context.CreateShortType(resolveResult.Type), Modifiers = Modifiers.Const, Variables = { initializer } }; script.InsertBefore(statement, decl); var variableUsage = new IdentifierExpression(name); script.Replace(pexpr, variableUsage); script.Link(initializer.NameToken, variableUsage); })); yield return(new CodeAction(context.TranslateString("Create constant field"), script => { string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type); var service = (NamingConventionService)context.GetService(typeof(NamingConventionService)); if (service != null) { name = service.CheckName(context, name, AffectedEntity.ConstantField); } var initializer = new VariableInitializer(name, pexpr.Clone()); var decl = new FieldDeclaration() { ReturnType = context.CreateShortType(resolveResult.Type), Modifiers = Modifiers.Const, Variables = { initializer } }; var variableUsage = new IdentifierExpression(name); script.Replace(pexpr, variableUsage); // script.Link(initializer.NameToken, variableUsage); script.InsertWithCursor(context.TranslateString("Create constant"), Script.InsertPosition.Before, decl); })); if (visitor.Matches.Count > 1) { yield return(new CodeAction(string.Format(context.TranslateString("Create local constant (replace '{0}' occurrences)"), visitor.Matches.Count), script => { string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type); var service = (NamingConventionService)context.GetService(typeof(NamingConventionService)); if (service != null) { name = service.CheckName(context, name, AffectedEntity.LocalConstant); } var initializer = new VariableInitializer(name, pexpr.Clone()); var decl = new VariableDeclarationStatement() { Type = context.CreateShortType(resolveResult.Type), Modifiers = Modifiers.Const, Variables = { initializer } }; script.InsertBefore(statement, decl); var linkedNodes = new List <AstNode>(); linkedNodes.Add(initializer.NameToken); for (int i = 0; i < visitor.Matches.Count; i++) { var identifierExpression = new IdentifierExpression(name); linkedNodes.Add(identifierExpression); script.Replace(visitor.Matches [i], identifierExpression); } script.Link(linkedNodes.ToArray()); })); yield return(new CodeAction(string.Format(context.TranslateString("Create constant field (replace '{0}' occurrences)"), visitor.Matches.Count), script => { string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type); var service = (NamingConventionService)context.GetService(typeof(NamingConventionService)); if (service != null) { name = service.CheckName(context, name, AffectedEntity.ConstantField); } var initializer = new VariableInitializer(name, pexpr.Clone()); var decl = new FieldDeclaration() { ReturnType = context.CreateShortType(resolveResult.Type), Modifiers = Modifiers.Const, Variables = { initializer } }; var linkedNodes = new List <AstNode>(); linkedNodes.Add(initializer.NameToken); for (int i = 0; i < visitor.Matches.Count; i++) { var identifierExpression = new IdentifierExpression(name); linkedNodes.Add(identifierExpression); script.Replace(visitor.Matches [i], identifierExpression); } script.InsertWithCursor(context.TranslateString("Create constant"), Script.InsertPosition.Before, decl); })); } }
public static MethodDeclaration CreateEventInvocator(RefactoringContext context, TypeDeclaration declaringType, EventDeclaration eventDeclaration, VariableInitializer initializer, IMethod invokeMethod, bool useExplictType) { bool hasSenderParam = false; IEnumerable <IParameter> pars = invokeMethod.Parameters; if (invokeMethod.Parameters.Any()) { var first = invokeMethod.Parameters [0]; if (first.Name == "sender" /*&& first.Type == "System.Object"*/) { hasSenderParam = true; pars = invokeMethod.Parameters.Skip(1); } } const string handlerName = "handler"; var arguments = new List <Expression>(); if (hasSenderParam) { arguments.Add(eventDeclaration.HasModifier(Modifiers.Static) ? (Expression) new PrimitiveExpression(null) : new ThisReferenceExpression()); } bool useThisMemberReference = false; foreach (var par in pars) { arguments.Add(new IdentifierExpression(par.Name)); useThisMemberReference |= par.Name == initializer.Name; } var proposedHandlerName = GetNameProposal(initializer); var modifiers = eventDeclaration.HasModifier(Modifiers.Static) ? Modifiers.Static : Modifiers.Protected | Modifiers.Virtual; if (declaringType.HasModifier(Modifiers.Sealed)) { modifiers = Modifiers.None; } var methodDeclaration = new MethodDeclaration { Name = proposedHandlerName, ReturnType = new PrimitiveType("void"), Modifiers = modifiers, Body = new BlockStatement { new VariableDeclarationStatement( useExplictType ? eventDeclaration.ReturnType.Clone() : new PrimitiveType("var"), handlerName, useThisMemberReference ? (Expression) new MemberReferenceExpression(new ThisReferenceExpression(), initializer.Name) : new IdentifierExpression(initializer.Name) ), new IfElseStatement { Condition = new BinaryOperatorExpression(new IdentifierExpression(handlerName), BinaryOperatorType.InEquality, new PrimitiveExpression(null)), TrueStatement = new ExpressionStatement(new InvocationExpression(new IdentifierExpression(handlerName), arguments)) } } }; foreach (var par in pars) { var typeName = context.CreateShortType(par.Type); var decl = new ParameterDeclaration(typeName, par.Name); methodDeclaration.Parameters.Add(decl); } return(methodDeclaration); }
static void AddImplementation(RefactoringContext context, TypeDeclaration result, IType guessedType) { foreach (var property in guessedType.GetProperties()) { if (!property.IsAbstract) { continue; } if (property.IsIndexer) { var indexerDecl = new IndexerDeclaration { ReturnType = context.CreateShortType(property.ReturnType), Modifiers = GetModifiers(property), Name = property.Name }; indexerDecl.Parameters.AddRange(ConvertParameters(context, property.Parameters)); if (property.CanGet) { indexerDecl.Getter = new Accessor(); } if (property.CanSet) { indexerDecl.Setter = new Accessor(); } result.AddChild(indexerDecl, Roles.TypeMemberRole); continue; } var propDecl = new PropertyDeclaration { ReturnType = context.CreateShortType(property.ReturnType), Modifiers = GetModifiers(property), Name = property.Name }; if (property.CanGet) { propDecl.Getter = new Accessor(); } if (property.CanSet) { propDecl.Setter = new Accessor(); } result.AddChild(propDecl, Roles.TypeMemberRole); } foreach (var method in guessedType.GetMethods()) { if (!method.IsAbstract) { continue; } var decl = new MethodDeclaration { ReturnType = context.CreateShortType(method.ReturnType), Modifiers = GetModifiers(method), Name = method.Name, Body = new BlockStatement { new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException"))) } }; decl.Parameters.AddRange(ConvertParameters(context, method.Parameters)); result.AddChild(decl, Roles.TypeMemberRole); } foreach (var evt in guessedType.GetEvents()) { if (!evt.IsAbstract) { continue; } var decl = new EventDeclaration { ReturnType = context.CreateShortType(evt.ReturnType), Modifiers = GetModifiers(evt), Name = evt.Name }; result.AddChild(decl, Roles.TypeMemberRole); } }