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());
}
}
