public static List <LocalVariableDeclaration> variables(this MethodDeclaration methodDeclaration) { var astVisitors = new AstVisitors(); methodDeclaration.AcceptVisitor(astVisitors, null); return(astVisitors.localVariableDeclarations); }
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); } }
protected ErrorKind CheckForJumpInstructions(MethodDeclaration method) { FindJumpInstructionsVisitor fjiv = new FindJumpInstructionsVisitor(method); method.AcceptVisitor(fjiv, null); return(fjiv.DoCheck()); }
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration) { var eligibleParameters = methodDeclaration.Parameters .Where(p => p.ParameterModifier != ParameterModifier.Out && p.ParameterModifier != ParameterModifier.Ref) .ToList(); if (eligibleParameters.Count == 0) { return; } var declarationResolveResult = ctx.Resolve(methodDeclaration) as MemberResolveResult; if (declarationResolveResult == null) { return; } var member = declarationResolveResult.Member; if (member.IsOverride || member.IsOverridable || member.ImplementedInterfaceMembers.Any()) { return; } var collector = new TypeCriteriaCollector(ctx); methodDeclaration.AcceptVisitor(collector); foreach (var parameter in eligibleParameters) { ProcessParameter(parameter, methodDeclaration.Body, collector); } }
protected static bool HasAssignment(MethodDeclaration method, Variable variable) { HasAssignmentsVisitor hav = new HasAssignmentsVisitor(variable.Name, variable.Type, variable.StartPos, variable.EndPos); method.AcceptVisitor(hav, null); return(hav.HasAssignment); }
public static List <InvocationExpression> invocations(this MethodDeclaration methodDeclaration) { var astVisitors = new AstVisitors(); methodDeclaration.AcceptVisitor(astVisitors, null); return(astVisitors.invocationExpressions); }
public static IList <PrimitiveExpression> AllPrimitiveExpressions(this MethodDeclaration md) { PrimitiveExpressionFinderVisitor pefv = new PrimitiveExpressionFinderVisitor(); md.AcceptVisitor(pefv, null); return(pefv.ExpressionsFound); }
public static bool Matches(this MethodDeclaration md_this, MethodDeclaration md) { AstComparisonVisitor cv = new AstComparisonVisitor(); md.AcceptVisitor(cv, md_this); return(cv.Match); }
public static Dictionary <string, List <LocalLookupVariable> > GetLookupTableWithParams(this MethodDeclaration md) { LookupTableVisitor v = new LookupTableVisitor(SupportedLanguage.CSharp, true); md.AcceptVisitor(v, null); return(v.Variables); }
// public void InsertCall() // { // string call = GenerateCode(CreateCaller(this.parentMethod, this.extractedMethod, this.returnedVariable), false); // StringBuilder builder = new StringBuilder(); // // foreach (LocalVariableDeclaration v in this.beforeCallDeclarations) { // builder.AppendLine(GenerateCode(v, false)); // } // // this.currentDocument.Replace(this.currentSelection.Offset, this.currentSelection.Length, builder.ToString() + "\r\n" + call); // } // // public void InsertAfterCurrentMethod() // { // IOutputAstVisitor outputVisitor = this.GetOutputVisitor(); // // using (SpecialNodesInserter.Install(this.specialsList, outputVisitor)) { // string code = "\r\n\r\n" + GenerateCode(this.extractedMethod, true); // // code = code.TrimEnd('\r', '\n', ' ', '\t'); // // Dom.IMember p = GetParentMember(this.textEditor, this.currentSelection.StartPosition.Line, this.currentSelection.StartPosition.Column); // // TextLocation loc = new ICSharpCode.TextEditor.TextLocation( // p.BodyRegion.EndColumn - 1, p.BodyRegion.EndLine - 1); // // int offset = textEditor.Document.PositionToOffset(loc); // // textEditor.Document.Insert(offset, code); // } // } protected static bool CheckForJumpInstructions(MethodDeclaration method, ISelection selection) { FindJumpInstructionsVisitor fjiv = new FindJumpInstructionsVisitor(method, selection); method.AcceptVisitor(fjiv, null); return(fjiv.IsOk); }
void txtNameTextChanged(object sender, EventArgs e) { declaration.Name = this.txtName.Text; IOutputAstVisitor visitor = this.generator.Invoke(); declaration.AcceptVisitor(visitor, null); this.txtPreview.Text = visitor.Text; }
bool HasReferencesInSelection(MethodDeclaration newMethod, Variable variable) { FindReferenceVisitor frv = new FindReferenceVisitor(CSharpNameComparer, variable.Name, newMethod.Body.StartLocation, newMethod.Body.EndLocation); newMethod.AcceptVisitor(frv, null); return(frv.Identifiers.Count > 0); }
public void CanBePerformedOnArbitrarilyDeepNodes() { const string codeText = @" using System; public class One { void Foo() { double w = 7; double l = 8; if (DateTime.Now.Day == 3) { Console.WriteLine(""stuff""); Console.WriteLine(""stuff""); } double area = l*w; } void Bar() { Console.WriteLine(""stuff""); } }"; var code_text_ast = AstMatchHelper.ParseToCompilationUnit(codeText); IndexableMethodFinderVisitor v = new IndexableMethodFinderVisitor(); code_text_ast.AcceptVisitor(v, null); MethodDeclaration method = v.Methods["Foo"]; FindFirstIfElseVisitor v2 = new FindFirstIfElseVisitor(); method.AcceptVisitor(v2, null); IfElseStatement ifelse_stmt = v2.IfElse; List <Statement> statements = ifelse_stmt.TrueStatement; Assert.AreEqual(1, statements.Count, "Expect TrueStatement to always return a single element, and it's a block."); Assert.IsInstanceOf <BlockStatement>(statements[0], "Expect TrueStatement to always return a single element, and it's a block."); BlockStatement block = (BlockStatement)statements[0]; CSharpMethodExtractor extractor = new CSharpMethodExtractor(); var success = extractor.Extract(method, new Window(0, 0), block.Children); Assert.IsTrue(success); Console.WriteLine(extractor.ExtractedMethod.Print()); MethodDeclaration expected_method = v.BarMethod; Assert.IsTrue(expected_method.Matches(extractor.ExtractedMethod), "The expected AST did not match the actual extracted AST.\nExpected: {0} \nActual:{1}", expected_method.Print(), extractor.ExtractedMethod.Print()); }
public static CSharpMethodBodyStatistics GetBodyStatistics(this MethodDeclaration declaration) { using (var writer = new StringWriter()) { var visitor = new CSharpOutputVisitor(writer, FormattingOptionsFactory.CreateAllman()); declaration.AcceptVisitor(visitor); var bodyAsString = writer.ToString(); return(new CSharpMethodBodyStatistics( bodyAsString.Split(new[] { Environment.NewLine }, StringSplitOptions.None).Length, bodyAsString.Length, bodyAsString.GetHashCode())); } }
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration) { var typeDeclaration = methodDeclaration.GetParent<TypeDeclaration>(); var writer = this.m_TypeWriters[typeDeclaration]; var modifiers = this.GetJavaModifiersAsList(methodDeclaration.Modifiers); var javaModifiers = this.ConvertModifierListToJavaModifiers(modifiers); writer.WriteLine(".method " + javaModifiers + " " + JavaSignature.CreateMethodSignature(methodDeclaration, this.m_Resolver.TypeResolveContext, false)); methodDeclaration.AcceptVisitor(new JavaMethodVisitor(this.m_Resolver, writer)); writer.WriteLine(".end method"); }
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration) { var typeDeclaration = methodDeclaration.GetParent <TypeDeclaration>(); var writer = this.m_TypeWriters[typeDeclaration]; var modifiers = this.GetJavaModifiersAsList(methodDeclaration.Modifiers); var javaModifiers = this.ConvertModifierListToJavaModifiers(modifiers); writer.WriteLine(".method " + javaModifiers + " " + JavaSignature.CreateMethodSignature(methodDeclaration, this.m_Resolver.TypeResolveContext, false)); methodDeclaration.AcceptVisitor(new JavaMethodVisitor(this.m_Resolver, writer)); writer.WriteLine(".end method"); }
IEnumerable <Variable> FromParameters(MethodDeclaration newMethod) { if (parentNode is ParametrizedNode) { foreach (ParameterDeclarationExpression pde in (parentNode as ParametrizedNode).Parameters) { FindReferenceVisitor frv = new FindReferenceVisitor(CSharpNameComparer, pde.ParameterName, newMethod.Body.StartLocation, newMethod.Body.EndLocation); newMethod.AcceptVisitor(frv, null); if (frv.Identifiers.Count > 0) { pde.ParamModifier &= ~(ParameterModifiers.Params); if (parentNode is MethodDeclaration) { yield return(new Variable((parentNode as MethodDeclaration).Body, pde)); } else if (parentNode is ConstructorDeclaration) { yield return(new Variable((parentNode as ConstructorDeclaration).Body, pde)); } else if (parentNode is PropertyDeclaration) { var p = parentNode as PropertyDeclaration; yield return(new Variable(p.BodyStart, p.BodyEnd, pde)); } else { throw new NotSupportedException("not supported!"); } } } } if (parentNode is PropertyDeclaration && IsInSetter(parentNode as PropertyDeclaration)) { PropertyDeclaration pd = parentNode as PropertyDeclaration; yield return(new Variable( new LocalLookupVariable( "value", pd.TypeReference, pd.SetRegion.StartLocation, pd.SetRegion.EndLocation, false, false, null, null, false ) )); } }
public static void FactorOutAlgorithmFields( Type algorithmType, MethodDeclaration method, MethodDeclaration initialize, ref string declarations) { var mappings = new Dictionary<string, string>(); foreach (var field in algorithmType.GetFields(BindingFlags.NonPublic | BindingFlags.Instance)) { if (field.GetCustomAttributes(typeof(FieldForGenerationAttribute), false).Length > 0) { mappings.Add(field.Name, "field_" + LayerCompiler.GenerateRandomIdentifier()); declarations += field.FieldType.FullName + " " + mappings[field.Name] + ";\r\n"; } } var factorOut = new FactorOutAlgorithmFieldsVisitor(mappings); method.AcceptVisitor(factorOut); if (initialize != null) initialize.AcceptVisitor(factorOut); }
IEnumerable <Variable> FromParameters(MethodDeclaration newMethod) { foreach (ParameterDeclarationExpression pde in parentNode.Parameters) { FindReferenceVisitor frv = new FindReferenceVisitor(CSharpNameComparer, pde.ParameterName /*, newMethod.Body.StartLocation, newMethod.Body.EndLocation*/); newMethod.AcceptVisitor(frv, null); if (frv.Identifiers.Count > 0) { pde.ParamModifier &= ~(ParameterModifiers.Params); if (parentNode is MethodDeclaration) { yield return(new Variable((parentNode as MethodDeclaration).Body, pde)); } else { throw new NotSupportedException("not supported!"); } } } }
public ExtractMethodForm(MethodDeclaration declaration, Func <IOutputAstVisitor> generator) { // // The InitializeComponent() call is required for Windows Forms designer support. // InitializeComponent(); SetTranslation(this); this.declaration = declaration; this.generator = generator; IOutputAstVisitor visitor = this.generator.Invoke(); body = declaration.Body; declaration.Body = new BlockStatement(); declaration.AcceptVisitor(visitor, null); this.txtName.Text = this.declaration.Name; this.txtPreview.Text = visitor.Text; this.txtName.SelectAll(); }
/// <summary> /// Refactors the names of parameters and their references so the /// method body can be copied directly into the output. /// </summary> public static void InlineInitialize(IAlgorithm algorithm, MethodDeclaration method) { if (algorithm == null) throw new ArgumentNullException("algorithm"); if (method == null) throw new ArgumentNullException("method"); var parameterContext = method.Parameters.ElementAt(0); // Replace properties. method.AcceptVisitor(new FindPropertiesVisitor { Algorithm = algorithm, ParameterContextName = parameterContext.Name }); // Replace identifiers. foreach (var i in method.Body.Descendants.Where(v => v is IdentifierExpression).Cast<IdentifierExpression>() ) { if (i.Identifier == "context") i.ReplaceWith(new ThisReferenceExpression()); } }
private MethodDeclaration MakePermutation(MethodDeclaration right, IEnumerable <PrimExpSet> prim_groups) { ResetNameCount(); right = right.DeepCopy(); var rights_primitives = right.AllPrimitiveExpressions(); foreach (var prim_grp in prim_groups) { var param_name = NextName(); var typeRef = new TypeReference(prim_grp.ValueType.FullName); right.Parameters.Add(new ParameterDeclarationExpression(typeRef, param_name)); var replacer = new PrimitiveReplacer(); foreach (var pos in prim_grp.Positions) { replacer.AddReplacement(rights_primitives[pos], new IdentifierExpression(param_name)); } right.AcceptVisitor(replacer, null); } return(right); }
protected void CreateReturnStatement(MethodDeclaration newMethod, List <VariableDeclaration> possibleReturnValues) { HasReturnStatementVisitor hrsv = new HasReturnStatementVisitor(); newMethod.AcceptVisitor(hrsv, null); if (hrsv.HasReturn) { if (this.parentNode is MethodDeclaration) { newMethod.TypeReference = (this.parentNode as MethodDeclaration).TypeReference; } if (this.parentNode is PropertyDeclaration) { newMethod.TypeReference = (this.parentNode as PropertyDeclaration).TypeReference; } if (this.parentNode is OperatorDeclaration) { newMethod.TypeReference = (this.parentNode as OperatorDeclaration).TypeReference; } } else { if (possibleReturnValues.Count > 0) { newMethod.TypeReference = possibleReturnValues[possibleReturnValues.Count - 1].TypeReference; newMethod.Body.Children.Add(new ReturnStatement(new IdentifierExpression(possibleReturnValues[possibleReturnValues.Count - 1].Name))); this.returnedVariable = possibleReturnValues[possibleReturnValues.Count - 1]; } else { newMethod.TypeReference = new TypeReference("System.Void", true); this.returnedVariable = null; } } }
public override void VisitMethodDeclaration(MethodDeclaration methodDeclaration) { var eligibleParameters = methodDeclaration.Parameters .Where(p => p.ParameterModifier != ParameterModifier.Out && p.ParameterModifier != ParameterModifier.Ref) .ToList(); if (eligibleParameters.Count == 0) return; var declarationResolveResult = ctx.Resolve(methodDeclaration) as MemberResolveResult; if (declarationResolveResult == null) return; var member = declarationResolveResult.Member; if (member.IsOverride || member.IsOverridable || member.ImplementedInterfaceMembers.Any()) return; var collector = new TypeCriteriaCollector(ctx); methodDeclaration.AcceptVisitor(collector); foreach (var parameter in eligibleParameters) { ProcessParameter(parameter, methodDeclaration.Body, collector); } }
public override void VisitMethodDeclaration (MethodDeclaration methodDeclaration) { base.VisitMethodDeclaration (methodDeclaration); var i = new Inline (); while (i.KeepGoing) { i.KeepGoing = false; methodDeclaration.AcceptVisitor (i); } }
/// <summary> /// Refactors the names of parameters and their references so the /// method body can be copied directly into the output. /// </summary> public static void InlineMethod(IAlgorithm algorithm, MethodDeclaration method, string outputName, string[] inputNames, string xStartOffset, string yStartOffset, string zStartOffset, string width, string height, string depth) { var parameterContext = method.Parameters.ElementAt(0); var parameterInputs = new ParameterDeclaration[method.Parameters.Count - 11]; for (var i = 1; i < method.Parameters.Count - 10; i++) { parameterInputs[i - 1] = method.Parameters.ElementAt(i); } var parameterOutput = method.Parameters.Reverse().ElementAt(9); var parameterX = method.Parameters.Reverse().ElementAt(8); var parameterY = method.Parameters.Reverse().ElementAt(7); var parameterZ = method.Parameters.Reverse().ElementAt(6); var parameterI = method.Parameters.Reverse().ElementAt(5); var parameterJ = method.Parameters.Reverse().ElementAt(4); var parameterK = method.Parameters.Reverse().ElementAt(3); var parameterWidth = method.Parameters.Reverse().ElementAt(2); var parameterHeight = method.Parameters.Reverse().ElementAt(1); var parameterDepth = method.Parameters.Reverse().ElementAt(0); // Replace properties. method.AcceptVisitor(new FindPropertiesVisitor { Algorithm = algorithm, ParameterContextName = parameterContext.Name }); // Replace identifiers. foreach (var i in method.Body.Descendants.Where(v => v is IdentifierExpression).Cast <IdentifierExpression>()) { if (i.Identifier == parameterX.Name) { i.ReplaceWith( new ParenthesizedExpression( new BinaryOperatorExpression( new IdentifierExpression("x"), BinaryOperatorType.Add, new BinaryOperatorExpression( new IdentifierExpression("i"), BinaryOperatorType.Add, new IdentifierExpression(xStartOffset) )))); } else if (i.Identifier == parameterY.Name) { i.ReplaceWith( new ParenthesizedExpression( new BinaryOperatorExpression( new IdentifierExpression("y"), BinaryOperatorType.Add, new BinaryOperatorExpression( new IdentifierExpression("j"), BinaryOperatorType.Add, new IdentifierExpression(yStartOffset) )))); } else if (i.Identifier == parameterZ.Name) { i.ReplaceWith( new ParenthesizedExpression( new BinaryOperatorExpression( new IdentifierExpression("z"), BinaryOperatorType.Add, new BinaryOperatorExpression( new IdentifierExpression("k"), BinaryOperatorType.Add, new IdentifierExpression(zStartOffset) )))); } else if (i.Identifier == parameterI.Name) { i.ReplaceWith( new ParenthesizedExpression( new BinaryOperatorExpression( new IdentifierExpression("i"), BinaryOperatorType.Add, new IdentifierExpression(xStartOffset) ))); } else if (i.Identifier == parameterJ.Name) { i.ReplaceWith( new ParenthesizedExpression( new BinaryOperatorExpression( new IdentifierExpression("j"), BinaryOperatorType.Add, new IdentifierExpression(yStartOffset) ))); } else if (i.Identifier == parameterK.Name) { i.ReplaceWith( new ParenthesizedExpression( new BinaryOperatorExpression( new IdentifierExpression("k"), BinaryOperatorType.Add, new IdentifierExpression(zStartOffset) ))); } else if (i.Identifier == parameterWidth.Name) { i.Identifier = width; } else if (i.Identifier == parameterHeight.Name) { i.Identifier = height; } else if (i.Identifier == parameterDepth.Name) { i.Identifier = depth; } else if (i.Identifier == parameterOutput.Name) { i.Identifier = outputName; } else if (parameterInputs.Count(v => v.Name == i.Identifier) > 0) { i.Identifier = inputNames.ElementAt(Array.FindIndex(parameterInputs, v => v.Name == i.Identifier)); } else if (i.Identifier == "context") { i.ReplaceWith(new ThisReferenceExpression()); } } }
/// <summary> /// Refactors the names of parameters and their references so the /// method body can be copied directly into the output. /// </summary> public static void InlineMethod( IAlgorithm algorithm, MethodDeclaration method, string outputName, string[] inputNames, Expression x, Expression y, Expression z, Expression i, Expression j, Expression k, Expression width, Expression height, Expression depth, Expression ox, Expression oy, Expression oz) { if (algorithm == null) throw new ArgumentNullException("algorithm"); if (method == null) throw new ArgumentNullException("method"); if (outputName == null) throw new ArgumentNullException("outputName"); if (inputNames == null) throw new ArgumentNullException("inputNames"); if (x == null) throw new ArgumentNullException("x"); if (y == null) throw new ArgumentNullException("y"); if (z == null) throw new ArgumentNullException("z"); if (i == null) throw new ArgumentNullException("i"); if (j == null) throw new ArgumentNullException("j"); if (k == null) throw new ArgumentNullException("k"); if (width == null) throw new ArgumentNullException("width"); if (height == null) throw new ArgumentNullException("height"); if (depth == null) throw new ArgumentNullException("depth"); if (ox == null) throw new ArgumentNullException("ox"); if (oy == null) throw new ArgumentNullException("oy"); if (oz == null) throw new ArgumentNullException("oz"); var parameterContext = method.Parameters.ElementAt(0); var parameterInputs = new ParameterDeclaration[method.Parameters.Count - 14]; for (var idx = 1; idx < method.Parameters.Count - 13; idx++) parameterInputs[idx - 1] = method.Parameters.ElementAt(idx); var parameterOutput = method.Parameters.Reverse().ElementAt(12); var parameterX = method.Parameters.Reverse().ElementAt(11); var parameterY = method.Parameters.Reverse().ElementAt(10); var parameterZ = method.Parameters.Reverse().ElementAt(9); var parameterI = method.Parameters.Reverse().ElementAt(8); var parameterJ = method.Parameters.Reverse().ElementAt(7); var parameterK = method.Parameters.Reverse().ElementAt(6); var parameterWidth = method.Parameters.Reverse().ElementAt(5); var parameterHeight = method.Parameters.Reverse().ElementAt(4); var parameterDepth = method.Parameters.Reverse().ElementAt(3); var parameterOX = method.Parameters.Reverse().ElementAt(2); var parameterOY = method.Parameters.Reverse().ElementAt(1); var parameterOZ = method.Parameters.Reverse().ElementAt(0); // Replace properties. method.AcceptVisitor(new FindPropertiesVisitor { Algorithm = algorithm, ParameterContextName = parameterContext.Name }); // Replace identifiers. var identifiers = method .Body .Descendants .Where(v => v is IdentifierExpression) .Cast<IdentifierExpression>() .ToArray(); foreach (var e in identifiers) { if (e.Identifier == parameterX.Name) e.ReplaceWith(x.Clone()); else if (e.Identifier == parameterY.Name) e.ReplaceWith(y.Clone()); else if (e.Identifier == parameterZ.Name) e.ReplaceWith(z.Clone()); else if (e.Identifier == parameterI.Name) e.ReplaceWith(i.Clone()); else if (e.Identifier == parameterJ.Name) e.ReplaceWith(j.Clone()); else if (e.Identifier == parameterK.Name) e.ReplaceWith(k.Clone()); else if (e.Identifier == parameterWidth.Name) e.ReplaceWith(width.Clone()); else if (e.Identifier == parameterHeight.Name) e.ReplaceWith(height.Clone()); else if (e.Identifier == parameterDepth.Name) e.ReplaceWith(depth.Clone()); else if (e.Identifier == parameterOX.Name) e.ReplaceWith(ox.Clone()); else if (e.Identifier == parameterOY.Name) e.ReplaceWith(oy.Clone()); else if (e.Identifier == parameterOZ.Name) e.ReplaceWith(oz.Clone()); else if (e.Identifier == parameterOutput.Name) e.Identifier = outputName; else if (parameterInputs.Count(v => v.Name == e.Identifier) > 0) e.Identifier = inputNames.ElementAt(Array.FindIndex(parameterInputs, v => v.Name == e.Identifier)); else if (e.Identifier == "context") e.ReplaceWith(new ThisReferenceExpression()); } }