void ConvertInterfaceImplementation(MethodDeclaration member) { // members without modifiers are already C# explicit interface implementations, do not convert them if (member.Modifier == Modifiers.None) return; while (member.InterfaceImplementations.Count > 0) { InterfaceImplementation impl = member.InterfaceImplementations[0]; member.InterfaceImplementations.RemoveAt(0); if (member.Name != impl.MemberName) { MethodDeclaration newMember = new MethodDeclaration { Name = impl.MemberName, TypeReference = member.TypeReference, Parameters = member.Parameters, Body = new BlockStatement() }; InvocationExpression callExpression = new InvocationExpression(new IdentifierExpression(member.Name)); foreach (ParameterDeclarationExpression decl in member.Parameters) { callExpression.Arguments.Add(new IdentifierExpression(decl.ParameterName)); } if (member.TypeReference.Type == "System.Void") { newMember.Body.AddChild(new ExpressionStatement(callExpression)); } else { newMember.Body.AddChild(new ReturnStatement(callExpression)); } newMember.InterfaceImplementations.Add(impl); InsertAfterSibling(member, newMember); } } }
protected override bool VerifyMethodCondition(TypeDeclaration typeDeclaration, MethodDeclaration methodDeclaration) { IList methods = AstUtil.GetChildrenWithType(typeDeclaration, typeof(MethodDeclaration)); string name = methodDeclaration.Name.Substring(3); if (Contains(methods, methodDeclaration)) { IList innerTypes = AstUtil.GetChildrenWithType(typeDeclaration, typeof(TypeDeclaration)); foreach (TypeDeclaration innerType in innerTypes) { if (innerType.Name == name) return true; } IList constructors = AstUtil.GetChildrenWithType(typeDeclaration, typeof(ConstructorDeclaration)); foreach (ConstructorDeclaration constructorDeclaration in constructors) { if (constructorDeclaration.Name == name) return true; } foreach (MethodDeclaration method in methods) { if (method.Name == name || char.ToUpper(method.Name[0]) + method.Name.Substring(1) == name) return true; } } else { IList properties = AstUtil.GetChildrenWithType(typeDeclaration, typeof(PropertyDeclaration)); return Contains(properties, name); } return false; }
protected bool IsMethodInExternalTypes(TypeDeclaration typeDeclaration, MethodDeclaration methodDeclaration) { bool found = false; foreach (TypeReference baseType in typeDeclaration.BaseTypes) { string fullName = GetFullName(baseType); if (!found && CodeBase.Types.Contains(fullName)) { TypeDeclaration baseTypeDeclaration = (TypeDeclaration) CodeBase.Types[fullName]; if (IsInExternalLibraries(fullName) || fullName.StartsWith("Helpers.")) { IList methods = AstUtil.GetChildrenWithType(baseTypeDeclaration, typeof(MethodDeclaration)); if (ContainsMethod(methods, methodDeclaration)) found = true; else found = IsMethodInExternalTypes(baseTypeDeclaration, methodDeclaration); } else found = IsMethodInExternalTypes(baseTypeDeclaration, methodDeclaration); if (found) break; } } return found; }
public override object VisitMethodDeclaration(MethodDeclaration declaration, object data) { if (!HasContainerType(declaration, ClassType.Interface) && declaration.InterfaceImplementations.Count == 0) MakePublic(declaration); return base.VisitMethodDeclaration(declaration, data); }
public override object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) { if (IsDerivedFrom(typeDeclaration, "Comparator")) { IList methods = AstUtil.GetChildrenWithType(typeDeclaration, typeof(MethodDeclaration)); MethodDeclaration equalsMethod = new MethodDeclaration("equals", Modifiers.Public, AstUtil.GetTypeReference("bool", typeDeclaration), new List<ParameterDeclarationExpression>(), null); equalsMethod.Parent = typeDeclaration; TypeReference argTypeReference = AstUtil.GetTypeReference("java.lang.Object", equalsMethod); argTypeReference.RankSpecifier = new int[] {}; equalsMethod.Parameters.Add(new ParameterDeclarationExpression(argTypeReference, "obj")); if (Contains(methods, equalsMethod)) { int index = IndexOf(methods, equalsMethod); MethodDeclaration method = (MethodDeclaration) methods[index]; AstUtil.RemoveModifierFrom(method, Modifiers.Abstract); method.TypeReference.Type = "bool"; CreateMethodImplementation(method); } else { CreateMethodImplementation(equalsMethod); typeDeclaration.Children.Add(equalsMethod); equalsMethod.Parent = typeDeclaration; } } return base.TrackedVisitTypeDeclaration(typeDeclaration, data); }
public override object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) { if (IsAbstractClass(typeDeclaration)) { IList currentClassMethods = AstUtil.GetChildrenWithType(typeDeclaration, typeof(MethodDeclaration)); currentClassMethods = GetMethodsInParents(typeDeclaration, currentClassMethods, true); IList methodsInParents = new ArrayList(); methodsInParents = GetMethodsInParents(typeDeclaration, methodsInParents, false); methodsInParents = FilterImplementedMethods(methodsInParents); IList abstractMethods = GetDiffList(currentClassMethods, methodsInParents); if (abstractMethods.Count > 0) { TypeDeclaration replacedTypeDeclaration = typeDeclaration; foreach (MethodDeclaration method in abstractMethods) { MethodDeclaration newMethod; newMethod = new MethodDeclaration(method.Name, Modifiers.Public | Modifiers.Abstract, method.TypeReference, method.Parameters, method.Attributes); newMethod.Parent = replacedTypeDeclaration; replacedTypeDeclaration.Children.Add(newMethod); } ReplaceCurrentNode(replacedTypeDeclaration); } } return base.TrackedVisitTypeDeclaration(typeDeclaration, data); }
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { if (methodDeclaration.Modifier.HasFlag(Modifiers.Abstract)) UnlockWith(methodDeclaration); return base.VisitMethodDeclaration(methodDeclaration, data); }
public override object VisitMethodDeclaration(AST.MethodDeclaration methodDeclaration, object data) { DomRegion region = GetRegion(methodDeclaration.StartLocation, methodDeclaration.EndLocation); DomRegion bodyRegion = GetRegion(methodDeclaration.EndLocation, methodDeclaration.Body != null ? methodDeclaration.Body.EndLocation : RefParser.Location.Empty); DefaultClass c = GetCurrentClass(); DefaultMethod method = new DefaultMethod(methodDeclaration.Name, null, ConvertModifier(methodDeclaration.Modifier), region, bodyRegion, GetCurrentClass()); method.Documentation = GetDocumentation(region.BeginLine, methodDeclaration.Attributes); ConvertTemplates(methodDeclaration.Templates, method); method.ReturnType = CreateReturnType(methodDeclaration.TypeReference, method); ConvertAttributes(methodDeclaration, method); if (methodDeclaration.Parameters != null && methodDeclaration.Parameters.Count > 0) { foreach (AST.ParameterDeclarationExpression par in methodDeclaration.Parameters) { method.Parameters.Add(CreateParameter(par, method)); } } else { method.Parameters = DefaultParameter.EmptyParameterList; } c.Methods.Add(method); return(null); }
public static MethodDeclaration add_Method(this TypeDeclaration typeDeclaration, string methodName, Dictionary<string, object> invocationParameters, BlockStatement body) { var newMethod = new MethodDeclaration { Name = methodName, //Modifier = Modifiers.None | Modifiers.Public | Modifiers.Static, Modifier = Modifiers.None | Modifiers.Public, Body = body }; newMethod.setReturnType(); if (invocationParameters != null) foreach (var invocationParameter in invocationParameters) { var parameterType = new TypeReference( (invocationParameter.Value != null && invocationParameter.Key != "returnData") ? invocationParameter.Value.typeFullName() : "System.Object", true); var parameter = new ParameterDeclarationExpression(parameterType, invocationParameter.Key); newMethod.Parameters.Add(parameter); } typeDeclaration.AddChild(newMethod); return newMethod; }
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { if (methodDeclaration.Name.ToLower().Equals("main") && !methodDeclaration.Modifier.HasFlag(Modifiers.Constructors)) { if (!methodDeclaration.IsExtensionMethod && !methodDeclaration.Modifier.HasFlag(Modifiers.Abstract)) { if (methodDeclaration.Parameters.Count==1) { ParameterDeclarationExpression param = methodDeclaration.Parameters[0]; if(param.ParameterName.Equals("args") && param.TypeReference.ToString().Equals("System.String[]")) { //now check if body uses argsparam //This is waaaaay to naive.... if(methodDeclaration.Body.ToString().Contains("args")) { UnlockWith(methodDeclaration); } } } } } return base.VisitMethodDeclaration(methodDeclaration, data); }
public override void GenerateCode(List<AbstractNode> nodes, IList items) { TypeReference stringReference = new TypeReference("System.String"); MethodDeclaration method = new MethodDeclaration("ToString", Modifiers.Public | Modifiers.Override, stringReference, null, null); method.Body = new BlockStatement(); Expression target = new FieldReferenceExpression(new TypeReferenceExpression(stringReference), "Format"); InvocationExpression methodCall = new InvocationExpression(target); StringBuilder formatString = new StringBuilder(); formatString.Append('['); formatString.Append(currentClass.Name); for (int i = 0; i < items.Count; i++) { formatString.Append(' '); formatString.Append(codeGen.GetPropertyName(((FieldWrapper)items[i]).Field.Name)); formatString.Append("={"); formatString.Append(i); formatString.Append('}'); } formatString.Append(']'); methodCall.Arguments.Add(new PrimitiveExpression(formatString.ToString(), formatString.ToString())); foreach (FieldWrapper w in items) { methodCall.Arguments.Add(new FieldReferenceExpression(new ThisReferenceExpression(), w.Field.Name)); } method.Body.AddChild(new ReturnStatement(methodCall)); nodes.Add(method); }
public object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { B.Method m = new B.Method(GetLexicalInfo(methodDeclaration)); m.Name = methodDeclaration.Name; m.Modifiers = ConvertModifier(methodDeclaration, B.TypeMemberModifiers.Private); ConvertAttributes(methodDeclaration.Attributes, m.Attributes); if (currentType != null) currentType.Members.Add(m); if (methodDeclaration.HandlesClause.Count > 0) { // TODO: Convert handles clauses to [Handles] attribute AddError(methodDeclaration, "Handles-clause is not supported."); } m.ExplicitInfo = ConvertInterfaceImplementations(methodDeclaration.InterfaceImplementations, methodDeclaration, m); if (methodDeclaration.Templates.Count > 0) { AddError(methodDeclaration, "Declaring generic methods is not supported."); } ConvertParameters(methodDeclaration.Parameters, m.Parameters); m.EndSourceLocation = GetEndLocation((INode)methodDeclaration.Body ?? methodDeclaration); m.ReturnType = ConvertTypeReference(methodDeclaration.TypeReference); m.Body = ConvertMethodBlock(methodDeclaration.Body); if (m.Name == "Main" && m.IsStatic && m.Parameters.Count <= 1 && (methodDeclaration.TypeReference.Type == "System.Void" || methodDeclaration.TypeReference.Type == "System.Int32")) { entryPointMethod = m; } return m; }
public override object TrackedVisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { TypeDeclaration typeDeclaration = (TypeDeclaration) methodDeclaration.Parent; if (methodDeclaration.Name.Length > 3) { if (IsAccessor(methodDeclaration, fields) || IsInterfaceOrAbstract(typeDeclaration) && ImplementInheritors(typeDeclaration, methodDeclaration) || ImplementSiblings(typeDeclaration, methodDeclaration)) { string name = GetPropertyName(methodDeclaration); TypeReference typeReference = GetAccessorTypeReference(methodDeclaration); IList properties = AstUtil.GetChildrenWithType(typeDeclaration, typeof(PropertyDeclaration)); PropertyDeclaration propertyDeclaration = GetProperty(properties, name, methodDeclaration.Modifier, typeReference); if (methodDeclaration.Name.StartsWith("set")) AddSetSection(propertyDeclaration, methodDeclaration, fields); else if (methodDeclaration.Name.StartsWith("get")) AddGetSection(propertyDeclaration, methodDeclaration, fields); AddToReferences(typeDeclaration, methodDeclaration.Name, propertyDeclaration.Name); if (!HasProperty(properties, name)) ReplaceCurrentNode(propertyDeclaration); else RemoveCurrentNode(); } } return base.TrackedVisitMethodDeclaration(methodDeclaration, data); }
public override object VisitMethodDeclaration(MethodDeclaration md, object data) { Push(); object result = base.VisitMethodDeclaration(md, data); Pop(); return result; }
public override object TrackedVisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { TypeDeclaration typeDeclaration = (TypeDeclaration) methodDeclaration.Parent; CheckForOverriding(typeDeclaration, methodDeclaration); return null; }
public IEnumerable<MethodDeclaration> FindCandidatesViaRefactoringPermutations(TargetInfo left, MethodDeclaration right) { right = right.DeepCopy(); /* * Steps to change one to match the other. * Get the lookup table for left. * Get the lookup table for right. * Loop through left, renaming the corresponding right var as you go (don't worry about collisions yet). * Compare. * * This is essentially a normalization of one to the other. */ Dictionary<string, List<LocalLookupVariable>> left_table = left.GetLookupTableWithParams(); Dictionary<string, List<LocalLookupVariable>> right_table = right.GetLookupTableWithParams(); if (left_table.Keys.Count == right_table.Keys.Count) { IDictionary<string, string> renames = new Dictionary<string, string>(); for (int i = 0; i < left_table.Count; i++) { var left_var_name = left_table.Keys.ToArray()[i]; var right_var_name = right_table.Keys.ToArray()[i]; // current name => new name renames.Add(right_var_name, left_var_name); } RenameLocalVariableRefactoring r = new RenameLocalVariableRefactoring(renames); right.AcceptVisitor(r, null); yield return right; } }
public void Equals() { string program = TestUtil.TypeMemberParse("public string Sentence(string title , string text);"); CompilationUnit cu = TestUtil.ParseProgram(program); NamespaceDeclaration ns = (NamespaceDeclaration) cu.Children[0]; TypeDeclaration ty = (TypeDeclaration) ns.Children[0]; MethodDeclaration pgMethod = (MethodDeclaration) ty.Children[0]; ParameterDeclarationExpression p1 = new ParameterDeclarationExpression(new TypeReference("string"), "title"); p1.TypeReference.RankSpecifier = new int[] {}; ParameterDeclarationExpression p2 = new ParameterDeclarationExpression(new TypeReference("string"), "text"); p2.TypeReference.RankSpecifier = new int[] {}; List<ParameterDeclarationExpression> argList = new List<ParameterDeclarationExpression>(); argList.Add(p1); argList.Add(p2); MethodDeclaration exMethod = new MethodDeclaration("Sentence", Modifiers.Public, new TypeReference("string"), argList, null); Assert.IsTrue(Equals(exMethod, pgMethod)); string program2 = TestUtil.TypeMemberParse("public string Sentence(string title , string[] text);"); cu = TestUtil.ParseProgram(program2); ns = (NamespaceDeclaration) cu.Children[0]; ty = (TypeDeclaration) ns.Children[0]; pgMethod = (MethodDeclaration) ty.Children[0]; Assert.IsFalse(Equals(exMethod, pgMethod)); }
public void HasReturnValue_HasNone() { var methodToTest = new MethodDeclaration(); var victim = new TestableMethodTemplate(methodToTest, null); Assert.IsFalse(victim.HasReturnValue); }
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { if (methodDeclaration.IsExtensionMethod) UnlockWith(methodDeclaration); return base.VisitMethodDeclaration(methodDeclaration, data); }
public bool Equals(MethodDeclaration firstMethod, MethodDeclaration secondMethod) { if (firstMethod.Name == secondMethod.Name) { if (firstMethod.Parameters.Count == secondMethod.Parameters.Count) { int index = 0; foreach (ParameterDeclarationExpression parameter in firstMethod.Parameters) { TypeReference parameterTypeReference = ((ParameterDeclarationExpression) secondMethod.Parameters[index]).TypeReference; string firstMethodParam = parameter.TypeReference.Type; if (firstMethodParam.IndexOf('.') != -1) firstMethodParam = firstMethodParam.Substring(firstMethodParam.LastIndexOf('.') + 1); string secondMethodParam = parameterTypeReference.Type; if (secondMethodParam.IndexOf('.') != -1) secondMethodParam = secondMethodParam.Substring(secondMethodParam.LastIndexOf('.') + 1); if ((firstMethodParam == secondMethodParam || AreEqualTypes(parameter.TypeReference, parameterTypeReference)) && parameter.TypeReference.RankSpecifier.Length == parameterTypeReference.RankSpecifier.Length) index++; else return false; } return true; } } return false; }
public override object TrackedVisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { if (ShouldStubMember(methodDeclaration.Name)) return base.TrackedVisitMethodDeclaration(methodDeclaration, data); else return null; }
public FindJumpInstructionsVisitor(MethodDeclaration method, ISelection selection) { this.method = method; this.selection = selection; this.labels = new List<LabelStatement>(); this.cases = new List<CaseLabel>(); }
public int CountAllExtractedMethods(MethodDeclaration right, int targetChildCount) { List<INode> children = right.Body.Children; var windows = AstMatchHelper.OscillateWindows(children.Count); return ProcessChildren(right, children, windows, targetChildCount); }
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { collectingUsedLabels = true; base.VisitMethodDeclaration(methodDeclaration, data); collectingUsedLabels = false; base.VisitMethodDeclaration(methodDeclaration, data); return null; }
public IEnumerable<CloneDesc> GetAllPossibleExtractedMethods(MethodDeclaration right, int targetChildCount) { List<INode> children = right.Body.Children; var windows = AstMatchHelper.OscillateWindows(children.Count); return ProcessChildren(right, children, windows, targetChildCount); }
public void GetTypeReference_Method() { var cut = AbstractMethodTemplate.CreateClassUnderTest(); var method = new MethodDeclaration { Name = "DoStuff", TypeReference = AbstractMethodTemplate.StringTypeReference }; var actual = Parent.RefactoryExtensions.GetTypeReference(method, cut); Assert.AreEqual(AbstractMethodTemplate.StringTypeReference, actual); }
/// <summary> /// Shows that the other two parameters are not necessary to this object. Exposed for testing. /// </summary> /// <param name="right"></param> /// <returns></returns> public IEnumerable<CloneDesc> FindCandidatesViaRefactoringPermutations(MethodDeclaration right) { var md = FindCandidates(right, -1); foreach (Holder h in md) { yield return new CloneDesc(h.md, Window.Null, new List<INode>()); } }
public void HasReturnValue_HasOne() { var methodToTest = new MethodDeclaration(); var retval = new TypeReference("string", new[] { 0 }); methodToTest.TypeReference = retval; var victim = new TestableMethodTemplate(methodToTest, null); Assert.IsTrue(victim.HasReturnValue); }
public void HasReturnValue_HasVoid() { var methodToTest = new MethodDeclaration(); var retval = new TypeReference("void"); methodToTest.TypeReference = retval; var victim = new TestableMethodTemplate(methodToTest, null); Assert.IsFalse(victim.HasReturnValue); }
public bool Contains(IList methodsList, MethodDeclaration method) { foreach (MethodDeclaration methodDeclaration in methodsList) { if (Equals(methodDeclaration, method)) return true; } return false; }
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) { if ((methodDeclaration.Body.StartLocation < new Location(startColumn + 1, startLine + 1)) && (methodDeclaration.Body.EndLocation > new Location(endColumn + 1, endLine + 1))) { this.member = methodDeclaration; } return base.VisitMethodDeclaration(methodDeclaration, data); }
public override object VisitMethodDeclaration(AST.MethodDeclaration methodDeclaration, object data) { DomRegion region = GetRegion(methodDeclaration.StartLocation, methodDeclaration.EndLocation); DomRegion bodyRegion = GetRegion(methodDeclaration.EndLocation, methodDeclaration.Body != null ? methodDeclaration.Body.EndLocation : RefParser.Location.Empty); DefaultClass currentClass = GetCurrentClass(); DefaultMethod method = new DefaultMethod(methodDeclaration.Name, null, ConvertModifier(methodDeclaration.Modifier), region, bodyRegion, currentClass); method.Documentation = GetDocumentation(region.BeginLine, methodDeclaration.Attributes); ConvertTemplates(methodDeclaration.Templates, method); method.ReturnType = CreateReturnType(methodDeclaration.TypeReference, method, TypeVisitor.ReturnTypeOptions.None); ConvertAttributes(methodDeclaration, method); method.IsExtensionMethod = methodDeclaration.IsExtensionMethod || method.Attributes.Any(att => att.AttributeType != null && att.AttributeType.FullyQualifiedName == "System.Runtime.CompilerServices.ExtensionAttribute"); if (methodDeclaration.Parameters.Count > 0) { foreach (AST.ParameterDeclarationExpression par in methodDeclaration.Parameters) { method.Parameters.Add(CreateParameter(par, method)); } } else { method.Parameters = DefaultParameter.EmptyParameterList; } if (methodDeclaration.HandlesClause.Count > 0) { foreach (string handlesClause in methodDeclaration.HandlesClause) { if (handlesClause.ToLowerInvariant().StartsWith("me.")) { method.HandlesClauses.Add(handlesClause.Substring(3)); } else if (handlesClause.ToLowerInvariant().StartsWith("mybase.")) { method.HandlesClauses.Add(handlesClause.Substring(7)); } else { method.HandlesClauses.Add(handlesClause); } } } else { method.HandlesClauses = EmptyList <string> .Instance; } AddInterfaceImplementations(method, methodDeclaration); currentClass.Methods.Add(method); return(null); }
public override object VisitMethodDeclaration(NR.MethodDeclaration methodDeclaration, object data) { this.VisitParametrizedNode(methodDeclaration, false); return(base.VisitMethodDeclaration(methodDeclaration, data)); }
internal void ExecuteIntroduceMethod(UnknownMethodResolveResult rr, Ast.Expression invocationExpr, ITextEditor editor, bool isNew, object result) { IClass targetClass = IsEqualClass(rr.CallingClass, rr.Target.GetUnderlyingClass()) ? rr.CallingClass : rr.Target.GetUnderlyingClass(); CodeGenerator gen = targetClass.ProjectContent.Language.CodeGenerator; IAmbience ambience = targetClass.ProjectContent.Language.GetAmbience(); ClassFinder finder = new ClassFinder(rr.CallingMember); ModifierEnum modifiers = ModifierEnum.None; bool isExtension = !targetClass.IsUserCode(); if (IsEqualClass(rr.CallingClass, targetClass)) { if (rr.CallingMember != null) { modifiers |= (rr.CallingMember.Modifiers & ModifierEnum.Static); } } else { if (isExtension) { if (isNew) { targetClass = rr.CallingClass; } else { targetClass = result as IClass; } } // exclude in Unit Test mode if (WorkbenchSingleton.Workbench != null) { editor = (FileService.OpenFile(targetClass.CompilationUnit.FileName) as ITextEditorProvider).TextEditor; } if (targetClass.ClassType != ClassType.Interface) { modifiers |= ModifierEnum.Public; } if (rr.IsStaticContext) { modifiers |= ModifierEnum.Static; } } NRefactoryResolver resolver = Extensions.CreateResolverForContext(targetClass.ProjectContent.Language, editor); IReturnType type = resolver.GetExpectedTypeFromContext(invocationExpr); Ast.TypeReference typeRef = CodeGenerator.ConvertType(type, finder); if (typeRef.IsNull) { if (invocationExpr.Parent is Ast.ExpressionStatement) { typeRef = new Ast.TypeReference("void", true); } else { typeRef = new Ast.TypeReference("object", true); } } Ast.MethodDeclaration method = new Ast.MethodDeclaration { Name = rr.CallName, Modifier = CodeGenerator.ConvertModifier(modifiers, finder), TypeReference = typeRef, Parameters = CreateParameters(rr, finder, invocationExpr as Ast.InvocationExpression).ToList(), }; if (targetClass.ClassType != ClassType.Interface) { method.Body = CodeGenerator.CreateNotImplementedBlock(); } RefactoringDocumentAdapter documentWrapper = new RefactoringDocumentAdapter(editor.Document); if (isExtension) { method.Parameters.Insert(0, new Ast.ParameterDeclarationExpression(CodeGenerator.ConvertType(rr.Target, finder), "thisInstance")); method.IsExtensionMethod = true; method.Modifier |= Ast.Modifiers.Static; } if (isNew) { Ast.TypeDeclaration newType = new Ast.TypeDeclaration(isExtension ? Ast.Modifiers.Static : Ast.Modifiers.None, null); newType.Name = result as string; newType.AddChild(method); gen.InsertCodeAfter(targetClass, documentWrapper, newType); } else { if (IsEqualClass(rr.CallingClass, targetClass)) { gen.InsertCodeAfter(rr.CallingMember, documentWrapper, method); } else { gen.InsertCodeAtEnd(targetClass.BodyRegion, documentWrapper, method); } } if (targetClass.ClassType == ClassType.Interface) { return; } ParseInformation info = ParserService.ParseFile(targetClass.CompilationUnit.FileName); if (info != null) { IMember newMember; if (isNew) { targetClass = info.CompilationUnit.Classes.FirstOrDefault(c => c.DotNetName == c.Namespace + "." + (result as string)); } else { targetClass = info.CompilationUnit.Classes.Flatten(c => c.InnerClasses).FirstOrDefault(c => c.DotNetName == targetClass.DotNetName); } if (targetClass == null) { return; } if (IsEqualClass(rr.CallingClass, targetClass)) { newMember = targetClass.GetInnermostMember(editor.Caret.Line, editor.Caret.Column); newMember = targetClass.AllMembers .OrderBy(m => m.BodyRegion.BeginLine) .ThenBy(m2 => m2.BodyRegion.BeginColumn) .First(m3 => m3.BodyRegion.BeginLine > newMember.BodyRegion.BeginLine); } else { newMember = targetClass.Methods.Last(); } IDocumentLine line = editor.Document.GetLine(newMember.BodyRegion.BeginLine + 2); int indentLength = DocumentUtilitites.GetWhitespaceAfter(editor.Document, line.Offset).Length; editor.Select(line.Offset + indentLength, "throw new NotImplementedException();".Length); } }
//DC public void mapMethod(NRefactoryAST.MethodDeclaration methodDeclaration, IMethod iMethod) { MethodDeclarationToIMethod.Add(methodDeclaration, iMethod); IMethodToMethodDeclaration.Add(iMethod, methodDeclaration); }